klypix-mcp 1.83.0 → 1.85.0

package/A2A.md

@@ -113,6 +113,12 @@ If a write (`make_board`/`remember`) returns `input-required`, reply with a mess
 carrying the same `taskId` plus the missing input to **continue that task** (the
 server resumes it with a stable id and accumulated history).
 
+For `remember` or `learn_skill`, one-card requests may also provide `args.evidence`
+and `args.verify` using the [brain capture schema](README.md#capture-and-corrections).
+Such requests use the shared capture engine even without a marker. References and
+verification text are preserved; malformed metadata is rejected instead of discarded.
+Verification text is never executed.
+
 ## Notes
 
 - Tasks complete synchronously (the work is local file I/O), so `message/send`

package/FORMAT.md

@@ -132,6 +132,18 @@ strings: `text`, `box`, `image`, `file`, `container`, `approval`, `link`,
 `createdBy` (`user` | `agent`) and the optional `createdVia` (which agent/channel
 captured it) are the provenance bits the brain surfaces as badges and lenses.
 
+Brain cards may also carry `evidence` and `verify`. An evidence reference has `kind`
+(`file`, `pr`, `url`, `commit`, or `run`), `ref`, optional caller-supplied file blob `oid`,
+and optional caller-reported ISO `verifiedAt`. The host-neutral capture API rejects
+unknown input fields, unsafe file paths, and malformed metadata before writing.
+It adds `capturedAt`; readable local files up to 2 MiB also receive a SHA-256 `sha256`
+and `sourceBasis: "working-tree"`. Optional `headRevision` identifies HEAD at capture,
+which does not imply the captured working bytes were committed. Legacy `oid`-only
+references are read with both HEAD and working-file changes considered. These fields
+describe source provenance and change detection, never factual verification.
+`verify` is retained text, not executable configuration. All these optional fields
+survive the format codec and capture lifecycle; an explicit empty amendment clears them.
+
 The optional **`author`** answers the question a team actually asks: `createdBy` says
 *what* wrote a card, `author` says *whose*. It is resolved from `git config user.name`
 so brain attribution matches commit attribution with no configuration (override with

package/README.md

@@ -1,14 +1,28 @@
 # Every project gets a brain.
 
-**Active state management for multi-agent coding — a local-first active context engine with a shared brain.**
-*One project. One shared understanding.*
+Shared project memory for **Claude Code, Codex, Cursor** and other MCP coding tools. One
+`brain.klypix` file, committed with your code, carries the project's decisions, corrections and open
+questions across sessions and between tools. Corrections supersede stale decisions; sessions declare
+the files they expect to touch and get warned about same-machine overlap. Versioned in Git. Served
+over MCP by a process on your machine; Klypix uploads nothing (your agent's provider still receives
+what the agent reads). Integration depth differs by host — see
+[Supported hosts](#supported-hosts-and-their-integration-level).
 
-[![CI](https://img.shields.io/github/actions/workflow/status/dahshanlabs/klypix-mcp/ci.yml?branch=master&style=flat-square&label=CI)](https://github.com/dahshanlabs/klypix-mcp/actions/workflows/ci.yml)
-[![npm](https://img.shields.io/npm/v/klypix-mcp?style=flat-square)](https://www.npmjs.com/package/klypix-mcp)
-[![License](https://img.shields.io/github/license/dahshanlabs/klypix-mcp?style=flat-square)](LICENSE)
-[![Node](https://img.shields.io/node/v/klypix-mcp?style=flat-square)](package.json)
-[![MCP](https://img.shields.io/badge/MCP-server-475569?style=flat-square)](https://modelcontextprotocol.io)
-[![bench](https://img.shields.io/badge/npx_klypix--mcp_bench-10_writers_%C2%B7_0_lost-475569?style=flat-square)](BENCHMARKS.md)
+![Two real MCP sessions on one project: Session B declares a file Session A already declared, and the server's exact-file-overlap warning fires; Session A then records a correction that supersedes its stale card](docs/demo/demo.gif)
+
+<sub>Real output, not a mockup: both panes run a real MCP client against this server
+([docs/demo/](docs/demo/) — the GIF is rendered by CI from a scripted tape against this server, not
+hand-recorded, and re-rendered when the server's responses change).</sub>
+
+Run this inside your project:
+
+```bash
+npx klypix-mcp install
+```
+
+It creates `brain.klypix` if the project has none, wires the editors it finds on this machine,
+registers the `.klypix` merge driver if this is a git repo, and exits only after a real MCP
+handshake has counted the tools that answered.
 
 [![Claude Code](https://img.shields.io/badge/Claude_Code-5_lifecycle_hooks-475569?style=flat-square)](#supported-hosts-and-their-integration-level)
 [![Codex](https://img.shields.io/badge/Codex-native_MCP_%2B_presence-475569?style=flat-square)](#supported-hosts-and-their-integration-level)
@@ -18,24 +32,18 @@
 <sub>Host badges name the **integration level**, not a flat "compatible" — the levels and what is
 actually tested are in [Supported hosts](#supported-hosts-and-their-integration-level).</sub>
 
-**One actively managed project brain for multi-agent coding.** `klypix-mcp` keeps one versioned
-`brain.klypix` in your repo: the project's active state — current decisions, corrections, evidence
-anchors, open questions, active work, and handoffs. Corrections supersede stale decisions,
-`brain_challenge` tests proposed decisions against standing rules and reversed approaches, and
-sessions declare their scope and get warned about same-machine file overlap. Agents read it and
-write to it over MCP. You read it and correct it in the [KLYPIX app](https://klypix.com).
-
 > **One project. Many agents. One current understanding.**
 
-![Two real MCP sessions on one project: Session B declares a file Session A already declared, and the server's exact-file-overlap warning fires; Session A then records a correction that supersedes its stale card](docs/demo/demo.gif)
-
-<sub>Real output, not a mockup: both panes run a real MCP client against this server
-([docs/demo/](docs/demo/) — the GIF is re-rendered by CI from a scripted tape, so it can never
-drift from what the product actually does).</sub>
-
 Klypix does not launch, run, supervise, or replace your agents. It is not an agent runtime, a model
-router, a worktree manager, or a replacement for Git. It is the layer underneath them that holds
-what the project currently believes.
+router, a worktree manager, or a replacement for Git. It holds what the project currently believes.
+
+[![CI](https://img.shields.io/github/actions/workflow/status/dahshanlabs/klypix-mcp/ci.yml?branch=master&style=flat-square&label=CI)](https://github.com/dahshanlabs/klypix-mcp/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/klypix-mcp?style=flat-square)](https://www.npmjs.com/package/klypix-mcp)
+[![License](https://img.shields.io/github/license/dahshanlabs/klypix-mcp?style=flat-square)](LICENSE)
+[![Node](https://img.shields.io/node/v/klypix-mcp?style=flat-square)](package.json)
+[![MCP](https://img.shields.io/badge/MCP-server-475569?style=flat-square)](https://modelcontextprotocol.io)
+[![Glama score](https://glama.ai/mcp/servers/dahshanlabs/klypix-mcp/badges/score.svg)](https://glama.ai/mcp/servers/dahshanlabs/klypix-mcp)
+[![bench](https://img.shields.io/badge/npx_klypix--mcp_bench-10_writers_%C2%B7_0_lost-475569?style=flat-square)](BENCHMARKS.md)
 
 ## See the shared project brain in action
 
@@ -346,6 +354,30 @@ there are no lifecycle hooks on those hosts.
 
 ## Capture and corrections
 
+`brain_note` accepts structured supporting references and inert verification text:
+
+```json
+{
+  "text": "Retry failed uploads with a bounded backoff to preserve queued work.",
+  "area": "Storage",
+  "evidence": [{ "kind": "file", "ref": "src/uploads.mjs:42" }],
+  "verify": "node test/uploads.mjs"
+}
+```
+
+File references must stay inside the project. The capture records a fingerprint of the
+working file and, when available, the repository HEAD revision. An unchanged fingerprint
+means **source unchanged**, not that the remembered claim is correct or that tests passed.
+Dirty working files are fingerprinted as they are; HEAD alone does not describe those bytes.
+Read results distinguish changed, missing, and unverified sources. External references
+(`pr`, `url`, `commit`, `run`) are retained without fetching or verifying them. `verify` is
+shown as recorded text and never executed. Optional `verifiedAt` is explicitly caller-reported.
+
+On an amendment (`marker: "~"`), omitted metadata is preserved; `evidence: []` and
+`verify: ""` clear obsolete metadata. A resolve (`✓`) archives existing evidence; attach
+new evidence with a milestone and `closes`, or amend before resolving. The CLI accepts the
+same JSON on stdin, or `--evidence '<JSON array>'` and `--verify '<text>'`.
+
 On Claude Code, decisions are captured automatically at turn end from inline `🧠 BRAIN [Area]:`
 markers in the transcript, deduped, under a capture lock.
 
@@ -563,10 +595,10 @@ The MCP verbs below are what agents call. These are what **you** call:
 | `brain_ask` | Whole-brain question answering — correction-aware, `as_of` time travel |
 | `brain_challenge` | The brain argues back: contradictions with receipts, tried-and-reversed chains, standing rules, other-agent provenance flags |
 | `brain_note` | Capture with the full lifecycle — supersede / re-adopt / ✓ resolve / ~ update / 🛠 skill / `closes:` |
-| `brain_reconcile` | Proposes stale-vs-correction pairs and unrecorded migrations for a human to confirm |
+| `brain_reconcile` | Proposes stale-vs-correction pairs, unrecorded migrations, and the open cards a release ref's commits look to have closed — then closes the exact pairs you confirm |
 | `brain_insights` | Hubs, orphaned decisions, stale questions, area sizes |
 | `brain_lens` | Machine-readable freshness, provenance, activity, timeline, orrery and unresolved views |
-| `brain_garden` | Maintenance pass — proposes first, and cannot apply without an approval code the human generates |
+| `brain_garden` | Maintenance pass — proposes first; consolidation cannot apply without an approval code the human generates. The separate `repair:"duplicate-partials"` pass is dry-run first and needs no code (it removes only exact repeats and archives nothing) |
 | `brain_doctor` | Self-diagnosis: version, core/enhanced host adapters, active sessions, tool count, projection drift |
 | `brain_message` | Session-to-session coordination notes with a fixed send-time audience and per-recipient pending / offer / acknowledgement / consumption / failure receipts (24h TTL, never written into the brain) |
 | `brain_message_receipt` | Explicitly record model-side consumption using the exact message id and per-recipient offer token; acknowledgement alone never consumes a note |
@@ -589,8 +621,15 @@ Exactly 22, machine-verifiable with `npx klypix-mcp doctor`.
 > screenshot and no host-level test. Hosts without the extension get clean text, which is the path
 > that is actually verified.
 
-`brain_doctor`, `brain_lens`, `brain_insights` and `brain_reconcile` are read-only introspection.
-`brain_garden`, `brain_reconcile` and `brain_connect` always propose before they apply.
+`brain_doctor`, `brain_lens` and `brain_insights` are read-only introspection. `brain_reconcile`
+is read-only too, with one exception: on `mode:"claims"` and `mode:"release"` you may pass
+`confirm` / `dismiss` to close the pairs you verified. Confirm names exact card ids — nothing is
+matched by prose — and covering only part of a multi-item clause writes `✔ partial` and keeps the
+card open unless you pass `whole:true`. A call whose every entry is refused leaves the brain
+byte-identical. A `dismiss` is recorded as a `not_fulfilled` edge between two CARDS, so a hint
+whose only evidence is a raw commit has nothing to point at — name a `cardId`, or resolve the open
+card itself. `brain_garden`, `brain_reconcile` and `brain_connect` always propose before they
+apply.
 `npx klypix-mcp doctor` gives one verdict and exits non-zero on drift, so it doubles as a CI gate.
 
 ## One file you can hold

package/bin/klypix-a2a.mjs

@@ -327,14 +327,15 @@ async function runSkill(skill, args, text, via) {
       if (skill === 'learn_skill') marker = '+';
       const single = (!args.cards && text.trim()) ? stripVerb(text) : null;
       if (!marker && single && looksLikeSkill(single)) marker = '+';   // NL "remember this gotcha: always…" → skill
-      if (marker) {
+      if (marker || args.evidence !== undefined || args.verify !== undefined) {
         const noteText = single ?? (Array.isArray(args.cards) && args.cards[0]?.text) ?? '';
         if (!String(noteText).trim()) return needInput('Nothing to capture — send text or a card to remember.');
         if (String(noteText).length > 20_000) return needInput('Captured text must be 20,000 characters or fewer.');
         const requested = args.canvas ?? 'brain';
         const target = confinedCanvas(requested);
         if (!target.ok) return refusedCanvas(requested);
-        return await opBrainNote({ vault: VAULT, canvas: target.canvas, text: noteText, area: args.area, marker, closes: args.closes, via });
+        if (Array.isArray(args.cards) && args.cards.length !== 1) return needInput('Evidence capture requires exactly one card per request.');
+        return await opBrainNote({ vault: VAULT, canvas: target.canvas, text: noteText, area: args.area, marker, closes: args.closes, evidence: args.evidence, verify: args.verify, via });
       }
       // NL convenience: a bare "remember: X" becomes a single card on the brain.
       const cards = args.cards ?? (text.trim() ? [{ text: stripVerb(text) }] : null);

package/bin/klypix-install.mjs

@@ -254,7 +254,11 @@ const flatten = (code) => code
     // only thing standing between that and the field; it caught exactly this.
     // (remote-client deliberately absent: the Remote feature was removed in
     // 1.73.x, and this cherry-pick must not resurrect it — recorded rule.)
-    .replace(/\.\.\/src\/(bench|brain-doctor|agent-presence|agent-rules|capture-gap|enrichment|finding-routing|mcp-presence|mcp-supervisor|mcp-auto-update|presence-relay|semantic-memory|runtime-inspector|project-graph|git-capture-install)\.mjs/g, './$1.mjs')
+    // repo-state: the worker's release-cut reconcile advisory (1.85.0) imports
+    // commitsInRange / makeContainmentProbe from it. It was already STAGED in
+    // the flat bundle (mcp-presence needs it) but never flattened, because
+    // nothing in bin/ had imported it directly before.
+    .replace(/\.\.\/src\/(bench|brain-doctor|agent-presence|agent-rules|capture-gap|enrichment|finding-routing|mcp-presence|mcp-supervisor|mcp-auto-update|presence-relay|repo-state|semantic-memory|runtime-inspector|project-graph|git-capture-install)\.mjs/g, './$1.mjs')
     .replace(/klypix-worker\.mjs/g, 'klypix-mcp-worker.mjs')
     .replace(/const PKG_VERSION = \(\(\) => \{[\s\S]*?\}\)\(\);/, `const PKG_VERSION = '${VERSION}'; // baked at install (flat layout has no package.json)`);
 
@@ -391,7 +395,7 @@ try {
     // canvas-view-app.html is the canvas_view MCP App UI — staged raw (an HTML
     // file must never get a JS-comment banner) beside the flat server, which
     // resolves it via its ./canvas-view-app.html candidate path.
-    for (const f of ['global-brain-hook.mjs', 'capture-gap.mjs', 'brain-semantic.mjs', 'semantic-memory.mjs', 'enrichment.mjs', 'brain-note.mjs', 'brain-git-hook.mjs', 'git-capture-install.mjs', 'brain-history.mjs', 'brain-graveyard.mjs', 'klypix-format.mjs', 'klypix-core.mjs', 'brain-write-lock.mjs', 'agent-rules.mjs', 'brain-doctor.mjs', 'editor-detect.mjs', 'agent-presence.mjs', 'mcp-presence.mjs', 'repo-state.mjs', 'result-reconcile.mjs', 'finding-routing.mjs', 'presence-relay.mjs', 'mcp-supervisor.mjs', 'mcp-auto-update.mjs', 'runtime-inspector.mjs', 'project-graph.mjs', 'bench.mjs', 'codex-brain-hook.mjs', 'codex-hooks.mjs', 'canvas-view-app.html']) {
+    for (const f of ['global-brain-hook.mjs', 'capture-gap.mjs', 'brain-semantic.mjs', 'semantic-memory.mjs', 'enrichment.mjs', 'brain-note.mjs', 'brain-evidence.mjs', 'brain-git-hook.mjs', 'git-capture-install.mjs', 'brain-history.mjs', 'brain-graveyard.mjs', 'klypix-format.mjs', 'klypix-core.mjs', 'brain-write-lock.mjs', 'agent-rules.mjs', 'brain-doctor.mjs', 'editor-detect.mjs', 'agent-presence.mjs', 'mcp-presence.mjs', 'repo-state.mjs', 'result-reconcile.mjs', 'finding-routing.mjs', 'presence-relay.mjs', 'mcp-supervisor.mjs', 'mcp-auto-update.mjs', 'runtime-inspector.mjs', 'project-graph.mjs', 'bench.mjs', 'codex-brain-hook.mjs', 'codex-hooks.mjs', 'canvas-view-app.html']) {
         const s = path.join(SRC, f); if (exists(s)) staged.push({ dst: f, content: fs.readFileSync(s, 'utf8') });
     }
     for (const [src, dst] of [

package/bin/klypix-worker.mjs

@@ -34,6 +34,7 @@ import { compareProjectGraphResults, projectGraphContextMarkdown, queryProjectGr
 import { auditProject, compactAgentsBrief, linkProject, mcpServerEntry } from '../src/agent-rules.mjs';
 import { createMcpPresence, KLYPIX_MCP_INSTRUCTIONS } from '../src/mcp-presence.mjs';
 import { consumeMessageReceipt, findProjectBrain } from '../src/agent-presence.mjs';
+import { collectRepoState, commitsInRange, makeContainmentProbe } from '../src/repo-state.mjs';
 import {
   reconcileRegisteredProjects,
   registerProjectBrain,
@@ -219,6 +220,10 @@ const mcpPresence = createMcpPresence({
     formatDecayAge: typeof brainFormat.formatDecayAge === 'function' ? brainFormat.formatDecayAge : undefined,
   } : {},
 });
+// Release-cut reconcile: the ref each lane last scanned, so a checkpoint that
+// merely REFRESHES the same lease does not re-walk the range. In-memory only —
+// a worker restart rescans once, which costs one bounded git log.
+const lastReconcileRef = new Map();
 // Once brain_sync binds this connection to an exact project brain, all
 // project-brain-default tools must use that same file. Leaving canvas undefined
 // lets klypix-core's intentional cwd/env precedence substitute an ambient brain
@@ -627,18 +632,32 @@ server.registerTool('brain_connect', {
 }, async ({ canvas, apply, max, threshold, scope, pairs, relationship }) => toContent(await opBrainConnect({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), apply, max, threshold, scope, pairs, relationship, log })));
 
 server.registerTool('brain_reconcile', {
-  title: 'Reconcile the brain — contradictions between cards + unrecorded migrations',
-  description: 'Truth maintenance. (1) CONTRADICTIONS: finds same-subject live card pairs where one carries an explicit correction cue (uppercase "CORRECTION", "was WRONG", "OBSOLETE" — that side is the presumed truth, UNLESS the cue predates its counterpart: then the pair is marked "presumed superseded" and the newer card is presumed current — verify before retiring) or the two use opposite polarity words (deferred↔wired, broken↔fixed, dead↔live), i.e. stale facts whose correction never got linked — candidates only, YOU confirm each: retire the stale card via brain_note ✓. Dismiss a FALSE positive (either kind) by connecting the two ids with brain_connect pairs + relationship:"not_contradiction" — persisted, so it never resurfaces (and its cue stops overlaying recall/ask for that pair). (2) MIGRATIONS: lists committed migration files (Supabase / Rails / Prisma / Knex / generic) that NO brain card references, so an applied-but-unnarrated rollout can be recorded. (3) LEGACY: pre-v1.15 raw-bash ship cards to tidy. Reads ONLY the filesystem — never the database, never the network — and changes nothing. Run it periodically, or when recall surfaces something you believe is stale.',
+  title: 'Reconcile the brain — contradictions, unrecorded migrations, and what a release already closed',
+  description: 'Truth maintenance. (1) CONTRADICTIONS: finds same-subject live card pairs where one carries an explicit correction cue (uppercase "CORRECTION", "was WRONG", "OBSOLETE" — that side is the presumed truth, UNLESS the cue predates its counterpart: then the pair is marked "presumed superseded" and the newer card is presumed current — verify before retiring) or the two use opposite polarity words (deferred↔wired, broken↔fixed, dead↔live), i.e. stale facts whose correction never got linked — candidates only, YOU confirm each: retire the stale card via brain_note ✓. Dismiss a FALSE positive (either kind) by connecting the two ids with brain_connect pairs + relationship:"not_contradiction" — persisted, so it never resurfaces (and its cue stops overlaying recall/ask for that pair). (2) MIGRATIONS: lists committed migration files (Supabase / Rails / Prisma / Knex / generic) that NO brain card references, so an applied-but-unnarrated rollout can be recorded. (3) LEGACY: pre-v1.15 raw-bash ship cards to tidy. (4) RELEASE: which open cards look fulfilled by the commits a release ref already carries (subject+body coverage, the card\'s own #commit- receipt, or a hint edge whose milestone is in the ref). READ-ONLY by default and on every other mode. THE ONE EXCEPTION: on mode "claims" and mode "release" you may pass confirm/dismiss to actually close what you verified — confirm names exact card ids, so nothing is matched by prose; covering only part of a multi-item clause writes "✔ partial" and KEEPS the card open unless you pass whole:true; a call whose every entry is refused leaves the brain byte-identical. Never reads the database or the network. Run it periodically, when recall surfaces something you believe is stale, or right before cutting a release.',
   inputSchema: {
     canvas: z.string().optional().describe('Brain canvas filename/path. Defaults to the project brain ("brain").'),
-    root: z.string().optional().describe("Project root holding the migrations dir (default: the brain file's folder)."),
-    mode: z.enum(['all', 'contradictions', 'migrations', 'legacy', 'claims', 'plans']).optional().describe('Which pass to run (default "all"): contradictions · migrations · legacy (pre-v1.15 raw-bash ship cards to tidy) · claims (open "remaining:/next:" clauses a later milestone likely fulfilled — receipts + ✓ markers, never auto-archived) · plans (plan / proposal / "design decided" cards a LATER 🏁 appears to have built — embedding-first because the ship is usually renamed; receipts + ✓ markers, never auto-archived).'),
+    root: z.string().optional().describe("Project root holding the migrations dir / git repo (default: the brain file's folder)."),
+    mode: z.enum(['all', 'contradictions', 'migrations', 'legacy', 'claims', 'plans', 'release']).optional().describe('Which pass to run (default "all"): contradictions · migrations · legacy (pre-v1.15 raw-bash ship cards to tidy) · claims (open "remaining:/next:" clauses a later milestone likely fulfilled — receipts + ✓ markers; confirm with {id, milestoneId}) · plans (plan / proposal / "design decided" cards a LATER 🏁 appears to have built — embedding-first because the ship is usually renamed) · release (open cards the commits in `ref` look to have fulfilled; confirm with {id, sha}).'),
+    ref: z.string().max(200).optional().describe('mode "release": the git ref being cut. Defaults to this session\'s active release lease, else HEAD.'),
+    sinceRef: z.string().max(200).optional().describe('mode "release": the baseline the range starts from. Defaults to the highest release-shaped tag in the repo.'),
+    confirm: z.array(z.object({
+      id: z.string().max(64).describe('The OPEN card id to close.'),
+      milestoneId: z.string().max(64).optional().describe('mode "claims": the live milestone card that fulfilled it. Requires an existing "likely closed by" link or a current coverage gap on this exact pair.'),
+      sha: z.string().max(40).optional().describe('mode "release": a commit the listing named as covering this card (cov ≥ 0.6, confirmable). Omit to use the card\'s own #commit- receipt.'),
+      whole: z.boolean().optional().describe('Assert the WHOLE card is done. Without it, covering one item of a multi-item clause writes "✔ partial" and the card stays open.'),
+    })).max(64).optional().describe('Pairs YOU verified. Honoured on mode "claims" and mode "release" only. Each confirmed card is stamped ✅, archived, and arrowed "closed by" to its evidence.'),
+    dismiss: z.array(z.object({
+      openId: z.string().max(64).describe('The open card the hint was wrong about.'),
+      cardId: z.string().max(64).optional().describe('The milestone/evidence card to dismiss it against (required unless the listing already named one).'),
+      sha: z.string().max(40).optional().describe('Informational only — the commit that produced the wrong hint. A dismissal is recorded against a CARD, so a hint whose only evidence is a raw commit (no milestone card) cannot be dismissed: pass a cardId, or retire the open card itself.'),
+    })).max(64).optional().describe('Wrong hints to retire permanently as "not_fulfilled" edges between two CARDS — never re-suggested by claims, release, or the self-heal. A card-to-card pair is what makes the dismissal durable; a coverage hint built straight from a commit has no card to point at and will be re-listed at the next release cut until the open card is resolved or the pair is named with a cardId.'),
+    note: z.string().max(400).optional().describe('One line of why, echoed in the receipt.'),
   },
-}, async ({ canvas, root, mode }) => toContent(await opBrainReconcile({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), root, mode, log })));
+}, async ({ canvas, root, mode, ref, sinceRef, confirm, dismiss, note }) => toContent(await opBrainReconcile({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), root, mode, ref, sinceRef, confirm, dismiss, note, log })));
 
 server.registerTool('brain_garden', {
   title: 'Garden the brain — consolidate over-grown areas (sleep-time compute)',
-  description: 'Tidy an over-grown brain WITHOUT losing anything — SMART and non-invasive: it only consolidates DORMANT cards (old + peripheral), never load-bearing ones. Two phases: call it with no apply to get the areas that have accumulated forgotten cards (deterministic: >3 cards that are older than 14 days, beyond the area\'s newest 8, AND have ≤1 connection — so hubs and still-referenced decisions are left untouched; Focus/Instructions/Archive/Open-questions areas protected) plus their card text; YOU write one tight synthesis per area; then call again with apply:true, syntheses:[{title, synthesis}] AND the human\'s 8-char `approve` code (apply is REFUSED without it — you are never shown the code; the human generates it with `npx klypix-mcp garden-code` after reviewing your plan). Each area gets a 🌿 synthesis card, the originals are stamped "⤵ consolidated", moved to Archive, and arrowed to the synthesis — nothing is deleted, and one undo un-gardens. Run it when brain_insights or the brief shows an area has grown noisy.',
+  description: 'Tidy an over-grown brain WITHOUT losing anything — SMART and non-invasive: it only consolidates DORMANT cards (old + peripheral), never load-bearing ones. Two phases: call it with no apply to get the areas that have accumulated forgotten cards (deterministic: >3 cards that are older than 14 days, beyond the area\'s newest 8, AND have ≤1 connection — so hubs and still-referenced decisions are left untouched; Focus/Instructions/Archive/Open-questions areas protected) plus their card text; YOU write one tight synthesis per area; then call again with apply:true, syntheses:[{title, synthesis}] AND the human\'s 8-char `approve` code (apply is REFUSED without it — you are never shown the code; the human generates it with `npx klypix-mcp garden-code` after reviewing your plan). Each area gets a 🌿 synthesis card, the originals are stamped "⤵ consolidated", moved to Archive, and arrowed to the synthesis — nothing is deleted, and one undo un-gardens. Run it when brain_insights or the brief shows an area has grown noisy. SEPARATE PASS: `repair:"duplicate-partials"` lists (and with apply:true collapses) cards that carry the SAME `✔ partial` note more than once — the residue of a partial ✓ on a card that stays live by design. It keeps the earliest note of each distinct body and removes only exact repeats, so nothing is archived, nothing is deleted, no synthesis and no approval code are needed, and a second run finds nothing.',
   inputSchema: {
     canvas: z.string().optional().describe('Brain canvas filename/path. Defaults to the project brain ("brain").'),
     apply: z.boolean().optional().describe('false (default) = list over-grown areas + cards to synthesize; true = consolidate using the supplied syntheses.'),
@@ -647,8 +666,9 @@ server.registerTool('brain_garden', {
       synthesis: z.string().describe('3-6 sentence prose synthesis preserving every still-relevant fact/decision/number.'),
     })).optional().describe('Required when apply:true — one entry per area you want consolidated.'),
     approve: z.string().optional().describe('Required when apply:true — the 8-char human-approval code. You are never shown it: the human runs `npx klypix-mcp garden-code` and pastes the code into chat after reviewing your plan. Never guess or fabricate it.'),
+    repair: z.enum(['duplicate-partials']).optional().describe('Run a targeted repair instead of the consolidation pass. "duplicate-partials" collapses repeated ✔ partial notes on a card to the earliest one — lossless, idempotent, no syntheses and no approval code. Dry-run by default; apply:true writes.'),
   },
-}, async ({ canvas, apply, syntheses, approve }) => toContent(await opBrainGarden({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), apply, syntheses, approve })));
+}, async ({ canvas, apply, syntheses, approve, repair }) => toContent(await opBrainGarden({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), apply, syntheses, approve, repair })));
 
 server.registerTool('create_canvas', {
   title: 'Create a KLYPIX canvas',
@@ -684,6 +704,13 @@ server.registerTool('brain_note', {
     marker: z.enum(['', '?', '!', '+', '✓', '~']).optional().describe('(none)=decision · ?=open question · !=milestone · +=🛠️ skill (reusable how-to/gotcha; always resurfaces, never ages out) · ✓=resolve+archive the best-matching card · ~=update the matching card in place. Default: decision.'),
     area: z.string().optional().describe('Area/topic — routes the card into that titled container and becomes a #tag (e.g. "Auth", "Release").'),
     closes: z.string().optional().describe('Title or [[wikilink]] of a strategy/question card this note fulfils — resolves+archives it and draws a "closed by" arrow.'),
+    evidence: z.array(z.object({
+      kind: z.enum(['file', 'pr', 'url', 'commit', 'run']),
+      ref: z.string().min(1).max(1000).describe('A project-relative file path (optional :line or #Lline), or an external reference. External references are stored without fetching them.'),
+      oid: z.string().optional().describe('Optional full file blob hash from Git; a caller-supplied anchor, not proof of the claim.'),
+      verifiedAt: z.string().optional().describe('Optional caller-reported ISO verification date/time; not independently verified.'),
+    }).strict()).max(16).optional().describe('Supporting references. File bytes are fingerprinted as captured working-tree sources; hashes only detect source changes. On ~, [] clears evidence. Not accepted on resolve; use a milestone with closes to attach new evidence.'),
+    verify: z.string().max(2000).optional().describe('Verification instructions or command text to retain and display. Never executed by KLYPIX. On ~, an empty string clears it.'),
     guard: z.object({
       when: z.object({
         tool: z.string().max(200).optional().describe('Regex matched against the tool name (e.g. "Bash", "Edit|Write").'),
@@ -697,10 +724,10 @@ server.registerTool('brain_note', {
     }).optional().describe("GUARD CARDS: make this '+' skill fire BEFORE a matching tool call runs (Claude Code PreToolUse denies on severity block; other hosts warn), not just resurface in briefs. The card stays a normal 🛠️ rule — ✓-resolving it retires the guard, ~ with {remove:true} disarms it."),
     canvas: z.string().optional().describe('Brain canvas filename/path. Defaults to the project brain ("brain").'),
   },
-}, async ({ text, marker, area, closes, guard, canvas }, extra) => {
+}, async ({ text, marker, area, closes, evidence, verify, guard, canvas }, extra) => {
   // Both 1.77 and 1.78 ride this call: the enrichment question (the asker's
   // vocabulary for retrieval) AND the per-session capture receipt below.
-  const result = await opBrainNote({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), text, area, marker: marker || '', closes, guard, via: extra.klypixClientName, enrichmentQuestion: mcpPresence.declaredIntent });
+  const result = await opBrainNote({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), text, area, marker: marker || '', closes, evidence, verify, guard, via: extra.klypixClientName, enrichmentQuestion: mcpPresence.declaredIntent });
   // Per-session capture receipt — this is what stops the uncaptured-work nudge
   // from firing at a session that DID record its reasoning, just through MCP
   // rather than a 🧠 marker. The Stop hook and this server share one session-id
@@ -708,7 +735,7 @@ server.registerTool('brain_note', {
   // hook reads. Best-effort: a receipt failure must never fail the note.
   try {
     const { recordSessionCapture } = await import('../src/capture-gap.mjs');
-    recordSessionCapture(extra?.klypixRequestIdentity?.sessionId || mcpPresence.id);
+    if (!result.isError) recordSessionCapture(extra?.klypixRequestIdentity?.sessionId || mcpPresence.id, undefined, Date.now(), { project: mcpPresence.vault });
   } catch { /* receipt is best-effort */ }
   return toContent(result);
 });
@@ -901,6 +928,71 @@ server.registerTool('brain_sync', {
       }
     } catch { /* observation is best-effort — never fail a sync */ }
   }
+  // ── Release-cut reconcile advisory (1.85.0) ─────────────────────────────────
+  // A release lease was just GRANTED, so this session is about to cut a build.
+  // The one question nobody ever asked at that moment: does anything still open
+  // in the brain look like it ALREADY SHIPPED in this ref? Advisory only — it
+  // never blocks, never writes, never joins the refusal object, and any git or
+  // brain failure degrades to `{ skipped }` rather than failing a sync.
+  //
+  // Recomputed only on a NEW lease or a CHANGED ref (the worker is long-lived;
+  // a restart rescans once, which is acceptable) so a checkpoint refresh every
+  // few minutes does not re-walk 500 commits.
+  let releaseReconcileText = '';
+  {
+    const lease = report.structured?.releaseLease;
+    const granted = lease && (lease.status === 'taken' || lease.status === 'refreshed');
+    const ref = granted ? String(lease.holder?.ref || '').trim() : '';
+    const laneKey = `${String(report.structured?.project || mcpPresence.vault || '').toLowerCase()}|${String(mcpPresence.id || '')}`;
+    if (granted && ref && lastReconcileRef.get(laneKey) !== ref) {
+      lastReconcileRef.set(laneKey, ref);
+      const projectDir = report.structured?.project || mcpPresence.vault;
+      const brainPath = report.structured?.brain;
+      try {
+        const { execFileSync } = await import('child_process');
+        const repoState = (() => { try { return collectRepoState(projectDir); } catch { return null; } })();
+        const sinceRef = repoState?.latestReleaseTag?.tag
+          || (() => {
+            try {
+              return brainFormat.readShipSignals(projectDir, (args) => execFileSync('git', String(args).split(/\s+/).filter(Boolean), {
+                cwd: projectDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 4000,
+              })).tag || '';
+            } catch { return ''; }
+          })();
+        // NO `${ref}~50` guess. On a young repo — no release-shaped tag and
+        // fewer than 50 commits, i.e. the FIRST release — `git log <ref>~50..`
+        // exits non-zero, commitsInRange reports 'bad-range', and the lease
+        // holder is told "git history for <ref> could not be read", which reads
+        // as a broken checkout when the truth is "this repo is young".
+        // commitsInRange already walks the ref's own tip window on an empty
+        // baseline, capped at the same 500 commits / 4 s either way.
+        const range = commitsInRange(projectDir, sinceRef, ref);
+        if (range.status !== 'ok' || !brainPath) {
+          lease.reconcile = { skipped: true, reason: range.status !== 'ok' ? (range.reason || 'git-unreadable') : 'no-brain' };
+          if (range.status !== 'ok') releaseReconcileText = brainFormat.releaseReconcileNotice({ ref, skipped: true });
+        } else {
+          const { struct } = await brainFormat.parseKlypix(fs.readFileSync(brainPath));
+          const { candidates, truncated } = brainFormat.releaseFulfilledOpens(struct, range.commits, {
+            ref, containedFn: makeContainmentProbe(projectDir, ref),
+          });
+          // Zero candidates → NO key at all (RL10 parity): an absent advisory
+          // and an empty one must not look the same to a reader.
+          if (candidates.length) {
+            lease.reconcile = {
+              kind: 'open-cards-likely-fulfilled-by-release', severity: 'advisory',
+              ref, sinceRef, commitsScanned: range.commits.length, scanCapped: range.capped,
+              candidates, truncated,
+              confirmWith: brainFormat.releaseReconcileConfirmTemplate(ref),
+            };
+          }
+          releaseReconcileText = brainFormat.releaseReconcileNotice({ ref, sinceRef, candidates });
+        }
+      } catch {
+        try { lease.reconcile = { skipped: true, reason: 'error' }; } catch { /* lease is frozen — advisory only */ }
+        releaseReconcileText = brainFormat.releaseReconcileNotice({ ref, skipped: true });
+      }
+    }
+  }
   // ── Uncaptured-work check, host-neutral half ────────────────────────────────
   // The Stop hook can REFUSE a stop; every other host has no lifecycle hook at
   // all, so brain_sync is the only place the same question can be asked. Stamp
@@ -939,32 +1031,34 @@ server.registerTool('brain_sync', {
         if (head) gap.recordTaskBaseline(sid, { head, project: projectDir });
       } else if (phase === 'complete' && projectDir && sid) {
         const baseline = gap.readTaskBaseline(sid);
-        if (baseline?.head) {
-          // An ancestry check first: a rebase/reset makes the range meaningless,
-          // and reporting a rewritten history as "commits you didn't record" is
-          // exactly the cry-wolf that gets a nudge switched off.
-          const reachable = gitOk(['merge-base', '--is-ancestor', baseline.head, 'HEAD']);
-          const count = reachable ? Number(gitOut(['rev-list', '--count', '--no-merges', `${baseline.head}..HEAD`]) || 0) : 0;
+        const sameProject = baseline?.project && path.resolve(baseline.project) === path.resolve(projectDir);
+        if (sameProject && baseline?.head) {
+          // A successful note checkpoints the observed HEAD only. Work committed
+          // after that note belongs to a new outcome even in the same task/session.
+          const receipt = gap.sessionCaptureReceipt(sid, projectDir);
+          let from = baseline.head;
+          if (receipt?.head && receipt.at >= baseline.at
+              && gitOk(['merge-base', '--is-ancestor', baseline.head, receipt.head])
+              && gitOk(['merge-base', '--is-ancestor', receipt.head, 'HEAD'])) from = receipt.head;
+          const reachable = gitOk(['merge-base', '--is-ancestor', from, 'HEAD']);
+          const range = from + '..HEAD';
+          const count = reachable ? Number(gitOut(['rev-list', '--count', '--no-merges', range]) || 0) : 0;
           if (count > 0) {
-            const subjects = gitOut(['log', '--no-merges', '--format=%s', `${baseline.head}..HEAD`])
+            const subjects = gitOut(['log', '--no-merges', '--format=%s', range])
               .split('\n').map((s) => s.trim()).filter(Boolean).slice(0, 5);
-            // Bodies decide whether ANY rationale was recorded — the same rule
-            // the hook uses, so the two halves never disagree about one session.
-            const withRationale = gitOut(['log', '--no-merges', '--format=%x1e%b', `${baseline.head}..HEAD`])
+            const withRationale = gitOut(['log', '--no-merges', '--format=%x1e%b', range])
               .split('\x1e').map((b) => b.replace(/\s+/g, ' ').trim()).filter((b) => b.length >= 12).length;
+            const outcome = projectDir + ':' + gitOut(['rev-parse', 'HEAD']);
             const decision = gap.captureGapDecision({
               commitTotal: count,
               commitCards: withRationale,
-              sessionCaptured: gap.sessionHasCaptured(sid),
+              alreadyNudged: gap.outcomeWasNudged(sid, outcome),
             });
             if (decision) {
-              const changed = gitOut(['diff', '--name-only', `${baseline.head}..HEAD`]).split('\n').filter(Boolean).slice(0, 20);
-              const draft = gap.draftCaptureMarker({
-                commits: subjects.map((subject) => ({ subject })),
-                filesTouched: changed,
-              });
+              const changed = gitOut(['diff', '--name-only', range]).split('\n').filter(Boolean).slice(0, 20);
+              const draft = gap.draftCaptureMarker({ commits: subjects.map((subject) => ({ subject })), filesTouched: changed });
               captureGapText = gap.captureGapReason({ ...decision, draft, mode: 'advise' });
-              gap.recordCaptureGapNudge(sid);
+              gap.recordCaptureGapNudge(sid, undefined, outcome);
             }
           }
         }
@@ -1022,7 +1116,7 @@ server.registerTool('brain_sync', {
   return {
     content: [{
       type: 'text',
-      text: [report.text, harnessText, shipNotice, captureGapText, contextText, timingText].filter(Boolean).join('\n\n'),
+      text: [report.text, harnessText, shipNotice, releaseReconcileText, captureGapText, contextText, timingText].filter(Boolean).join('\n\n'),
     }],
     structuredContent,
     ...(report.isError ? { isError: true } : {}),
@@ -1031,7 +1125,7 @@ server.registerTool('brain_sync', {
 
 server.registerTool('brain_doctor', {
   title: 'Brain doctor — is this brain current, wired, and in sync?',
-  description: 'Read-only self-check of the installed klypix brain, as ONE verdict: VERSION (deployed brain-core + optional npm currency), CLAUDE (existing 5-hook capture readiness), CODEX (automatic MCP presence plus optional enhanced-hook status), TOOLS (discoverable MCP verbs), SESSIONS (all active presence-adapter sessions across hosts, never recent-chat history), and HARNESS (projection drift). Use to answer "is my brain current, correctly installed, in sync, and who is actually live?" without file-spelunking. Never writes. SCOPE: only CLAUDE and CODEX get behavioural verdicts. HARNESS classifies the projected config/rules FILES on disk — a project can read fully ok while no other host has ever actually loaded them, so do not report a clean HARNESS as "Cursor/Cline/Windsurf/Copilot is working". The MCP-callable twin of `npx klypix-mcp doctor`.',
+  description: 'Read-only self-check of the installed klypix brain, as ONE verdict: VERSION (deployed brain-core + optional npm currency), CLAUDE (existing 5-hook capture readiness), CODEX (automatic MCP presence plus optional enhanced-hook status), TOOLS (discoverable MCP verbs), SESSIONS (all active presence-adapter sessions across hosts, never recent-chat history), and HARNESS (projection drift). Use to answer "is my brain current, correctly installed, in sync, and who is actually live?" without file-spelunking. Never writes: the only side effects are read-only subprocess queries (git rev-parse / tag --list / log / merge-base with fixed argument arrays, and `npm view` only when check_npm is true) — it creates, edits, and deletes nothing. SCOPE: only CLAUDE and CODEX get behavioural verdicts. HARNESS classifies the projected config/rules FILES on disk — a project can read fully ok while no other host has ever actually loaded them, so do not report a clean HARNESS as "Cursor/Cline/Windsurf/Copilot is working". The MCP-callable twin of `npx klypix-mcp doctor`.',
   inputSchema: {
     project: z.string().optional().describe('Project dir to audit harness + peers for. Defaults to the server\'s working directory.'),
     check_npm: z.boolean().optional().describe('Also fetch npm latest to flag a stale brain (default false — this one does a network `npm view`).'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klypix-mcp",
-  "version": "1.83.0",
+  "version": "1.85.0",
   "mcpName": "io.github.dahshanlabs/klypix-mcp",
   "description": "Active state management for multi-agent coding: a shared, versioned project brain over MCP.",
   "type": "module",
@@ -84,10 +84,11 @@
     "bench": "node bin/klypix-mcp.mjs bench",
     "test:bench": "node test/bench.mjs",
     "pretest": "node test/publish-workflow.mjs",
-    "test": "node test/publish-verdict.mjs && node test/project-graph.mjs && node test/project-map-cli.mjs && node test/mcp-auto-update.mjs && node test/mcp-supervisor.mjs && node test/runtime-inspector.mjs && node test/codex-hooks.mjs && node test/request-identity.mjs && node test/session-identity-core.mjs && node test/agent-presence.mjs && node test/message-delivery-v3.mjs && node test/claude-message-delivery-v3.mjs && node test/result-reconcile.mjs && node test/evidence-publication-gate.mjs && node test/release-evidence-cli.mjs && node test/intent-guard.mjs && node test/git-capture-install.mjs && node test/brain-history.mjs && node test/brain-graveyard.mjs && node test/archived-visibility.mjs && node test/finding-routing.mjs && node test/finding-routing-hook.mjs && node test/presence-relay.mjs && node test/install-version.mjs && node test/install-rename-backoff.mjs && node test/project-binding-rebind.mjs && node test/context-gateway.mjs && node test/repo-state.mjs && node test/released-tag-guard.mjs && node test/conformance.mjs && node test/brain-doctor.mjs && node test/version-currency.mjs && node test/ship-capture.mjs && node test/capture-gap.mjs && node test/lane-message.mjs && node test/brain-quality.mjs && node test/brain-connect-orphans.mjs && node test/orphan-gardener.mjs && node test/brief-and-recall.mjs && node test/guard-cards.mjs && node test/layout-cluster.mjs && node test/brain-ask.mjs && node test/retrieval-fusion.mjs && node test/field-report-2026-07-04.mjs && node test/autoprop.mjs && node test/overlay-recency-2026-07-12.mjs && node test/brain-challenge.mjs && node test/brain-lens.mjs && node test/brain-kind.mjs && node test/rule-drafts.mjs && node test/claim-engine.mjs && node test/plan-fulfillment.mjs && node test/skill-staleness.mjs && node test/canvas-view.mjs && node test/status-completeness.mjs && node test/semantic-security.mjs && node test/semantic-gate.mjs && node test/memory-runtime.mjs && node test/semantic-cache.mjs && node test/enrichment.mjs && node test/decay-status.mjs && node test/decay-hook.mjs && node test/evidence-anchors.mjs && node test/presence-visibility.mjs && node test/undeclared-active.mjs && node test/presence-liveness.mjs && node test/observed-scope.mjs && node test/release-lease.mjs && node test/release-ancestry.mjs && node test/release-claim-join.mjs && node test/release-claims.mjs && node test/release-handshake.mjs && node test/completion-guard.mjs && node test/merge-brains.mjs && node test/concurrent-writes.mjs && node test/lock-interop.mjs && node test/capture-write-failure.mjs && node test/a2a-smoke.mjs && node test/one-command-setup.mjs && node test/cli-args.mjs && node test/format-guard.mjs && node test/canvas-groups.mjs && node test/git-tools.mjs && node test/uninstall.mjs",
+    "test": "node test/publish-verdict.mjs && node test/project-graph.mjs && node test/project-map-cli.mjs && node test/mcp-auto-update.mjs && node test/mcp-supervisor.mjs && node test/runtime-inspector.mjs && node test/codex-hooks.mjs && node test/request-identity.mjs && node test/session-identity-core.mjs && node test/agent-presence.mjs && node test/message-delivery-v3.mjs && node test/claude-message-delivery-v3.mjs && node test/result-reconcile.mjs && node test/evidence-publication-gate.mjs && node test/release-evidence-cli.mjs && node test/intent-guard.mjs && node test/git-capture-install.mjs && node test/brain-history.mjs && node test/brain-graveyard.mjs && node test/archived-visibility.mjs && node test/finding-routing.mjs && node test/finding-routing-hook.mjs && node test/presence-relay.mjs && node test/install-version.mjs && node test/install-rename-backoff.mjs && node test/project-binding-rebind.mjs && node test/context-gateway.mjs && node test/repo-state.mjs && node test/released-tag-guard.mjs && node test/conformance.mjs && node test/brain-doctor.mjs && node test/version-currency.mjs && node test/ship-capture.mjs && node test/capture-gap.mjs && node test/lane-message.mjs && node test/brain-quality.mjs && node test/brain-connect-orphans.mjs && node test/orphan-gardener.mjs && node test/brief-and-recall.mjs && node test/guard-cards.mjs && node test/layout-cluster.mjs && node test/brain-ask.mjs && node test/retrieval-fusion.mjs && node test/eval-retrieval.mjs && node test/field-report-2026-07-04.mjs && node test/autoprop.mjs && node test/overlay-recency-2026-07-12.mjs && node test/brain-challenge.mjs && node test/brain-lens.mjs && node test/brain-kind.mjs && node test/rule-drafts.mjs && node test/claim-engine.mjs && node test/partial-notes.mjs && node test/lifecycle-prefix.mjs && node test/close-link-safety.mjs && node test/resolve-ledger.mjs && node test/plan-fulfillment.mjs && node test/skill-staleness.mjs && node test/canvas-view.mjs && node test/status-completeness.mjs && node test/semantic-security.mjs && node test/semantic-gate.mjs && node test/memory-runtime.mjs && node test/semantic-cache.mjs && node test/enrichment.mjs && node test/decay-status.mjs && node test/decay-hook.mjs && node test/evidence-anchors.mjs && node test/brain-evidence.mjs && node test/presence-visibility.mjs && node test/undeclared-active.mjs && node test/presence-liveness.mjs && node test/observed-scope.mjs && node test/release-lease.mjs && node test/release-reconcile.mjs && node test/release-ancestry.mjs && node test/release-claim-join.mjs && node test/release-claims.mjs && node test/release-handshake.mjs && node test/completion-guard.mjs && node test/merge-brains.mjs && node test/concurrent-writes.mjs && node test/lock-interop.mjs && node test/capture-write-failure.mjs && node test/a2a-smoke.mjs && node test/one-command-setup.mjs && node test/cli-args.mjs && node test/format-guard.mjs && node test/canvas-groups.mjs && node test/git-tools.mjs && node test/uninstall.mjs && node test/current-guidance.mjs && node test/status-shape.mjs && node test/status-hook.mjs",
     "test:memory": "node test/memory-runtime.mjs",
     "test:memory:soak": "node --expose-gc test/memory-soak.mjs",
-    "runtime": "node bin/klypix-runtime.mjs"
+    "runtime": "node bin/klypix-runtime.mjs",
+    "eval:retrieval": "node scripts/eval-retrieval.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/ext-apps": "^1.7.5",

package/src/agent-presence.mjs

@@ -766,6 +766,11 @@ export function upsertSession({
   identitySource = null,
   aliases,
   home,
+  // Status-digest dedup hash (1.85.0): sha1[0:12] of the last computed status
+  // digest this session was shown, so a repeat status prompt gets a one-line
+  // pointer instead of the same ~5k chars. ADDITIVE — written only when a
+  // writer passes it; kept verbatim by every other touch (…previous spread).
+  statusDigestHash,
   now = Date.now(),
 }) {
   if (!brainPath || !id) return withWriteVerdict([], false, 'no-brain-or-id');
@@ -926,6 +931,7 @@ export function upsertSession({
           ...(previous.scopeStartedAt ? { scopeStartedAt: previous.scopeStartedAt } : {}),
           ...(taskCompleted ? { completedAt: now } : (previous.completedAt ? { completedAt: previous.completedAt } : {})),
         }),
+      ...(statusDigestHash !== undefined ? { statusDigestHash: String(statusDigestHash || '').slice(0, 16) } : {}),
       lastSeen: now,
     };
     const kept = sessions.filter((session) => session.id !== id);