klypix-mcp 1.86.3 → 1.87.0

package/bin/klypix-install.mjs

@@ -395,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-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']) {
+    for (const f of ['global-brain-hook.mjs', 'capture-gap.mjs', 'brain-semantic.mjs', 'semantic-memory.mjs', 'enrichment.mjs', 'provenance.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

@@ -621,7 +621,7 @@ server.registerTool('brain_lens', {
 
 server.registerTool('brain_connect', {
   title: 'Connect related-but-unlinked brain cards (densify the graph)',
-  description: 'Repairs orphaned decision/milestone cards first (scope:"orphans", the default) by proposing genuinely related unlinked pairs — semantic similarity at a conservative 0.55 threshold when the on-device model is installed, else shared tags + [[mentions]]. The dry run includes a before→projected orphan receipt; apply:true draws only additive, removable arrows and reports the measured after count. It NEVER archives or rewrites cards. Use scope:"all" for deliberate whole-graph densification. To DISMISS a brain_reconcile false-positive contradiction, pass pairs:[{fromId,toId}] with relationship:"not_contradiction".',
+  description: 'Repairs orphaned decision/milestone cards first (scope:"orphans", the default) by proposing genuinely related unlinked pairs — semantic similarity at a conservative 0.55 threshold when the on-device model is installed, else shared tags + [[mentions]]. The dry run includes a before→projected orphan receipt; apply:true draws only additive, removable arrows and reports the measured after count. It NEVER archives or rewrites cards. Use scope:"all" for deliberate whole-graph densification. To DISMISS a brain_reconcile false-positive contradiction, pass pairs:[{fromId,toId}] with relationship:"not_contradiction". Every applied not_fulfilled / not_contradiction dismissal is also recorded, with its surface and client, to the machine-local provenance sidecar (nothing extra is written into the brain file).',
   inputSchema: {
     canvas: z.string().optional().describe('Canvas filename/path. Defaults to the project brain ("brain").'),
     apply: z.boolean().optional().describe('false (default) = suggest only; true = draw the connections.'),
@@ -631,11 +631,11 @@ server.registerTool('brain_connect', {
     pairs: z.array(z.object({ fromId: z.string(), toId: z.string() })).optional().describe('Explicit card-id pairs to connect (bypasses auto-proposal). Use to dismiss a reconcile false-positive: pass the two card ids with relationship:"not_contradiction".'),
     relationship: z.string().optional().describe('Relationship for explicit `pairs` (e.g. "not_contradiction" to permanently dismiss a contradiction candidate, or "relates_to", "depends_on", "supports").'),
   },
-}, async ({ canvas, apply, max, threshold, scope, pairs, relationship }) => toContent(await opBrainConnect({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), apply, max, threshold, scope, pairs, relationship, log })));
+}, async ({ canvas, apply, max, threshold, scope, pairs, relationship }, extra) => toContent(await opBrainConnect({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), apply, max, threshold, scope, pairs, relationship, via: extra.klypixClientName, log })));
 
 server.registerTool('brain_reconcile', {
   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.',
+  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. Every applied confirm/dismiss is also recorded to the machine-local provenance sidecar (actor, surface, exact card ids — nothing extra is written into the brain file), and a claims confirm settles the pair\'s dashed "likely closed by" hint into a solid confirmed edge. 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 / git repo (default: the brain file's folder)."),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klypix-mcp",
-  "version": "1.86.3",
+  "version": "1.87.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,7 +84,7 @@
     "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/npx-owned-names.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/semantic-hash-parity.mjs && node test/enrichment.mjs && node test/hook-fallback.mjs && node test/eval-hook-lane.mjs && node test/decay-status.mjs && node test/decay-hook.mjs && node test/marker-suffix-grammar.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": "node test/publish-verdict.mjs && node test/npx-owned-names.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/semantic-hash-parity.mjs && node test/enrichment.mjs && node test/provenance.mjs && node test/confirm-trail.mjs && node test/hook-fallback.mjs && node test/eval-hook-lane.mjs && node test/hook-unified-lane.mjs && node test/decay-status.mjs && node test/decay-hook.mjs && node test/marker-suffix-grammar.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",

package/src/brain-doctor.mjs

@@ -57,6 +57,11 @@ try { repoStateLib = await import('./repo-state.mjs'); } catch { repoStateLib =
 // (the exact drift that once produced three different live-session counts).
 let presenceLib = null;
 try { presenceLib = await import('./agent-presence.mjs'); } catch { presenceLib = null; }
+// provenance powers the informational JUDGMENTS line (confirm/dismiss verdict
+// counts + rejected-prompt pool). Same failure-tolerant idiom; absence of the
+// module OR of any records is a fact, never drift.
+let provenanceLib = null;
+try { provenanceLib = await import('./provenance.mjs'); } catch { provenanceLib = null; }
 
 const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 
@@ -497,6 +502,13 @@ export function inspect(opts = {}) {
       history = { available: true, count: points.length, newestAt: points[0]?.ts || null };
     } catch { history = { available: true, count: 0, newestAt: null }; }
   }
+  // Judgment provenance (2026-09-29). Informational only: a brain with zero
+  // recorded verdicts is NEW, not drifted (same doctrine as history above).
+  let provenance = null;
+  if (hasBrain && provenanceLib && typeof provenanceLib.provenanceCounts === 'function') {
+    try { provenance = { available: true, ...provenanceLib.provenanceCounts(brainPath, { home }) }; }
+    catch { provenance = null; }
+  }
   const tools = inspectTools(brainDir, PKG_ROOT);
   // ── CHECKOUT (release-state visibility, 2026-08-14 incident) ──────────────
   // Advisory, never a verdict layer: when the PROJECT itself is a versioned
@@ -669,7 +681,7 @@ export function inspect(opts = {}) {
 
   // `checkout` is additive (schema-stable): downstream renderers keep parsing
   // every existing field; it never feeds layers/verdict/actions by design.
-  return { verdict, layers, drifted, readinessWarnings, version, running, supervisors, autoUpdate, hooks, codexSmart, codexHooks, gitCapture, history, tools, peers, sessions: peers, receipts: peers.receipts, receiptSessionId, harness, npm, decayGuard, checkout, project: { dir: projectDir, brainPath, hasBrain }, brainDir, actions };
+  return { verdict, layers, drifted, readinessWarnings, version, running, supervisors, autoUpdate, hooks, codexSmart, codexHooks, gitCapture, history, provenance, tools, peers, sessions: peers, receipts: peers.receipts, receiptSessionId, harness, npm, decayGuard, checkout, project: { dir: projectDir, brainPath, hasBrain }, brainDir, actions };
 }
 
 // One-line drift summary (empty when clean) — for a footer / status line.
@@ -840,6 +852,17 @@ export function render(r, opts = {}) {
     const age = r.history.newestAt ? `${Math.max(0, Math.round((Date.now() - r.history.newestAt) / 60000))}m ago` : 'none yet';
     L.push(`${ok} ${c.bold}HISTORY${c.rst}  ${r.history.count} restore point(s) · newest ${age} ${c.dim}(npx klypix-mcp brain-history list)${c.rst}`);
   }
+  // Judgment provenance — say what confirm/dismiss verdicts this machine has
+  // recorded, by verdict and surface, because "the trail exists" is only
+  // believable with the counts on the table. Zero records = a new sidecar,
+  // never a warning.
+  if (r.provenance?.available) {
+    const j = r.provenance.judgments || { total: 0, byVerdict: {}, bySource: {} };
+    const rej = r.provenance.rejected || { total: 0 };
+    const since = j.firstTs ? ` · since ${new Date(j.firstTs).toISOString().slice(0, 10)}` : '';
+    const srcBits = Object.entries(j.bySource || {}).map(([source, n]) => `${source} ${n}`).join(' · ');
+    L.push(`${ok} ${c.bold}JUDGMENTS${c.rst} ${j.total} recorded (${j.byVerdict?.yes || 0} yes / ${j.byVerdict?.no || 0} no)${since} · rejected-prompt pool ${rej.total}${srcBits ? ` ${c.dim}(${srcBits})${c.rst}` : ''}`);
+  }
 
   // TOOLS
   L.push(`${ok} ${c.bold}TOOLS${c.rst}    ${r.tools.count} MCP verb(s)${r.tools.hash ? ` ${c.dim}[#${r.tools.hash}, ${r.tools.source}]${c.rst}` : ''}${r.tools.count ? `: ${c.dim}${r.tools.names.join(', ')}${c.rst}` : ''}`);

package/src/enrichment.mjs

@@ -120,18 +120,34 @@ export function enrichmentQuestionQuality(question) {
  * pruned — enrichment is a rolling quality window, not an archive, and unlike
  * the claims lane nothing downstream depends on any single entry existing.
  * Returns { recorded, rejected } — `rejected` counts texts the quality gate
- * refused (see enrichmentQuestionQuality); they are never written.
+ * refused (see enrichmentQuestionQuality); they never reach the enrichment
+ * sidecar or the embedder. Since 2026-09-29 each refusal is forwarded, with its
+ * reason, to the privacy-screened rejected-log in provenance.mjs (best-effort).
  */
 export function recordEnrichment(brainPath, items, { home = os.homedir(), now = Date.now() } = {}) {
   const list = [];
+  const discarded = [];
   let rejected = 0;
   for (const item of (Array.isArray(items) ? items : [])) {
     const key = enrichmentKeyFor(item?.body);
     if (key.length < 24) continue;
     const quality = enrichmentQuestionQuality(item?.question);
-    if (!quality.ok) { rejected++; continue; }
+    if (!quality.ok) { rejected++; discarded.push({ text: quality.text, reason: quality.reason }); continue; }
     list.push({ key, q: quality.text });
   }
+  // A discard is still SIGNAL — the acknowledgement class is exactly the
+  // negative pool a judge study needs — so the text goes, WITH its refusal
+  // reason, to the bounded rejected-log sidecar (provenance.mjs applies the
+  // privacy screen: machine/console/pasted-doc classes store hash+length only).
+  // Lazy fire-and-forget import, never-throw: a stale deployment without
+  // provenance.mjs just skips, costing training data, never a capture.
+  if (discarded.length) {
+    try {
+      import('./provenance.mjs')
+        .then((prov) => { try { prov.recordRejectedEnrichment(brainPath, discarded, { home, now }); } catch { /* additive */ } })
+        .catch(() => { /* stale deployment — additive signal only */ });
+    } catch { /* dynamic import unavailable — additive signal only */ }
+  }
   if (!list.length) return { recorded: 0, rejected };
   const file = enrichmentFileFor(brainPath, home);
   fs.mkdirSync(path.dirname(file), { recursive: true });

package/src/global-brain-hook.mjs

@@ -2743,13 +2743,19 @@ function draftRulesFromFixes(lib, cards, verified, sid) {
                 candidates.push({ area: c.area || '', text: seed, source: c.createdVia || 'marker' });
             }
         }
-        if (!candidates.length && !skillCards.length) return { drafted: 0, approved: 0 };
+        if (!candidates.length && !skillCards.length) return { drafted: 0, approved: 0, approvedDrafts: [] };
         let added = 0, approved = 0;
+        const approvedDrafts = [];   // which draft each skill retired — the shown-then-promoted provenance signal
         persistDrafts((drafts, now) => {
             if (skillCards.length) {   // approval: a captured 🛠️ skill retires the draft it fulfils
-                const before = drafts.length;
-                drafts = drafts.filter(d => !skillCards.some(sc => draftMatches(d, String(sc.text || ''))));
-                approved = before - drafts.length;
+                const kept = [];
+                for (const d of drafts) {
+                    const sc = skillCards.find(sc => draftMatches(d, String(sc.text || '')));
+                    if (sc) approvedDrafts.push({ area: d.area || '', text: String(d.text || ''), skillText: String(sc.text || '') });
+                    else kept.push(d);
+                }
+                approved = drafts.length - kept.length;
+                drafts = kept;
             }
             const handled = new Set();
             for (const cand of candidates) {
@@ -2764,8 +2770,8 @@ function draftRulesFromFixes(lib, cards, verified, sid) {
             }
             return drafts;
         });
-        return { drafted: added, approved };
-    } catch { return { drafted: 0, approved: 0 }; }
+        return { drafted: added, approved, approvedDrafts };
+    } catch { return { drafted: 0, approved: 0, approvedDrafts: [] }; }
 }
 // Pending drafts: TTL-fresh, not already covered by a live 🛠️ skill, and NOT decayed
 // (a draft surfaced-and-ignored across ≥ RULE_DRAFT_MAX_SURFACINGS distinct sessions
@@ -3642,7 +3648,38 @@ async function capture(lib) {
     {
         const hadFixCommit = commitCards.some(cc => cc.createdVia === 'commit' && !/🏁/.test(String(cc.text || '')));
         const verified = sessionVerified(shellCmds, errorIds, hadFixCommit);
-        draftRulesFromFixes(lib, cards, verified, sid);
+        const draftRes = draftRulesFromFixes(lib, cards, verified, sid);
+        // Draft-rule provenance (2026-09-29): the shown-then-promoted (and
+        // shown-then-ignored) loop is the one DETERMINISTIC yes/no signal the
+        // hook owns — record both verdicts in the sidecar. Best-effort and
+        // skew-safe: a bundle without provenance.mjs just skips. Repeat
+        // observations of the same decayed draft dedup into count++ (jid).
+        try {
+            const judgments = [];
+            for (const a of (draftRes.approvedDrafts || [])) {
+                judgments.push({
+                    kind: 'rule', direction: 'rule-covers', verdict: 'yes', source: 'draft-promotion',
+                    actor: 'agent', session: sid, from: { text: a.text }, to: { text: a.skillText },
+                });
+            }
+            // A draft surfaced across RULE_DRAFT_MAX_SURFACINGS distinct
+            // sessions and still unpromoted has EARNED its silence — that "no"
+            // is a verdict too (the decay itself only stops the nagging).
+            const nowTs = Date.now();
+            for (const d of readRuleDrafts()) {
+                if (!d || !d.id || !d.text) continue;
+                if ((nowTs - (d.lastSeen || d.firstSeen || 0)) >= RULE_DRAFT_TTL_MS) continue;
+                if ((Array.isArray(d.shownSessions) ? d.shownSessions.length : 0) < RULE_DRAFT_MAX_SURFACINGS) continue;
+                judgments.push({
+                    kind: 'rule', direction: 'silence', verdict: 'no', source: 'draft-decay',
+                    actor: 'agent', session: sid, from: { text: String(d.text || '') },
+                });
+            }
+            if (judgments.length) {
+                const prov = await import(new URL('./provenance.mjs', import.meta.url).href);
+                prov.recordJudgments(BRAIN, judgments);
+            }
+        } catch { /* stale deployment or unwritable sidecar — additive signal only */ }
         // Cross-lane FINDING routing rides the SAME verify gate: a finding this
         // session verified about a file outside its own scope is drafted and
         // routed to whoever declared that file. Nothing is sent. `recentPaths`
@@ -3888,7 +3925,13 @@ async function capture(lib) {
         if (drainedLanded) clearDrained();
         reportBatch();
         try { await refreshAgentsBrief(lib, out); } catch { /* AGENTS.md refresh is best-effort */ }
-        return { ...res.stats, batchScope: scope, ...(batchError ? { batchError: String(batchError.message || batchError).slice(0, 160) } : {}), ...(quarantined.length ? { quarantined } : {}) };
+        // ownCounts marks the OWN/DRAINED boundary for the judgment writer
+        // below: drained batches are APPENDED to the shared cards/resolutions
+        // arrays (and land at the same tail indices), so "index < own length"
+        // is exactly "this session's marker". Without it, scope 'all' stamped
+        // THIS session's prompt hash and actor grade onto verdicts whose
+        // markers came from ANOTHER session's queued batch (2026-09-29 review).
+        return { ...res.stats, batchScope: scope, ownCounts: { cards: ownCards.length, resolutions: ownResolutions.length }, ...(batchError ? { batchError: String(batchError.message || batchError).slice(0, 160) } : {}), ...(quarantined.length ? { quarantined } : {}) };
     };
     // Canonical cross-process lock (heartbeat + token-checked release, shared
     // with the MCP engine and the desktop app). Stale bundles missing the module
@@ -3942,6 +3985,82 @@ async function capture(lib) {
             else if (outcome === 'fallback-milestone') d.action = 'resolve-unmatched';
         }
     }
+    // Marker-verdict provenance (2026-09-29): what this Stop's markers ACTUALLY
+    // retired — closes: fulfillments (stats.closedCards), archived ✓ resolves
+    // (per-outcome cardIds), and the hint edges a full resolve settled — goes
+    // to the machine-local provenance sidecar with an honest actor grade: a
+    // terminal marker is agent-emittable, so the strongest attainable class is
+    // 'agent-human-adjacent' (a machine-turn-guarded human prompt sat above
+    // it), never 'human'. The prompt itself rides as a hash only.
+    //
+    // ATTRIBUTION BOUNDARY (2026-09-29 review): scope 'all' — the NORMAL
+    // success path — means the landed arrays are this session's markers (the
+    // prefix) PLUS queued batches from EARLIER sessions appended by the drain.
+    // This session's prompt hash, session id and human-adjacency grade may
+    // only ever stamp the own prefix; a drained batch's verdict is recorded
+    // with the honest bare 'agent' grade and NO session/prompt — its human,
+    // if one existed, sat above a different transcript this hook never saw.
+    // Scope 'drained' (own half failed entirely) is skipped outright, as
+    // before. Best-effort + skew-safe.
+    if (stats.batchScope !== 'drained') {
+        try {
+            const ownCardCount = stats.ownCounts ? stats.ownCounts.cards : cards.length;
+            const ownResolutionCount = stats.ownCounts ? stats.ownCounts.resolutions : resolutions.length;
+            const hasDrained = cards.length > ownCardCount || resolutions.length > ownResolutionCount;
+            const ownStamp = { actor: lastUserPrompt ? 'agent-human-adjacent' : 'agent', humanPromptText: lastUserPrompt, session: sid };
+            const drainedStamp = { actor: 'agent' };   // another session's marker: agent-asserted, nothing stronger provable
+            const judgments = [];
+            for (const cc of (stats.closedCards || [])) {
+                // The closing card is the captured card whose closes: named this
+                // target (stats.closedCards carries the closed card, not the
+                // closer). findIndex against the shared array places the closer
+                // on the own/drained side of the boundary; an own closer with
+                // the same closes text as a drained one wins the prefix scan,
+                // which is correct — this session really did carry the marker.
+                const closerIdx = cards.findIndex(c => c && c.closes && String(c.closes).trim().slice(0, 80) === cc.target);
+                if (closerIdx === -1) continue;   // unidentifiable closer (engine skew) — never guess attribution
+                judgments.push({
+                    kind: 'pair', direction: 'closes', verdict: 'yes', source: 'marker-closes',
+                    ...(closerIdx < ownCardCount ? ownStamp : drainedStamp),
+                    from: { id: cc.id, text: cc.title || '' },
+                    to: { text: cards[closerIdx].text },
+                });
+            }
+            const seenResolved = new Set();
+            for (const o of (stats.resolutionOutcomes || [])) {
+                if (o.outcome !== 'archived') continue;
+                const cardId = o.cardId || o.id;
+                if (!cardId || seenResolved.has(cardId)) continue;
+                seenResolved.add(cardId);
+                const r = resolutions[o.i] || {};
+                judgments.push({
+                    kind: 'pair', direction: 'closes', verdict: 'yes', source: 'marker-resolve',
+                    ...(o.i < ownResolutionCount ? ownStamp : drainedStamp),
+                    from: { id: cardId },
+                    to: { text: r.text || '' },
+                });
+            }
+            for (const s of (stats.settledHints || [])) {
+                if (s.via !== 'resolve') continue;   // a byId settle is the reconcile-confirm's record, not the hook's
+                // `ri` joins the settle to the resolution that caused it (the
+                // engine mirrors resolutionOutcomes' indexing). Without the
+                // join — a stale engine bundle — a merged capture cannot place
+                // the settle on either side of the boundary, so it is skipped
+                // rather than guessed.
+                if (!Number.isInteger(s.ri) && hasDrained) continue;
+                judgments.push({
+                    kind: 'pair', direction: 'closes', verdict: 'yes', source: 'hint-settle',
+                    ...((Number.isInteger(s.ri) ? s.ri < ownResolutionCount : true) ? ownStamp : drainedStamp),
+                    from: { id: s.fromId, text: s.fromText || '' },
+                    to: { id: s.toId, text: s.toText || '' },
+                });
+            }
+            if (judgments.length) {
+                const prov = await import(new URL('./provenance.mjs', import.meta.url).href);
+                prov.recordJudgments(BRAIN, judgments);
+            }
+        } catch { /* stale deployment or unwritable sidecar — additive signal only */ }
+    }
     // Same honesty for ~: a thin update was APPENDED to its card, not a
     // replacement, and one the card already says changed nothing — a ledger
     // that still read `update` would claim a rewrite that never happened.
@@ -4128,6 +4247,31 @@ async function cachedStruct(lib) {
 // SessionStart already paid for. typeof-guarded: an older engine falls back
 // to the uncached pure function, then to null (renderers compute their own).
 const STATUS_CACHE = CACHE.replace(/\.json$/, '.status.json');
+// ── Unified-lane index cache (1.87) ──────────────────────────────────────────
+// rankHookWords / rankHookFused each build a per-struct index that the engine
+// caches in a WeakMap — useless to THIS one-shot process, which would rebuild
+// both on every prompt (measured on the 2,984-card brain: ~250-300ms of a
+// ~740ms end-to-end prompt; ~470ms with this cache — machine-dependent, the
+// review probe saw ~1s of builds). So the built indexes are persisted next to
+// the struct cache,
+// keyed on the brain file's mtimeMs AND size, and re-seeded into the engine's
+// WeakMaps before ranking. Behaviour-neutral: the doc holds only derived
+// stats re-linked to live cards by id, and ANY problem (stale key, unknown
+// id, parse error, version-skewed engine) falls back to an in-memory rebuild.
+// Named .brief-cache-…hookix.json so pruneCacheDir covers it too.
+const HOOK_IX_CACHE = CACHE.replace(/\.json$/, '.hookix.json');
+function seedHookIndexes(lib, struct) {
+    if (typeof lib.seedHookIndexCache !== 'function' || typeof lib.hookIndexCacheDoc !== 'function') return;
+    let st = null; try { st = fs.statSync(BRAIN); } catch { return; }
+    try {
+        const doc = JSON.parse(fs.readFileSync(HOOK_IX_CACHE, 'utf8'));
+        if (doc && doc.mtimeMs === st.mtimeMs && doc.size === st.size && lib.seedHookIndexCache(struct, doc)) return;
+    } catch { /* miss/corrupt → rebuild below */ }
+    try {
+        const doc = lib.hookIndexCacheDoc(struct);   // builds both indexes once, warming the WeakMaps
+        fs.writeFileSync(HOOK_IX_CACHE, JSON.stringify({ mtimeMs: st.mtimeMs, size: st.size, ...doc }));
+    } catch { /* cache is best-effort — the rankers rebuild in memory */ }
+}
 function cachedOpenStatusSummary(lib, struct, opts = {}) {
     if (!struct) return null;
     try {
@@ -4406,13 +4550,30 @@ async function promptRetrieve(lib) {
     // nothing (a peer's presence/ship is itself the signal). Empty string when solo.
     const peers = peerFooter(sid);
     const messages = messageFooter(sid, input.transcript_path, lib);   // 📨 durable notes: offer, acknowledge, replay until explicit consumption
-    let hits = [], repeats = [], struct = null;
-    if (tokens.length) {
+    // ── Unified recall (1.87) — the bench-measured two-lane policy ──────────
+    // Ported line-for-line from the 2026-09-28 "unified balanced" bench winner
+    // (dev/held-out split of real founder prompts; parity-proven against the
+    // reference policy). Routing: a STRONG status prompt keeps the computed
+    // digest below; a prompt whose UNIQUE CONTENT tokens reach
+    // HOOK_MODEL_MIN_TOKENS takes the MODEL lane (rankHookFused over the warm
+    // vector cache) when the embedder answers in budget and any card vector
+    // exists, else the WORDS lane (rankHookWords, BM25-idf rarity with an
+    // evidence bar) decides. Git-diff fileToks still feed the WORDS lane for
+    // terse prompts but never count toward the model gate — they are not the
+    // asker's words. A repeat nudge suppresses the model lane (and its
+    // embedder cost) exactly as it suppressed the old semantic fallback.
+    let repeats = [], struct = null, freshHits = [];
+    // lane + its deciding evidence are logged for every HUMAN decision — the
+    // silent rows are precisely the data the bars get re-fitted from in the
+    // field (the 2026-09-16 audit had only "hits: 5" ×165 to go on); machine
+    // turns are skipped at the write below (no refit signal, and they would
+    // rotate real rows out of the cap). Note the health log keeps its 500-row
+    // cap, and per-prompt rows still fill it faster than the old sem-only
+    // rows did — a field audit sees a shorter window per file, and the
+    // vocabulary changed: `lane`/`evidence` succeed `top1` (`sem` still lands).
+    let lane = statusStrong ? 'status-digest' : 'no-tokens', laneEvidence = null;
+    if (!statusStrong && tokens.length) {
         struct = await cachedStruct(lib);
-        // The lexical bar is the engine's measured export (1.86: 4 — one title
-        // word alone no longer injects; see HOOK_LEXICAL_MIN_SCORE). An older
-        // engine keeps the pre-1.86 bar of 3.
-        hits = lib.scoreCardsAgainstQuery(struct, tokens, { topK: 5, minScore: Number.isFinite(lib.HOOK_LEXICAL_MIN_SCORE) ? lib.HOOK_LEXICAL_MIN_SCORE : 3 });
         // PRECISION-first repeat nudge ("you already did this in another session"):
         // only on a do/build request, only completed-work cards, only high confidence.
         // Matched on the PROMPT's stated intent (ptoks), not the git-diff fallback. A
@@ -4420,66 +4581,64 @@ async function promptRetrieve(lib) {
         if (looksLikeWorkRequest(humanText || '') && typeof lib.detectRepeatWork === 'function') {
             try { repeats = lib.detectRepeatWork(struct, ptoks, { topK: 2 }); } catch { /* best-effort */ }
         }
-    }
-    const repeatIds = new Set(repeats.map(r => r.card.id));
-    let freshHits = hits.filter(h => !repeatIds.has(h.card.id));
-    // SEMANTIC fallback — runs ONLY on a lexical MISS (paraphrase / no keyword
-    // overlap, where you'd otherwise get zero recall). Gated behind the OPTIONAL
-    // on-device model, timeout-bounded (~1.2s), READ-ONLY (never embeds cards in
-    // this one-shot process — that's a 10s–195s stall). The common lexical-HIT
-    // prompt never enters this lane → zero added latency. Bulletproof: not installed
-    // / timeout / any failure → stays exactly today's pure-lexical behavior. The
-    // helper is optional+deploy-gated, so a missing copy degrades cleanly to lexical.
-    let semMode = 'lexical', semTop = null;
-    // Prompt-side admission (1.86): the fallback is an UNCORROBORATED five-card
-    // guess, and the measured cosines cannot tell an acknowledgement from a
-    // real question — but the prompt can. Fewer than FALLBACK_MIN_CONTENT_TOKENS
-    // content tokens ("build best in class", "continue where needed") skips the
-    // lane; the git-diff file tokens do not count, they are not the asker's words.
-    const fallbackEligible = typeof lib.lexicalMissFallbackEligible === 'function' ? lib.lexicalMissFallbackEligible(ptoks) : true;
-    if (!repeats.length && !freshHits.length && tokens.length && struct && !fallbackEligible) semMode = 'sem-skipped';
-    if (!repeats.length && !freshHits.length && tokens.length && struct && fallbackEligible) {
-        try {
-            const semlib = await import(new URL('./brain-semantic.mjs', import.meta.url).href);
-            if (typeof semlib.semanticVecs === 'function') {
-                // Embed the DERIVED human text, never the raw prompt — a mixed
-                // turn's stripped machine block must not re-contaminate the
-                // semantic query (parity with the lexical path above).
-                const sem = await semlib.semanticVecs(BRAIN, struct, humanText || '', { timeoutMs: 1500 });
-                if (!sem) semMode = 'sem-unavailable';
-                else {
-                    // ONE production primitive for this lane (1.86). The ranking
-                    // used to live inline here, which meant the surface every
-                    // session actually receives was the one no harness could
-                    // measure — an eval must IMPORT the ranker, never re-implement
-                    // it. rankLexicalMissFallback in klypix-format.mjs is that
-                    // primitive (scripts/eval-hook-lane.mjs measures it); its
-                    // defaults are the measured ones. An older engine without the
-                    // export degrades to the pre-1.86 inline ranking.
-                    let ranked;
-                    if (typeof lib.rankLexicalMissFallback === 'function') {
-                        const r = lib.rankLexicalMissFallback(struct, sem, { topK: 5 });
-                        ranked = r.hits; semTop = r.topCos;
-                    } else {
-                        const fresh = Date.now() - 30 * 86_400_000;
-                        ranked = struct.cards
-                            .filter(c => c.type !== 'container' && (c.text || '').trim() && !/^archive$/i.test(c.area || ''))
-                            .map(c => { const v = sem.vecsMap.get(c.id); return { card: c, s: v ? sem.dot(sem.qv, v) : null }; })
-                            .filter(x => x.s != null && x.s >= 0.30)
-                            .map(x => { let score = x.s * 10; if ((x.card.createdAt || 0) >= fresh) score += 0.5; return { card: x.card, score }; })
-                            .sort((a, b) => b.score - a.score).slice(0, 5);
+        const repeatIds = new Set(repeats.map(r => r.card.id));
+        if (typeof lib.rankHookWords === 'function' && typeof lib.rankHookFused === 'function') {
+            seedHookIndexes(lib, struct);
+            let decided = false;
+            // MODEL lane gate, in this order: repeat-nudge check, then the
+            // unique-content-token bar — semanticVecs (and its embedder load)
+            // is never paid for a terse prompt or a nudged repeat.
+            if (!repeats.length && new Set(ptoks).size >= lib.HOOK_MODEL_MIN_TOKENS) {
+                try {
+                    const semlib = await import(new URL('./brain-semantic.mjs', import.meta.url).href);
+                    if (typeof semlib.semanticVecs === 'function') {
+                        // Embed the DERIVED human text, never the raw prompt — a
+                        // mixed turn's stripped machine block must not
+                        // re-contaminate the semantic query. semanticVecs
+                        // lowercases, reads the warm card-vector cache read-only,
+                        // and returns null on ANY failure (not installed /
+                        // timeout / empty cache) → the words lane decides.
+                        const sem = await semlib.semanticVecs(BRAIN, struct, humanText || '', { timeoutMs: 1500 });
+                        if (sem) {
+                            const fused = lib.rankHookFused(struct, sem, tokens, { topK: 5 });
+                            if (fused.hits.length) {   // pool > 0; an empty pool is "no vectors" → words lane
+                                decided = true;
+                                laneEvidence = fused.best;
+                                if (fused.best >= fused.bar) { lane = 'model-shown'; freshHits = fused.hits; }
+                                else lane = 'model-silent';   // below-bar is a DECISION, never rescued by words
+                            }
+                        }
                     }
-                    freshHits = ranked;
-                    semMode = ranked.length ? 'sem-hit' : 'sem-empty';
-                }
+                } catch { /* any model-lane failure degrades to the words lane */ }
+            }
+            if (!decided) {
+                const w = lib.rankHookWords(struct, tokens, { topK: 5 });
+                laneEvidence = w.evidence;
+                if (w.hits.length && w.evidence >= w.bar) { lane = 'words-shown'; freshHits = w.hits; }
+                else lane = 'words-silent';
             }
-        } catch { semMode = 'sem-error'; }
+        } else {
+            // Version-skew fallback (older klypix-format without the 1.87
+            // exports): the pre-unified lexical lane at HOOK_LEXICAL_MIN_SCORE.
+            freshHits = lib.scoreCardsAgainstQuery(struct, tokens, { topK: 5, minScore: Number.isFinite(lib.HOOK_LEXICAL_MIN_SCORE) ? lib.HOOK_LEXICAL_MIN_SCORE : 3 });
+            lane = freshHits.length ? 'lexical' : 'lexical-silent';
+        }
+        // Repeat ids are filtered from the SHOWN hits — the nudge block renders
+        // those cards itself, with their correction overlays.
+        freshHits = freshHits.filter(h => !repeatIds.has(h.card.id));
+    }
+    // Header choice downstream: only a model-lane show is a "semantic match".
+    const semMode = lane === 'model-shown' ? 'sem-hit' : 'lexical';
+    // Health row: HUMAN decisions only. A machine turn (humanText === null —
+    // harness-injected reminders, task notifications) always lands 'no-tokens'
+    // and carries zero refit signal, but an agent-team session generates
+    // hundreds of them a day — logged, they would rotate the evidence-bearing
+    // words-silent/model-silent rows out of the 500-row cap (2026-09-29
+    // review). `sem` is kept for grep continuity with the pre-1.87 rows; the
+    // old `top1` field's successor is `evidence` (the deciding lane value).
+    if (humanText !== null) {
+        try { appendJsonl(HEALTH, { ts: nowIso(), project: path.basename(CWD), mode: 'prompt', sem: semMode, lane, hits: freshHits.length, mtok: new Set(ptoks).size, ...(Number.isFinite(laneEvidence) ? { evidence: Math.round(laneEvidence * 1000) / 1000 } : {}) }, 500); } catch { /* health log is best-effort */ }
     }
-    // The health row carries the best cosine the lane saw (`top1`) so the
-    // admission rule can be re-fitted from the field later without a
-    // transcript — the 2026-09-16 audit had only "hits: 5" ×165 to go on. A
-    // skipped lane is logged too (`sem-skipped`, with the content-token count).
-    if (semMode !== 'lexical') { try { appendJsonl(HEALTH, { ts: nowIso(), project: path.basename(CWD), mode: 'prompt', sem: semMode, hits: freshHits.length, ...(Number.isFinite(semTop) ? { top1: Math.round(semTop * 1000) / 1000 } : {}), ...(semMode === 'sem-skipped' ? { content: ptoks.length } : {}) }, 500); } catch { /* */ } }
     // T8 STATUS-DIGEST INJECTION (2026-07-23): a status-shaped prompt gets the
     // COMPUTED current-state digest INSTEAD of card hits — so an agent that
     // never queried the brain still answers "what is remaining?" from state,
@@ -4958,11 +5117,15 @@ function staleOpenFooter(stale) {
         const flat = (s) => String(s || '').replace(/\s+/g, ' ').trim();
         const lines = [];
         if (gaps && gaps.length) {
+            // The id-addressed confirm is the PREFERRED channel (2026-09-29):
+            // it names exact ids, settles the dashed hint to a solid 'closed
+            // by', and records the confirmation trail — the bare ✓ marker
+            // resolves by prose match and stays the human-typed fallback.
             lines.push('', '---',
                 `## 🔧 Self-heal — ${total} open card(s) look DONE (a later milestone covers them)`,
-                `These ❓/🎯 cards still read as open, but a shipped 🏁 milestone appears to fulfil them — so recall keeps surfacing already-done goals as "next". Confirm + close each:`,
-                '· done → `🧠 BRAIN [Area] ✓: <what it resolved to>` — stamps ✅ + archives the open card (or add `closes: <its title>` to the milestone marker).');
-            for (const g of gaps) lines.push(`- ⚠️ [${flat(g.open.area) || '?'}] ${flat(g.open.text).slice(0, 90)}  ·  likely closed by → ${flat(g.by.text).slice(0, 70)}`);
+                `These ❓/🎯 cards still read as open, but a shipped 🏁 milestone appears to fulfil them — so recall keeps surfacing already-done goals as "next". Verify, then confirm + close each:`,
+                '· done → the per-card `brain_reconcile mode:"claims" confirm:[{ id, milestoneId }]` call below — stamps ✅, archives the open card, and settles its hint with a recorded confirmation. Human-typed fallback: `🧠 BRAIN [Area] ✓: <what it resolved to>` (or add `closes: <its title>` to the milestone marker).');
+            for (const g of gaps) lines.push(`- ⚠️ [${flat(g.open.area) || '?'}] ${flat(g.open.text).slice(0, 90)}  ·  likely closed by → ${flat(g.by.text).slice(0, 70)}\n  confirm: \`brain_reconcile mode:"claims" confirm:[{ id:"${g.open.id}", milestoneId:"${g.by.id}" }]\``);
         }
         // Plan-shaped cards (2026-08-23): the same leak for proposals that never
         // carried a ❓ — recall serves them as current intent ("only a proposal")