dsh-memory-fitting

Ask first, act later · Memory Fitting

dsh-memory-fitting — It asks before it acts.

EN The agent predicts a few directions first, then asks in batches until one converges. 中文 你先别急着说清楚，让它先猜。猜错了你纠正，比从头描述便宜得多。

📖 User Guide · 🧪 Training Roadmap · Changelog

---

What this is

Most of the time, what blocks us isn't "we don't know how." It's "we can't say what we want."

You drop a line like "just make that part better, it feels off" and the agent can only guess. Guessing right is luck. Guessing wrong costs a full round of rework. The wasted tokens and your wasted time both go into guessing.

Memory Fitting flips the order:

Instead of letting the agent guess, let it put up targets first — then ask.

It writes down 3-5 directions you might want, then asks in batches about the places those directions still can't be told apart. After each round it re-weighs every direction and puts the updated list in front of you. Once it's clear enough, it proposes: "I read this as X — right?"

You never have to describe what you want. You only have to correct its guess. And correcting is far cheaper than describing.

---

How it works

① Predict  The agent writes down 3-5 directions you might want
           (each with: what it is, and what would be true if it's right)
                 ↓
② Compose  Design 2-4 questions for THIS round, aimed at
           the differences between directions — not at what's already known
                 ↓
③ Ask      await ctx.userQuestions.ask({ questions: [...] })
           One batch in, all answers back
                 ↓
④ Think    Digest the round → update directions (promote / drop / add / merge)
           【SHOW IT TO THE USER】← this step is not optional
                 ↓
          One direction clearly ahead and stable?
                 │                        │
                 no                       yes
                 │                        ↓
                 └──► back to ②   ⑤ Propose: "I read this as X" (+ the runners-up)
                                              ↓
                                       ⑥ You confirm → archive

Why step ④ cannot be skipped

Putting the agent's understanding in plain sight is the only substantive difference between this and "the agent asked a couple of things and then said it understood."

---

Interface

A floating panel in the bottom-right: Settings (default) · Archive · Start a fitting.

Positioning: its own column, so nothing overlaps

The bottom-right of DSH is already a stack (dsh-cua and Ark9Canvas each probe for the other's FAB, but are unaware of each other):

Our FAB sits at the very bottom of the stack; our panel moves to the left of the right-hand column and spans full height — completely clear of the `right:16` column, no overlap whether or not the others are open. On narrow screens (<900px) it degrades to a centered overlay.

---

Switches: all off by default

This plugin makes a point of not getting in your way. All three "contamination surface" switches are off by default:

Why off by default: on a shared API, every turn of injection costs token rent — and the more often you inject, the more the model's attention to it decays. The right strategy isn't "inject more," it's "make every injection count." So: no injection unless you ask for it.

You don't need to touch the switches to use it: click Start a fitting in the panel. No tools need to be visible to the model.

---

Where the data lives

~/.dsh/memory-fitting/
  config.json                              configuration
  sessions/<stamp>-<id>.jsonl              the whole fitting (append-only, never rewritten)
  sessions/index.json                      index (rebuildable)

Keep the process to yourself; send only the conclusion to memory. The full Q&A trace stays in local JSONL, immune to any other plugin's compaction. Only the converged conclusion goes to the memory plugin, and only if `writeMemory` is on.

Those archives aren't just logs — they are training-ready samples. See the Training Roadmap.

---

⚠️ The memory-write seatbelt

`src/node/sanitize.js` performs character-level rewriting on everything headed for the memory plugin.

Background: the write path in dsh-auto-memory does not filter the incoming body (\`appendAnchoredRecord\` only runs `parseAnchors` on the existing file). If a body ever contains the HTML-comment form of the memory anchor opening sequence, every subsequent write to that file is fail-closed — the entire memory file locks up.

Critically: escaping does not help. Backticks, code fences, HTML entities — none of it is understood. You must rephrase.

Because a fitting record naturally contains the user's own words, this plugin forces every archive through `guard()`. That is also why "raw user words go only to local JSONL, and only rewritten text reaches memory."

---

Install

dsh plugin --profile web add @a9i5k4/dsh-memory-fitting

Or manually: link the package into the profile's `node_modules` and add `@a9i5k4/dsh-memory-fitting` to `dsh.profile.bundles`.

After changing host-side code, re-run `node build.mjs` and restart dsh web.

---

Development

npm install       # esbuild is the only build dependency
npm run build     # → lib/index.js (node) + lib/client.js (browser)
npm test          # 51 regression checks
npm run verify    # dependency surface + safety self-check

Hard constraints by design

• Only a session root agent can start a fitting: a subagent passing `agent` hits `DELEGATED_CALLER`. This plugin passes `agent` through as optional and falls back to the global waterfall.
• `ctx.userQuestions` is deliberately not in `inject`: it's an optional capability. If it's missing, we degrade — we don't fail to load.
• Context injection uses imperatives + triggers, not descriptions. The model treats "background information" and "a constraint I must follow" at different depths; at equal token cost the latter moves output far more.
• Zero external deps on the node side, zero `require` on the client side — sidestepping "one missed require and the whole plugin fails to load."

---

Origin

This plugin is a port of the intent fitting stage from an SSVEP brain-computer-interface project.

In that setting the users were paralyzed: their only channel for expressing intent was EEG. The system couldn't wait for them to explain — it had to offer a small set of candidates repeatedly and infer intent from each choice, converging as it went.

Generalized: when a person's output bandwidth is low (can't articulate, hasn't decided, or simply won't) and the agent's prior is wide, raising targets before asking is far cheaper than guessing.

---

License

MIT © Aik358