klypix-mcp 1.78.0 → 1.80.0

package/bin/klypix-worker.mjs

@@ -632,9 +632,9 @@ server.registerTool('brain_reconcile', {
   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']).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).'),
+    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).'),
   },
-}, async ({ canvas, root, mode }) => toContent(await opBrainReconcile({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), root, mode })));
+}, async ({ canvas, root, mode }) => toContent(await opBrainReconcile({ vault: mcpPresence.vault, canvas: boundBrainCanvas(canvas), root, mode, log })));
 
 server.registerTool('brain_garden', {
   title: 'Garden the brain — consolidate over-grown areas (sleep-time compute)',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klypix-mcp",
-  "version": "1.78.0",
+  "version": "1.80.0",
   "description": "Active state management for multi-agent coding: a shared, versioned project brain over MCP.",
   "type": "module",
   "license": "Apache-2.0",
@@ -83,7 +83,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/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/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/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/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/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/git-tools.mjs && node test/uninstall.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-semantic.mjs

@@ -141,10 +141,20 @@ function readCachedVecs(brainPath, cards) {
         } catch { /* try next variant */ }
     }
     const map = new Map();
-    if (cache && cache.cards) for (const c of cards) { const e = cache.cards[c.id]; if (e && e.v) map.set(c.id, e.v); }
+    // A vector is accepted only for the text it was embedded from (the cache
+    // stores sha1(text) as `h`) — an edited card must fall back to lexical, never
+    // pair on a stale embedding (parity with semantic-memory.cachedVectorsForBrain).
+    if (cache && cache.cards) for (const c of cards) { const e = cache.cards[c.id]; if (e && e.v && (!e.h || e.h === sha1(String(c.text)))) map.set(c.id, e.v); }
     return map;
 }
 
+// Card vectors ONLY, from the warm cache — for card↔card pairing (plan ↔ 🏁)
+// that needs no query embedding and therefore no model at all. Same read-only
+// contract: never embeds, never writes, never throws; empty Map when no cache.
+export function cachedCardVecs(brainPath, cards) {
+    try { return readCachedVecs(brainPath, Array.isArray(cards) ? cards : []); } catch { return new Map(); }
+}
+
 // Entry point: embed the QUERY (needs the model) + read cached card vectors.
 // Returns { qv, vecsMap, dot } or null (not installed / timeout / any failure →
 // the hook keeps its exact lexical behavior). NEVER throws, NEVER embeds cards.

package/src/global-brain-hook.mjs

@@ -3399,6 +3399,21 @@ async function promptRetrieve(lib) {
             try { mergeOv = lib.mergeOverlaysFor(struct, freshHits.map(h => h.card)); } catch { /* best-effort */ }
         }
         const mergeTag = (id) => { const m = mergeOv.get(id); return m ? `\n  ↳ ⚠️ PR #${m.num} is since MERGED${m.date ? ` (ship event ${m.date})` : ''} — this "awaits merge" note is stale; nothing to do.` : ''; };
+        // Plan→🏁 decay (2026-08-23 AgentLit incident): a recalled PLAN/PROPOSAL
+        // card whose feature a newer 🏁 appears to have shipped gets a hedged
+        // POSSIBLY BUILT line. Brain-wide — the ship card is usually RENAMED, so
+        // it is rarely in this hit set — embedding-first from the READ-ONLY warm
+        // vector cache (cards only; this one-shot process never loads the model),
+        // strict lexical bars without it. Paid only when a plan-shaped card is a
+        // hit. Never retires anything. Version-skew guarded like every lib call.
+        let planOv = new Map();
+        if (struct && typeof lib.planFulfillmentFor === 'function' && typeof lib.isPlanCard === 'function') {
+            try {
+                const planCards = freshHits.map(h => h.card).filter(c => lib.isPlanCard(c));
+                if (planCards.length) planOv = lib.planFulfillmentFor(struct, planCards, { pairSim: await cachedPairSimFor(struct), scope: 'brain' });
+            } catch { planOv = new Map(); }
+        }
+        const planTag = (id) => { const p = planOv.get(id); return p ? `\n  ↳ ⏳ POSSIBLY BUILT — this card reads as a plan/proposal, but a newer 🏁 appears to have shipped it: “${head({ text: p.by }, 110)}”. Do NOT report it as "only a proposal" or still-to-do without checking the repo; if built, confirm with a ✓ marker (or \`closes:\` on the milestone); if not, dismiss via brain_connect pairs:[{fromId:"${id}", toId:"${p.byId}"}] relationship:"not_fulfilled".` : ''; };
         // Per-session injection dedup: a card already shown full-text this session
         // renders as one headline, not another ~600 words of context. LARGE cards
         // (>1KB) are tracked in a separate, deep-capped ledger so the 100-entry
@@ -3439,7 +3454,7 @@ async function promptRetrieve(lib) {
                 continue;
             }
             if (wasInjected(h.card)) {
-                lines.push(`- (already shown this session) ${head(h.card, 110)}${mergeTag(h.card.id)}`);
+                lines.push(`- (already shown this session) ${head(h.card, 110)}${mergeTag(h.card.id)}${planTag(h.card.id)}`);
                 shownNow.add(h.card.id);
                 continue;
             }
@@ -3452,7 +3467,7 @@ async function promptRetrieve(lib) {
             // reads this as "uncapped" and overstates it. Clipping here also
             // breaks the contract F5a asserts — first sight must be complete, or
             // the one chance to deliver a long decision intact is lost.
-            lines.push(`- ${flat(h.card.text)}${mergeTag(h.card.id)}`);
+            lines.push(`- ${flat(h.card.text)}${mergeTag(h.card.id)}${planTag(h.card.id)}`);
             shownNow.add(h.card.id);
             noteInjected(h.card);
         }
@@ -3710,19 +3725,51 @@ function doctorFooter() {
 // surfaced so the agent CLOSES them (✓ / closes:) instead of recall surfacing
 // already-done goals as "next". Never auto-archives (precision-first; the human
 // confirms). Version-skew guarded like the migration footer.
-function staleOpenFooter(lib, struct) {
+// Card↔card similarity from the READ-ONLY warm vector cache the MCP host fills
+// (never loads the model, never embeds, never writes): lets the one-shot hook
+// pair a plan card with its RENAMED ship ("Capability Forge proposal" ↔ "🏁
+// Capability builder shipped" — cosine 0.81, lexical coverage 0.20). Null when
+// there is no cache → the engine's strict lexical bars apply. One cache read per
+// process; the read is skipped entirely when nothing plan-shaped needs it.
+let _pairSim;
+async function cachedPairSimFor(struct) {
+    if (_pairSim !== undefined) return _pairSim;
+    _pairSim = null;
     try {
-        if (typeof lib.findStaleOpenCards !== 'function') return '';   // version-skew guard (stale live klypix-format)
-        const { gaps, total } = lib.findStaleOpenCards(struct, { max: 5 });
-        if (!gaps || !gaps.length) return '';
+        const semlib = await import(new URL('./brain-semantic.mjs', import.meta.url).href);
+        if (typeof semlib.cachedCardVecs !== 'function') return null;
+        const vecs = semlib.cachedCardVecs(BRAIN, (struct && struct.cards) || []);
+        if (!vecs || !vecs.size) return null;
+        _pairSim = (a, b) => { const va = vecs.get(a), vb = vecs.get(b); return va && vb ? semlib.dot(va, vb) : null; };
+    } catch { _pairSim = null; }
+    return _pairSim;
+}
+function staleOpenFooter(stale) {
+    try {
+        if (!stale) return '';
+        const { gaps = [], total = 0, plans = [], plansTotal = 0 } = stale;
         const flat = (s) => String(s || '').replace(/\s+/g, ' ').trim();
-        const lines = ['', '---',
-            `## 🔧 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)}`);
-        return '\n' + lines.join('\n') + '\n';
+        const lines = [];
+        if (gaps && gaps.length) {
+            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)}`);
+        }
+        // Plan-shaped cards (2026-08-23): the same leak for proposals that never
+        // carried a ❓ — recall serves them as current intent ("only a proposal")
+        // while the feature is live. Hedged: verify, then ✓ or dismiss (the
+        // dismissal names the exact pair — the engine honours it either way).
+        if (plans && plans.length) {
+            lines.push('', '---',
+                `## 🔧 Self-heal — ${plansTotal} plan/proposal card(s) look BUILT (a later 🏁 appears to ship them)`,
+                `These cards read as plans, so recall keeps serving them as current intent — but a shipped 🏁 appears to cover each (the ship is often RENAMED, which is why no link exists). Verify against the repo, then:`,
+                '· built → `🧠 BRAIN [Area] ✓: <what shipped>` — archives the plan as fulfilled history (still retrievable, flagged), or add `closes: <its title>` to the milestone marker.',
+                '· not built → `brain_connect` with the pairs shown and relationship:"not_fulfilled" — dismissed for good.');
+            for (const p of plans) lines.push(`- ⏳ [${flat(p.open.area) || '?'}] ${flat(p.open.text).slice(0, 90)}  ·  likely built by → ${flat(p.by.text).slice(0, 70)}${p.sim != null ? ` (sim ${p.sim})` : ''}  ·  dismiss: pairs:[{fromId:"${p.open.id}", toId:"${p.by.id}"}]`);
+        }
+        return lines.length ? '\n' + lines.join('\n') + '\n' : '';
     } catch { return ''; }
 }
 
@@ -3870,11 +3917,21 @@ async function read(lib) {
     })();
     const { struct } = await lib.parseKlypix(fs.readFileSync(BRAIN));
     const { freshness, drifted } = computeFreshness(struct);
+    // Plan↔🏁 self-heal (2026-08-23): card↔card similarity from the warm vector
+    // cache (read-only, no model) lets the self-heal pair plan cards with
+    // their RENAMED ships. Read ONLY when a plan-shaped card exists (review:
+    // an unconditional read cost every SessionStart ~150ms for nothing), and
+    // the stale-open/plan report is computed ONCE — shared by the brief's
+    // footer and the preview's heal line.
+    const hasPlans = typeof lib.isPlanCard === 'function' && (struct.cards || []).some(c => lib.isPlanCard(c));
+    const pairSim = hasPlans ? await cachedPairSimFor(struct) : null;
+    let stale = null;
+    try { if (typeof lib.findStaleOpenCards === 'function') stale = lib.findStaleOpenCards(struct, { max: 5, pairSim }); } catch { stale = null; }
     // The FULL brief: tiered brief + every self-heal/health footer. Messages are
     // deliberately NOT part of it: messageFooter advances durable offer/ack state
     // and must only go to stdout where the receiving model can see the exact token.
     const full = ((typeof lib.structToBrief === 'function') ? lib.structToBrief(struct, { freshness }) : lib.structToMarkdown(struct))
-        + inflightFooter(input.session_id, struct) + selfHealFooter(drifted) + reconcileFooter(lib, struct) + staleOpenFooter(lib, struct)
+        + inflightFooter(input.session_id, struct) + selfHealFooter(drifted) + reconcileFooter(lib, struct) + staleOpenFooter(stale)
         + ruleDraftsFooter(input.session_id, struct, { markShown: false })
         + receiptLine + selfCheckFooter() + doctorFooter() + versionCurrencyFooter() + legendFooter() + memoryFooter();
     const emitFull = () => {
@@ -3909,7 +3966,10 @@ async function read(lib) {
             if (files.length) { const { total } = lib.findUnrecordedMigrations(struct, files, { max: 6 }); if (total) heals.push(`${total} unrecorded migration(s)`); }
         }
     } catch { /* */ }
-    try { if (typeof lib.findStaleOpenCards === 'function') { const { total } = lib.findStaleOpenCards(struct, { max: 5 }); if (total) heals.push(`${total} open card(s) look already done`); } } catch { /* */ }
+    if (stale) {
+        if (stale.total) heals.push(`${stale.total} open card(s) look already done`);
+        if (stale.plansTotal) heals.push(`${stale.plansTotal} plan/proposal card(s) look BUILT`);
+    }
     const healLine = heals.length ? `\n🔧 Self-heal: ${heals.join(' · ')} — detail + fix markers in ${briefRel}.` : '';
     // Rule-draft nudge (capture-coverage): a one-line count in the preview; the full
     // promote-markers live in the brief file (read-only here — no shown-mark).

package/src/klypix-core.mjs

@@ -32,7 +32,8 @@ import {
   brainLensData, lensToMarkdown, deathDateOfCard,
   statusContextToMarkdown, findFulfillmentCandidates,
   splitQueryTokens, scoreCardsAgainstQuery, correctionOverlaysFor,
-  isFastDecayCard, isUnresolvedOpenCard, DECAY_STALE_MS, formatDecayAge,
+  isFastDecayCard, isUnresolvedOpenCard, isSkillCard, DECAY_STALE_MS, formatDecayAge,
+  isPlanCard, planFulfillmentFor, PLAN_PAIR_SIM_BRAIN, isAgconfTwinId,
   readPendingShips, clearPendingShips, pendingShipCards, formatCaptureReceipts,
 } from './klypix-format.mjs';
 import { findProjectBrain, postPresenceMessage } from './agent-presence.mjs';
@@ -41,6 +42,7 @@ import {
   dot, embedTexts, getEmbedder, getEmbedderForUse, withRerankerForUse,
   rerankHits, semanticFallbackNotice, semanticMemorySnapshot,
   semanticRuntimeInstalled, shouldPrewarmSemantic, vectorsForBrain,
+  cachedVectorsForBrain,
 } from './semantic-memory.mjs';
 
 // The MCP and A2A faces prewarm through this protocol-neutral module. Bounded
@@ -443,6 +445,23 @@ export async function opBrainTaskContext({
   let overlays = new Map();
   try { overlays = correctionOverlaysFor(struct, hits.map((hit) => hit.card)); }
   catch { /* context remains useful without overlays */ }
+  // Plan→🏁 hints (2026-08-23): a recalled PLAN/PROPOSAL whose feature a newer
+  // 🏁 appears to have shipped. Brain-wide (the ship card is usually renamed
+  // and not in this hit set), embedding-first from the READ-ONLY warm vector
+  // cache — this fast path never loads the model — strict lexical bars when
+  // no cache exists. Only paid when a plan-shaped card is among the hits.
+  let planHints = new Map();
+  try {
+    const planCards = hits.map((hit) => hit.card).filter((card) => isPlanCard(card));
+    if (planCards.length) {
+      let pairSim = null;
+      try {
+        const vecs = cachedVectorsForBrain(t.file, struct.cards);
+        if (vecs && vecs.size) pairSim = (a, b) => { const va = vecs.get(a), vb = vecs.get(b); return va && vb ? dot(va, vb) : null; };
+      } catch { pairSim = null; }
+      planHints = planFulfillmentFor(struct, planCards, { pairSim, scope: 'brain' });
+    }
+  } catch { planHints = new Map(); }
 
   const flat = (value) => String(value || '').replace(/\s+/g, ' ').trim();
   const clip = (value, limit) => {
@@ -457,6 +476,7 @@ export async function opBrainTaskContext({
   const nowTs = Date.now();
   const entries = hits.map((hit) => {
     const correction = overlays.get(hit.card.id)?.by || null;
+    const plan = planHints.get(hit.card.id) || null;
     let decayAge = null;
     try {
       const ageMs = (hit.card.createdAt || 0) > 0 ? nowTs - hit.card.createdAt : 0;
@@ -470,12 +490,33 @@ export async function opBrainTaskContext({
       correctedBy: correction ? clip(correction.text, 420) : null,
       ...(recentOpenIds.has(hit.card.id) ? { recentOpen: true } : {}),
       ...(decayAge ? { lastKnown: true, age: decayAge } : {}),
+      ...(plan ? { possiblyBuilt: { by: clip(plan.by, 200), byId: plan.byId, ...(plan.sim != null ? { sim: plan.sim } : {}) } } : {}),
     };
   });
   const maxChars = Math.max(800, Math.min(5000, Number(budgetChars) || 2800));
+  // Standing rules (2026-08-24 audit): 🛠️ skills are "apply every session",
+  // but the ranker's `score <= 0` gate drops a zero-overlap rule BEFORE its +1
+  // skill boost applies — so the capsule delivered task hits and zero standing
+  // rules, and the rule that would have warned the founder about a same-day
+  // billing trap never reached any session. This block is UNCONDITIONAL:
+  // relevance-ordered when the ranker scored a rule, newest-first otherwise,
+  // deduped against the hit list, and prepended so the maxChars tail-cut can
+  // never be the reason a rule silently vanished.
+  const skillPool = struct.cards.filter((c) => c.type !== 'container'
+    && !/^archive$/i.test(c.area || '') && isSkillCard(c));
+  const scoreById = new Map(candidatePool.map((hit) => [hit.card.id, hit.score]));
+  const standing = skillPool
+    .filter((c) => !hitIds.has(c.id))
+    .sort((a, b) => (scoreById.get(b.id) || 0) - (scoreById.get(a.id) || 0)
+      || (b.createdAt || 0) - (a.createdAt || 0))
+    .slice(0, 3);
   const lines = [
     `## Compact task context (${entries.length} relevant brain card${entries.length === 1 ? '' : 's'} · lexical-fast)`,
   ];
+  if (standing.length) {
+    lines.push(`### 🛠️ Standing rules (${skillPool.length} in the brain — apply always; full set in the brief)`);
+    for (const c of standing) lines.push(`- [${flat(c.area) || 'Notes'}] ${clip(c.text, 220)}`);
+  }
   if (!entries.length) {
     lines.push('No high-confidence task-specific card matched. Continue from repository evidence; use brain_ask only if deeper project history is needed.');
   } else {
@@ -486,7 +527,10 @@ export async function opBrainTaskContext({
       // (v1.32.0 law — a claim may truncate, its warning may not).
       const stamp = entry.lastKnown ? ` ⏱️ LAST KNOWN (${entry.age} old — verify live before reporting):` : '';
       const openStamp = entry.recentOpen ? ' ❓ RECENT OPEN:' : '';
-      lines.push(`- [${entry.area}]${entry.correctedBy ? ' superseded context:' : ''}${openStamp}${stamp} ${entry.text}`);
+      // Same prefix discipline as LAST KNOWN: the hint can never be the part a
+      // budget cut removes. It names the ship so the reader can verify it.
+      const planStamp = entry.possiblyBuilt ? ` ⏳ POSSIBLY BUILT (a newer 🏁 appears to ship this plan: “${entry.possiblyBuilt.by}” — verify before treating it as only a plan/proposal):` : '';
+      lines.push(`- [${entry.area}]${entry.correctedBy ? ' superseded context:' : ''}${openStamp}${stamp}${planStamp} ${entry.text}`);
       if (lines.join('\n').length >= maxChars) break;
     }
     lines.push('This is a bounded start-of-task capsule, not the whole brain; use brain_ask for broad status/history questions.');
@@ -497,6 +541,9 @@ export async function opBrainTaskContext({
     context: {
       mode: 'lexical-fast',
       hits: entries,
+      ...(standing.length ? {
+        standingRules: standing.map((c) => ({ id: c.id, area: flat(c.area) || 'Notes', text: clip(c.text, 220) })),
+      } : {}),
       sufficient: entries.length > 0,
       durationMs,
       brain: path.basename(t.file),
@@ -707,7 +754,7 @@ export function collectMigrationFiles(root) {
   }
   return out;
 }
-export async function opBrainReconcile({ vault, canvas, root, mode = 'all' }) {
+export async function opBrainReconcile({ vault, canvas, root, mode = 'all', log = () => {} }) {
   const t = brainTarget(vault, canvas);
   if (t.ambiguous) return ambiguousBrainErr(t.ambiguous);
   if (!t.file) return err(`No brain found — looked for ./brain.klypix in the project, then ${vault}. Pass canvas: "<name>".`);
@@ -782,6 +829,78 @@ export async function opBrainReconcile({ vault, canvas, root, mode = 'all' }) {
     }
   }
 
+  // (1d) PLANS (2026-08-23, AgentLit incident) — plan / proposal / "design
+  // decided" cards that never carried a ❓, reconciled against LATER live 🏁
+  // milestones — embedding-first (the ship is usually RENAMED, so lexical
+  // coverage alone misses it: the incident pair measured cov 0.20, 0 anchors,
+  // cosine 0.81), strict lexical bars when no vectors exist. The retroactive
+  // plan-vs-shipped sweep: every hit is a suggestion with its receipt; the ✓
+  // is a human act and archives the plan as fulfilled HISTORY (still
+  // retrievable, flagged) — nothing is deleted or hidden.
+  // Mode 'all' (the default) stays READ-ONLY and side-effect free: cached
+  // vectors only — no model load, no cross-process cache lock, no cache write
+  // (review 2026-08-23). Only an explicit mode:"plans" may embed, with the
+  // bounded model load; a cold cache is reported as such, never as "no model".
+  if (mode === 'all' || mode === 'plans') {
+    try {
+      const isArchived = (c) => /^archive$/i.test(c.area || '');
+      const textCards = struct.cards.filter(c => c.type !== 'container' && (c.text || '').trim());
+      const planCards = textCards.filter(c => !isArchived(c) && isPlanCard(c));
+      if (!planCards.length) {
+        if (mode === 'plans') sections.push('✓ No plan-shaped cards (proposal / planned / design decided …) are live — nothing to reconcile against the ships.');
+      } else {
+        let vecs = null, embedErr = null;
+        try { vecs = cachedVectorsForBrain(file, struct.cards); } catch { vecs = null; }
+        const installed = (() => { try { return semanticRuntimeInstalled(); } catch { return false; } })();
+        const cold = !vecs || vecs.size < Math.ceil(0.5 * textCards.length);
+        if (mode === 'plans' && cold && installed) {
+          try {
+            const pipe = await getEmbedderForUse(log, 20_000);
+            if (pipe) vecs = await vectorsForBrain(pipe, file, struct.cards);
+          } catch (e) { embedErr = e; }
+        }
+        let pairSim = null, how;
+        if (vecs && vecs.size) {
+          pairSim = (a, b) => { const va = vecs.get(a), vb = vecs.get(b); return va && vb ? dot(va, vb) : null; };
+          how = `on-device embedding ≥ ${PLAN_PAIR_SIM_BRAIN} + lexical corroboration (${vecs.size} of ${textCards.length} cards vectorized), lexical strict bars for the rest`;
+        } else if (!installed) {
+          how = 'lexical strict bars (no on-device model installed — coverage ≥ 0.6 or rare shared anchors)';
+        } else if (mode === 'plans') {
+          how = `lexical strict bars (embedding unavailable${embedErr ? `: ${embedErr.code || embedErr.message}` : ' — model still warming or the inference queue is saturated; retry shortly'})`;
+        } else {
+          how = 'lexical strict bars (vector cache cold — run brain_ask once, or mode:"plans", to vectorize this brain)';
+        }
+        const hints = planFulfillmentFor(struct, planCards, { pairSim, scope: 'brain' });
+        if (!hints.size) {
+          if (mode === 'plans') sections.push(`✓ No plan/proposal card looks built by a later milestone (${planCards.length} plan-shaped card(s) checked · ${how}).`);
+        } else {
+          const flat = (s) => String(s || '').replace(/\s+/g, ' ').trim();
+          const byId = new Map(struct.cards.map(c => [c.id, c]));
+          // Identical-text twins (pre-1.49 merge residue) collapse to one row,
+          // the original's id preferred — a brain awaiting its Arrange heal
+          // must not list the same plan twice.
+          const byText = new Map();
+          for (const [id, h] of hints) {
+            const plan = byId.get(id), by = byId.get(h.byId);
+            if (!plan || !by) continue;
+            const k = String(plan.text || '').toLowerCase().replace(/\s+/g, ' ').trim();
+            const prev = byText.get(k);
+            if (!prev || (isAgconfTwinId(prev.plan.id) && !isAgconfTwinId(plan.id))) byText.set(k, { plan, by, h });
+          }
+          const all = [...byText.values()].sort((a, b) => ((b.h.sim ?? 0) + b.h.cov) - ((a.h.sim ?? 0) + a.h.cov));
+          const rows = all.slice(0, 20);
+          const lines = rows.map((r, i) =>
+            `${i + 1}. [${r.plan.area || '?'}] (id ${r.plan.id}) PLAN: ${flat(r.plan.text).slice(0, 150)}\n`
+            + `   · looks BUILT by [${r.by.area || '?'}] (id ${r.by.id}) ${flat(r.by.text).slice(0, 150)}\n`
+            + `   · receipt: ${r.h.sim != null ? `sim ${r.h.sim} · ` : ''}coverage ${r.h.cov} · via ${r.h.via}\n`
+            + `   · if built: \`🧠 BRAIN [${r.plan.area || 'Notes'}] ✓: ${flat(r.plan.text).replace(/^[^:\n]{1,40}:\s*/, '').slice(0, 80)}\` · if not: brain_connect pairs:[{fromId:"${r.plan.id}", toId:"${r.by.id}"}] relationship:"not_fulfilled"`);
+          const more = all.length > rows.length ? `\n\n…and ${all.length - rows.length} more.` : '';
+          sections.push(`# 🧩 ${all.length} plan/proposal card(s) a later 🏁 appears to have BUILT\n_Suggestions with receipts (${how}) — nothing was changed. These cards read as plans, so recall keeps serving them as current intent ("it's only a proposal") while the feature is live. VERIFY each against the repo, then confirm with the ✓ marker (archives the plan as fulfilled history — it stays retrievable, flagged) or add \`closes: <plan title>\` to the milestone; dismiss a wrong pair permanently with the brain_connect call shown._\n\n${lines.join('\n')}${more}`);
+        }
+      }
+    } catch { /* best-effort section — the rest of reconcile stands */ }
+  }
+
   // (2) MIGRATIONS — the brain reconciled against committed external state.
   // Migrations live in the CODE repo (usually beside brain.klypix), not in a
   // separate canvas vault — so default the root to the brain file's folder.

package/src/klypix-format.mjs

@@ -1161,6 +1161,64 @@ export async function tidyBrain(buffer, opts = {}) {
 const normTitleKey = (t) => String(t || '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim();
 const normTextKey = (t) => String(t || '').toLowerCase().replace(/\s+/g, ' ').trim();
 const connDupKey = (c) => `${c.fromId}|${c.toId}|${c.relationship || ''}|${c.label || ''}`;
+// Merge-engine conflict twins ("<id>__agconf_<rand>") whose text is IDENTICAL
+// to their original are serialization residue (the pre-1.49.0 byte-compare
+// merge), never a deliberate placement — so unlike ordinary same-text cards
+// they collapse ACROSS areas. The live twin of an archived/superseded original
+// is exactly the zombie that outranked its own CORRECTION with no overlay
+// (AgentLit, 2026-08-23: 37 such pairs; 518 twins in total). The original is
+// the survivor; the twin's edges re-point onto it. Text that DIFFERS (a real
+// two-sided edit) is untouched — that twin is a genuine conflict record.
+const AGCONF_TWIN_RE = /^(.+?)__agconf_[a-z0-9]+$/i;
+export const isAgconfTwinId = (id) => AGCONF_TWIN_RE.test(String(id || ''));
+// Engine-authored RETIREMENT stamps — the exact formats the lifecycle writers
+// put on a card: "↩︎ superseded <date>\n" / "⤵ consolidated <date>\n" prepended,
+// "\n✅ <date>: …" / "\n✔ partial <date>: …" appended (the ✅ text itself wraps
+// across lines, so the suffix runs to the end of the card; it must START a
+// line — a dated ✅ cited mid-sentence is prose, not a stamp). A twin born
+// BEFORE its original was retired carries the original's pre-retirement text
+// exactly — the AgentLit zombie was this: "Capability Forge proposal"
+// superseded on 2026-08-22, its live twin byte-identical minus the "↩︎
+// superseded" line. Comparing with the stamps stripped recognizes that pair;
+// the stamped copy is the survivor so the lifecycle record is never lost.
+// Measured on AgentLit (518 twins): 3 live cross-area zombies of this shape,
+// 34 same-area stamped twins beside their original in Archive, 481 plain
+// byte-identical twins the same-area rule already folded.
+const RETIRE_PREFIX_RE = /^(?:↩︎? superseded|⤵ consolidated) \d{4}-\d{2}-\d{2}[ \t]*\n?/u;
+const RETIRE_SUFFIX_RE = /\n(?:✅|✔ partial) \d{4}-\d{2}-\d{2}:[\s\S]*$/u;
+const stripRetirement = (t) => String(t || '').replace(RETIRE_PREFIX_RE, '').replace(RETIRE_SUFFIX_RE, '');
+const hasRetirementStamp = (t) => RETIRE_PREFIX_RE.test(String(t || '')) || RETIRE_SUFFIX_RE.test(String(t || ''));
+const retiredTextKey = (t) => normTextKey(stripRetirement(t));
+// The ROOT a twin folds onto: strip trailing __agconf_<rand> segments to the
+// deepest EXISTING ancestor. A nested twin (X__agconf_a__agconf_b) folds onto
+// X, never onto the intermediate twin — grouping by the immediate parent put
+// one card in two collapse groups and dropped a valid edge as "dangling"
+// (review 2026-08-23).
+const agconfRootOf = (id, byId) => {
+    let cur = String(id || ''), root = null;
+    for (let guard = 0; guard < 8; guard++) {
+        const m = AGCONF_TWIN_RE.exec(cur);
+        if (!m) break;
+        cur = m[1];
+        if (byId.has(cur)) root = cur;
+    }
+    return root;
+};
+function foldIdenticalTwins(cardGroups, items, byId, keyOf) {
+    for (const c of items) {
+        if (c.type !== 'text' || !isAgconfTwinId(c.id)) continue;
+        const rootId = agconfRootOf(c.id, byId);
+        const orig = rootId ? byId.get(rootId) : null;
+        if (!orig || orig.type !== 'text' || !retiredTextKey(orig.text) || retiredTextKey(orig.text) !== retiredTextKey(c.text)) continue;
+        const ok = keyOf(orig), tk = keyOf(c);
+        if (!ok || !tk || ok === tk) continue;                  // same area → the plain same-text rule already groups them
+        const rest = (cardGroups.get(tk) || []).filter(id => id !== c.id);
+        if (rest.length) cardGroups.set(tk, rest); else cardGroups.delete(tk);
+        if (!cardGroups.has(ok)) cardGroups.set(ok, [orig.id]);
+        if (!cardGroups.get(ok).includes(orig.id)) cardGroups.get(ok).unshift(orig.id);
+        if (!cardGroups.get(ok).includes(c.id)) cardGroups.get(ok).push(c.id);
+    }
+}
 
 // Read-only layout report over a parsed brain: duplicate containers/cards,
 // overlapping boxes (same layer: roots together, siblings per container),
@@ -1181,14 +1239,14 @@ function layoutReportOf({ canvas, struct }) {
     const dupContainers = [...ctnGroups.entries()].filter(([, ids]) => ids.length > 1).map(([key, ids]) => ({ key, ids }));
 
     const cardGroups = new Map();
+    const cardKeyOf = (c) => { const tk = normTextKey(c.text); if (!tk) return ''; const ak = c.parentId ? normTitleKey(byId.get(c.parentId)?.title) : ''; return ak + '|' + tk; };
     for (const c of items) {
         if (c.type !== 'text') continue;
-        const tk = normTextKey(c.text); if (!tk) continue;
-        const ak = c.parentId ? normTitleKey(byId.get(c.parentId)?.title) : '';
-        const k = ak + '|' + tk;
+        const k = cardKeyOf(c); if (!k) continue;
         if (!cardGroups.has(k)) cardGroups.set(k, []);
         cardGroups.get(k).push(c.id);
     }
+    foldIdenticalTwins(cardGroups, items, byId, cardKeyOf);
     const dupCards = [...cardGroups.values()].filter(ids => ids.length > 1).map(ids => ({ ids, text: labelOf(byId.get(ids[0])) }));
 
     // Overlaps within each layer (root layer + one layer per container).
@@ -1247,6 +1305,8 @@ export async function arrangeBrain(buffer, opts = {}) {
     const beforeReport = layoutReportOf(first);
     // Lossless baselines, snapshotted BEFORE any mutation.
     const beforeTexts = new Set(first.struct.cards.filter(c => c.type === 'text').map(c => normTextKey(c.text)).filter(Boolean));
+    const beforeById = new Map(first.struct.cards.map(c => [c.id, c]));
+    const beforeRetiredOf = new Map(first.struct.cards.filter(c => c.type === 'text').map(c => [normTextKey(c.text), retiredTextKey(c.text)]));
     const beforeTitles = new Set(first.struct.cards.filter(c => c.type === 'container').map(c => normTitleKey(c.title)).filter(Boolean));
     const stats = {
         before: { items: beforeReport.items, containers: beforeReport.containers, connections: beforeReport.connections, overlaps: beforeReport.overlaps.length, dupCardGroups: beforeReport.dupCards.length, dupContainerGroups: beforeReport.dupContainers.length },
@@ -1304,17 +1364,21 @@ export async function arrangeBrain(buffer, opts = {}) {
         // container → one survivor. Same text in DIFFERENT areas is kept — that
         // placement may be deliberate.
         const cardGroups = new Map();
+        const dedupeKeyOf = (c) => { const tk = normTextKey(c.text); if (!tk) return ''; const parent = c.parentId ? (remap.get(c.parentId) || c.parentId) : ''; return parent + '|' + tk; };
         for (const c of struct.cards) {
             if (c.type !== 'text' || removed.has(c.id)) continue;
-            const tk = normTextKey(c.text); if (!tk) continue;
-            const parent = c.parentId ? (remap.get(c.parentId) || c.parentId) : '';
-            const k = parent + '|' + tk;
+            const k = dedupeKeyOf(c); if (!k) continue;
             if (!cardGroups.has(k)) cardGroups.set(k, []);
             cardGroups.get(k).push(c.id);
         }
+        // Identical __agconf twins fold onto their original across areas (see
+        // foldIdenticalTwins); the original always survives the collapse.
+        foldIdenticalTwins(cardGroups, struct.cards.filter(c => !removed.has(c.id)), byId, dedupeKeyOf);
         for (const ids of cardGroups.values()) {
             if (ids.length < 2) continue;
-            const survivor = pickSurvivor(ids);
+            // Survivor: a copy carrying a retirement stamp (the lifecycle record)
+            // beats a bare one; the original id beats a twin id.
+            const survivor = pickSurvivor(ids, (id) => (hasRetirementStamp(byId.get(id)?.text) ? 2 : 0) + (isAgconfTwinId(id) ? 0 : 1));
             for (const loser of ids) { if (loser !== survivor) { remap.set(loser, survivor); removed.add(loser); } }
             stats.collapsedCards.push({ kept: survivor, removed: ids.filter(id => id !== survivor), text: String(byId.get(survivor)?.text || '').split('\n')[0].slice(0, 60) });
         }
@@ -1323,9 +1387,12 @@ export async function arrangeBrain(buffer, opts = {}) {
         // duplicates, self-loops born from the collapse, and (already-broken)
         // dangling edges. Everything else is preserved verbatim.
         const seen = new Set(); const conns = [];
+        // Transitive: a loser may itself be the survivor another loser mapped to
+        // (a nested twin chain) — follow the chain to the final survivor.
+        const resolve = (id) => { let cur = id; for (let guard = 0; guard < 16 && remap.has(cur); guard++) cur = remap.get(cur); return cur; };
         for (const cn of (canvas.connections || [])) {
-            const fromId = remap.get(cn.fromId) || cn.fromId;
-            const toId = remap.get(cn.toId) || cn.toId;
+            const fromId = resolve(cn.fromId);
+            const toId = resolve(cn.toId);
             if (fromId !== cn.fromId || toId !== cn.toId) stats.connectionsRepointed++;
             if (!byId.has(fromId) || !byId.has(toId) || removed.has(fromId) || removed.has(toId)) { stats.danglingConnectionsDropped++; continue; }
             if (fromId === toId) { stats.selfLoopConnectionsDropped++; continue; }
@@ -1376,13 +1443,31 @@ export async function arrangeBrain(buffer, opts = {}) {
     if (afterReport.items < beforeReport.items - collapsedCount)
         throw new Error(`arrange lost items (${beforeReport.items} before − ${collapsedCount} collapsed > ${afterReport.items} after) — aborted, original untouched`);
     const afterTexts = new Set(after.struct.cards.filter(c => c.type === 'text').map(c => normTextKey(c.text)).filter(Boolean));
-    for (const t of beforeTexts) if (!afterTexts.has(t)) throw new Error(`arrange lost a unique card text ("${t.slice(0, 60)}…") — aborted, original untouched`);
+    // A folded twin's text may survive only INSIDE its stamped original (the
+    // pre-retirement text plus a "↩︎ superseded" / "✅ closed by" stamp) — that
+    // is content preserved, not lost. The escape is tied to the ids THIS pass
+    // logged as collapsed (review 2026-08-23: an open-ended retired-key
+    // escape would have hidden any other loss that happened to alias a
+    // stamped survivor). Everything else must still be verbatim.
+    const removedIds = new Set(stats.collapsedCards.flatMap(g => g.removed));
+    const removedTexts = new Set([...removedIds].map(id => beforeById.get(id)).filter(c => c && c.type === 'text').map(c => normTextKey(c.text)).filter(Boolean));
+    const afterRetiredKeys = new Set(after.struct.cards.filter(c => c.type === 'text').map(c => retiredTextKey(c.text)).filter(Boolean));
+    for (const t of beforeTexts) {
+        if (afterTexts.has(t)) continue;
+        if (removedTexts.has(t) && afterRetiredKeys.has(beforeRetiredOf.get(t))) continue;
+        throw new Error(`arrange lost a unique card text ("${t.slice(0, 60)}…") — aborted, original untouched`);
+    }
     const afterTitles = new Set(after.struct.cards.filter(c => c.type === 'container').map(c => normTitleKey(c.title)).filter(Boolean));
     for (const t of beforeTitles) if (!afterTitles.has(t)) throw new Error(`arrange lost an area container ("${t}") — aborted, original untouched`);
     if (beforeReport.focusPresent && !afterReport.focusPresent) throw new Error('arrange lost the 📌 Focus container — aborted, original untouched');
     if (afterReport.overlaps.length) throw new Error(`arrange left ${afterReport.overlaps.length} overlapping pair(s) (e.g. ${afterReport.overlaps[0].aLabel} × ${afterReport.overlaps[0].bLabel}) — aborted`);
     if (afterReport.outOfBounds.length) throw new Error(`arrange left ${afterReport.outOfBounds.length} card(s) outside their container — aborted`);
     if (afterReport.danglingConnections) throw new Error(`arrange produced ${afterReport.danglingConnections} dangling connection(s) — aborted`);
+    // No edge may vanish except as a logged duplicate / self-loop or a
+    // pre-existing dangling edge (review 2026-08-23: a nested twin's edges were
+    // being dropped as "dangling" with nothing to notice).
+    const minConnections = beforeReport.connections - stats.duplicateConnectionsDropped - stats.selfLoopConnectionsDropped - beforeReport.danglingConnections;
+    if (afterReport.connections < minConnections) throw new Error(`arrange lost ${minConnections - afterReport.connections} connection(s) beyond the logged duplicates/self-loops — aborted, original untouched`);
     if (dedupe && (afterReport.dupCards.length || afterReport.dupContainers.length || afterReport.dupConnections))
         throw new Error(`arrange left duplicates behind (${afterReport.dupContainers.length} container group(s), ${afterReport.dupCards.length} card group(s), ${afterReport.dupConnections} twin edge(s)) — aborted`);
     stats.after = { items: afterReport.items, containers: afterReport.containers, connections: afterReport.connections, overlaps: 0 };
@@ -1436,6 +1521,48 @@ export const isMilestoneCard = (c) => lifecycleEligible(c) && !isSkillCard(c) &&
 // extra guard so a ✅/↩/⤵-stamped card is never reported as plainly still-open.
 export const isUnresolvedOpenCard = (c) => isOpenCard(c) && !RESOLVED_GLYPH.test(String(c?.text || ''));
 
+// ── Plan-shaped plain cards (2026-08-23 AgentLit incident) ──────────────────
+// A proposal / plan / "design decided" card written WITHOUT a ❓/🎯 glyph sits
+// outside every lifecycle mechanism above — no close-pass, no fulfillment
+// pairing, no self-heal, no ⏳ hint. So when the thing it describes ships under
+// a 🏁 (often RENAMED: "Capability Forge proposal" → "🏁 Capability builder
+// shipped", same day), the plan keeps rendering as current intent and an agent
+// answers "it's only a proposal" about a feature that is live. Measured before
+// this landed (with the shipped classifier, 2026-08-23): 25 such cards in the
+// KLYPIX brain, 10 distinct in AgentLit, most with a real later 🏁 (a wider
+// draft regex had counted 61/9). This classifier admits them to the SAME pairing machinery as
+// ❓ cards — as hedged HINTS, never as a close.
+// PRECISION-FIRST like every sibling: the HEADLINE (area prefix stripped,
+// wrap-normalized, first ~220 chars) must carry a future-work cue AND no ship
+// pin ("Phase 1 BUILT + verified" is an event, not a plan — "not built" / "not
+// yet built" stay plan cues via the negation lookbehind). Glyphed cards keep
+// their own lifecycle; correction-cue cards assert present truth, never plans.
+// Cue shapes (review 2026-08-23 tightened the bare nouns): "plan"/"proposal"
+// fire only as the card's own intent — not inside an identifier (users.plan),
+// a pipeline arrow (plan→act), a pricing tier (paid plan), a quotation, or a
+// negation ("don't plan to"). "to be built" is exempt from the ship pin, and
+// "Design:" may be followed by a space (both were dead alternatives before).
+const PLAN_NOUN_GUARD = String.raw`(?<![.\w\/_-])(?<!\b(?:don'?t|do not|no|never|not|paid|free|pricing|subscription|beta|pro|cloud|billing|current)\s)`;
+const PLAN_CUE_RE = new RegExp(String.raw`\b(?:${PLAN_NOUN_GUARD}(?:proposals?|proposed|proposes?|plan(?:ned|ning)?(?![→\/.\-]))|roadmap|next\s+steps?|to\s+be\s+(?:built|shipped|implemented|wired|added)|not\s+(?:yet\s+)?(?:built|designed|implemented|shipped|started|wired)|will\s+(?:build|ship|implement|wire|add|land)|will\s+be\s+(?:built|shipped|implemented|wired|added)|should\s+(?:be|go|default|use|become|move|live|ship|land)|design\b[^.\n]{0,30}?\b(?:decided|locked|approved|agreed|chosen)|(?:decided|approved|locked|agreed)\b[^.\n]{0,20}?\b(?:build|ship|implement|wire)|spec(?:ification)?\s+(?:written|drafted|locked))\b|\bdesign\s*:(?=\s|$)`, 'i');
+const PLAN_SHIP_PIN_RE = /(?<!\bnot\s)(?<!\bnot\s+yet\s)(?<!\bto\s+be\s)(?<!\bwill\s+be\s)\b(?:shipped|merged|published|released|deployed|landed|built|implemented|went\s+live|is\s+live|now\s+live)\b/i;
+// An UPPERCASE verdict that the plan is dead (the same deliberate-signal casing
+// as CORRECTION): a rejected proposal is history, never a plan awaiting a ship.
+const PLAN_DEAD_RE = /\b(?:REJECTED|DECLINED|DROPPED|ABANDONED|WITHDRAWN|CANCELLED|CANCELED)\b/;
+const planHeadline = (text) => normalizeWrappedProse(String(text || ''))
+    .replace(/^[^:\n]{1,40}:\s*/, '')
+    .slice(0, 220)
+    .replace(/`[^`]*`/g, ' ')                                  // code spans carry identifiers, not intent
+    .replace(/["“”„][^"“”„]{0,120}["“”„]/g, ' ');              // quoted strings are someone else's words
+export const isPlanCard = (c) => {
+    if (!lifecycleEligible(c) || c?.type === 'container') return false;
+    const t = String(c?.text || '');
+    if (!t.trim() || STATE_GLYPH.test(t) || SKILL_GLYPH.test(t) || RESOLVED_GLYPH.test(t)) return false;
+    if (hasCorrectionCue(t)) return false;
+    const head = planHeadline(t);
+    if (PLAN_DEAD_RE.test(head)) return false;
+    return PLAN_CUE_RE.test(head) && !PLAN_SHIP_PIN_RE.test(head);
+};
+
 // ── Per-area status digest (2026-07-23 field incident) ───────────────────────
 // ONE computed current-state line per ACTIVE area: newest 🏁 headline + open
 // count. This is the fact whose tier-eviction let a stale "remaining:" claim
@@ -1503,8 +1630,11 @@ export function structToBrief(struct, { recentDays = 14, maxRecent = 40, maxMile
     // 🛠️ Skills — reusable how-tos / gotchas / procedures (the '+' marker).
     // Standing reference, NOT a point-in-time event: always shown, never
     // recency-decayed, and excluded from open/milestones/recent so a skill never
-    // masquerades as (or ages out like) a decision.
-    const skills = rest.filter(isSkillCard);
+    // masquerades as (or ages out like) a decision. Newest first: the render
+    // below can only show maxSkills of them, and an unsorted slice pinned the
+    // OLDEST rules forever while every rule learned since reached no session
+    // (2026-08-24 audit — the founder's same-day billing rule was invisible).
+    const skills = rest.filter(isSkillCard).sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0));
     const open = rest.filter(isOpenCard);
     const miles = rest.filter(isMilestoneCard);
     const plain = rest.filter(c => !open.includes(c) && !miles.includes(c) && !skills.includes(c));
@@ -1789,6 +1919,32 @@ export function structToUltraBrief(struct, { freshness = null, briefPath = '.cla
     // line that falls off the bottom of the preview-sized budget.
     const overdueById = findOverdueOpenCards(struct).byId;
     const openSorted = open.slice().sort((a, b) => (overdueById.has(b.id) ? 1 : 0) - (overdueById.has(a.id) ? 1 : 0));
+    // 🛠️ Standing rules tier (2026-08-24): the ultra brief used to render
+    // skills as a COUNT in the tail — so the one surface every session reads
+    // carried zero of the rules that are supposed to "fire every session".
+    // Newest first (the most recently learned trap is the likeliest live one),
+    // BEFORE the open list: opens are greedy to the budget floor, so anything
+    // placed after them never lands. Small cap — this is a reminder tier, the
+    // full set stays in the brief file. BUDGET FENCE (adversarial review of
+    // 10f43e1, reproduced live at the 1800-char SessionStart default): this
+    // tier must never be the reason a ⏰ OVERDUE line fell off — price the
+    // opens header, every overdue line, and the overflow line FIRST, and hold
+    // that budget back from the skills tier. Rules yield to deadlines.
+    if (skills.length) {
+        const openHeader = `## Open questions & goals (${open.length}${overdueById.size ? `, ${overdueById.size} ⏰ overdue` : ''})`;
+        const overdueLines = openSorted.filter(c => overdueById.has(c.id)).map(c => `- ⏰ OVERDUE ${fr(c)}${head(c)}`);
+        const reserve = open.length
+            ? ['', openHeader, ...overdueLines, `- …and ${open.length} more — in the full brief.`]
+                .reduce((s, l) => s + l.length + 1, 0)
+            : 0;
+        const pushIfFenced = (l) => (used + l.length + 1 > budget - reserve) ? false : (push(l), true);
+        if (pushIfFenced('') && pushIfFenced(`## 🛠️ Standing rules (${skills.length} — newest first, apply always)`)) {
+            const newest = skills.slice().sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0));
+            let shown = 0;
+            for (const c of newest.slice(0, 5)) { if (!pushIfFenced(`- ${fr(c)}${head(c)}`)) break; shown++; }
+            if (shown < skills.length) pushIfFenced(`- …and ${skills.length - shown} more standing rule(s) — in the full brief.`);
+        }
+    }
     if (open.length && pushIf('') && pushIf(`## Open questions & goals (${open.length}${overdueById.size ? `, ${overdueById.size} ⏰ overdue` : ''})`)) {
         let shown = 0;
         for (const c of openSorted) { if (!pushIf(`- ${overdueById.has(c.id) ? '⏰ OVERDUE ' : ''}${fr(c)}${head(c)}`)) break; shown++; }
@@ -2120,6 +2276,40 @@ export function rankForQuestion(struct, question, { semantic = null, k = 10, as_
                 }
             }
         } catch { /* pairing is a best-effort overlay — never fail the answer */ }
+        // PLAN↔🏁 (2026-08-23 AgentLit incident) — ONE scorer for plan cards.
+        // In-answer first (planFulfillmentFor scope 'answer': the ❓ pass's bars
+        // plus the order-independent near-tie → EARLIEST-ship rule), then the
+        // strict brain-wide tier for plan hits still unpaired: a proposal's
+        // ship is usually RENAMED ("Capability Forge proposal" → "🏁 Capability
+        // builder shipped"), so for a question phrased in the plan's words it
+        // is often not in this hit set at all. Then, when the pairing card IS
+        // in the answer but ranks BELOW the plan it fulfilled — whether the
+        // pairing came from these passes or from a persisted 'likely closed
+        // by' edge (the renderer's own predicate; review 2026-08-23 found the
+        // lift silently off once an edge existed) — it is lifted to directly
+        // above it: the newest truth takes the slot, the plan stays (history),
+        // and its hint names the ship. Hedged; never retires anything.
+        try {
+            const mileCards = hits.filter(h => isMilestoneCard(h.card) && !/^archive$/i.test(h.card.area || '')).map(h => h.card);
+            const unpairedPlans = () => hits.filter(h => !h.correction && !h.fulfillment && !h.archived && isPlanCard(h.card));
+            let left = unpairedPlans();
+            if (left.length && mileCards.length) {
+                const inAnswer = planFulfillmentFor(struct, left.map(h => h.card), { pairSim, scope: 'answer', milestones: mileCards });
+                for (const h of left) if (inAnswer.has(h.card.id)) h.fulfillment = inAnswer.get(h.card.id);
+                left = unpairedPlans();
+            }
+            if (left.length) {
+                const brainWide = planFulfillmentFor(struct, left.map(h => h.card), { pairSim, scope: 'brain' });
+                for (const h of left) if (brainWide.has(h.card.id)) h.fulfillment = brainWide.get(h.card.id);
+            }
+            for (let i = 0; i < hits.length; i++) {
+                const h = hits[i];
+                const isPlanHint = h.fulfillment && h.fulfillment.byId && (h.fulfillment.kind === 'plan' || isPlanCard(h.card));
+                if (!isPlanHint) continue;
+                const j = hits.findIndex(x => x.card.id === h.fulfillment.byId);
+                if (j > i) { const [m] = hits.splice(j, 1); hits.splice(i, 0, m); i++; }
+            }
+        } catch { /* best-effort — never fail the answer */ }
     }
     // SERVE-TIME 🛠️↔🏁 OBSOLESCENCE (2026-08-01 incident): the ❓ pass above
     // cannot see the class where a SKILL encodes a since-removed limitation —
@@ -2207,6 +2397,13 @@ export function questionContextToMarkdown(question, result, { mode = 'lexical',
         let block = `## [${flat(c.area) || 'Notes'}] ${day(c.createdAt)}${status}${rel}\n${flat(c.text)}`;
         if (h.correction) {
             block += `\n\n  ⚠️ CORRECTED — this card is STALE; the current truth is:\n  ${flat(h.correction.by.text).slice(0, 600)}`;
+        } else if (h.fulfillment && (h.fulfillment.kind === 'plan' || isPlanCard(c))) {
+            // A PLAN/PROPOSAL card a newer 🏁 appears to have shipped (2026-08-23
+            // incident: "it's only a proposal" answered about a live feature).
+            // The direction of trust differs from an open item: the reader must
+            // NOT report the plan as unbuilt — and must not assert it built
+            // either. Verify, then confirm or dismiss.
+            block += `\n\n  ⏳ POSSIBLY BUILT${h.fulfillment.unconfirmed ? ' (hint — no confirmed link)' : ''}: this card reads as a PLAN/PROPOSAL, and a newer 🏁 appears to have shipped it: “${flat(h.fulfillment.by).slice(0, 200)}”. Do NOT answer "only a proposal" or "still to do" from this card — for current state trust the newer card and VERIFY against the repo. If built: confirm with a ✓ marker (archives the plan as fulfilled history; it stays retrievable here) or add closes: to the milestone; if not: dismiss via brain_connect relationship:"not_fulfilled".`;
         } else if (h.fulfillment) {
             // Precedence: a correction outranks a fulfills-hint (never stack both).
             // Serve-time pairs (detected inside THIS answer's hit set, no
@@ -4680,6 +4877,112 @@ const SERVE_MIN_STEMS = 3;
 export const serveTimeAccepts = (lex, sameArea) =>
     anchorsSufficient(lex.anchors, sameArea, lex.cov)
     || ((lex.size || 0) >= SERVE_MIN_STEMS && lex.cov >= SERVE_COV_BAR);
+// ── Plan↔🏁 pairing (2026-08-23) — ONE scorer for every plan-card surface ───
+// Two acceptance tiers, because the surfaces differ in how much the QUESTION
+// already constrains the pair:
+//   · 'answer' — inside one brain_ask hit set, where both cards already matched
+//     the same question: the ❓ pass's own bars (embedding ≥ PLAN_PAIR_SIM_ANSWER
+//     plus any lexical corroboration, or lexical alone at the serve bars).
+//   · 'brain'  — against EVERY live newer 🏁 (per-prompt recall, brain_sync
+//     context, SessionStart self-heal, reconcile), where nothing constrains the
+//     pair but the two texts: near-duplicate similarity (PLAN_PAIR_SIM_BRAIN)
+//     plus lexical corroboration, or the self-heal's strict lexical bars
+//     (coverage ≥ 0.6, or rare shared anchors) without embeddings.
+// MEASURED on the KLYPIX brain (2026-08-23, 61 plan-shaped cards under the
+// wider draft classifier × 890 🏁, BGE-small cosines; the shipped classifier
+// keeps 25 of them and reproduces 18 pairs at 0.80–0.93): true plan→ship
+// pairs sat at 0.81–0.93; the false pairs
+// the looser answer tier admitted brain-wide sat at 0.68–0.77 ("Marketing piece
+// #2 planned" ↔ an npm publish, a lock-plan doc ↔ an image-decode fix). The
+// incident pair itself — a RENAMED feature: cov 0.20, zero anchors — measures
+// 0.811 against its ship card, so 0.80 is the floor this tier must keep, and
+// the 0.77→0.81 gap is thin: the constant is exported for RE-MEASUREMENT
+// (scripts/brain-eval in the KLYPIX repo), never tuned by feel.
+// Best milestone = highest score, a near-tie (≤ 0.1) broken toward the EARLIEST
+// 🏁: a plan ships once, and later 🏁s that reuse its vocabulary are follow-ups
+// (the Forge feasibility card's top-score pair was a later unrelated ship
+// until this rule). Bounded O(plans × milestones) with milestones tokenized
+// once; returns Map<planId, { kind:'plan', by, byId, cov, sim, via, unconfirmed }>.
+// Suggestion-only by construction — nothing here writes or retires.
+export const PLAN_PAIR_SIM_ANSWER = 0.55;
+export const PLAN_PAIR_SIM_BRAIN = 0.80;
+export function planFulfillmentFor(struct, cards, { pairSim = null, scope = 'brain', milestones = null, df = null } = {}) {
+    const out = new Map();
+    if (!struct || !Array.isArray(struct.cards) || !Array.isArray(cards) || !cards.length) return out;
+    const isArchived = (c) => /^archive$/i.test(c.area || '');
+    const plans = cards.filter(c => c && isPlanCard(c) && !isArchived(c));
+    if (!plans.length) return out;
+    const miles = Array.isArray(milestones) ? milestones.filter(Boolean)
+        : struct.cards.filter(c => c.type !== 'container' && (c.text || '').trim() && !isArchived(c) && isMilestoneCard(c));
+    if (!miles.length) return out;
+    // Settled pairs: an existing hint edge or close (plan → ship), and human
+    // dismissals in EITHER direction — a person draws "this ship is not that
+    // plan" as naturally as the reverse (review 2026-08-23).
+    const settled = new Set();
+    for (const cn of struct.connections || []) {
+        if (cn.label === 'likely closed by' || cn.label === 'closed by') settled.add(`${cn.fromId}|${cn.toId}`);
+        if (DISMISSAL_RELS.has(cn.relationship)) { settled.add(`${cn.fromId}|${cn.toId}`); settled.add(`${cn.toId}|${cn.fromId}`); }
+    }
+    const dfMap = () => (df ??= buildStemDf(struct));
+    const simBar = scope === 'answer' ? PLAN_PAIR_SIM_ANSWER : PLAN_PAIR_SIM_BRAIN;
+    const mPre = miles.map(m => { const idx = stemIndex(tokenSet(m.text)); return { m, idx, keys: new Set(idx.keys()) }; });
+    const structural = new Map();
+    const excludeFor = (a, b) => { const k = `${a || ''}|${b || ''}`; if (!structural.has(k)) structural.set(k, structuralStems(a, b)); return structural.get(k); };
+    for (const o of plans) {
+        const oIdx = stemIndex(claimTokens(normalizeWrappedProse(o.text)));
+        const oKeys = new Set(oIdx.keys());
+        if (oKeys.size < SERVE_MIN_STEMS) continue;                         // too vague to pair safely
+        // TWO-PASS selection (order-independent — review 2026-08-23 showed the
+        // single-pass near-tie rule picked a different ship per card order):
+        // collect every accepted candidate, take the top score, then among the
+        // candidates within 0.1 of it choose the EARLIEST ship; remaining ties
+        // → the original id over a twin id, then the higher score, then the id.
+        const accepted = [];
+        for (const { m, idx: mIdx, keys: mKeys } of mPre) {
+            if (!m || m.id === o.id || (m.createdAt || 0) <= (o.createdAt || 0)) continue;   // a ship must post-date the plan
+            if (settled.has(`${o.id}|${m.id}`)) continue;
+            const sim = typeof pairSim === 'function' ? pairSim(o.id, m.id) : null;
+            const cov = coverageOf(oKeys, mKeys);
+            const sameArea = (o.area || '') === (m.area || '');
+            // Rare shared anchors are only worth computing when a tier can use them.
+            const wantAnchors = (sim != null && sim >= simBar) || scope === 'answer' || cov >= ANCHOR_COV_FLOOR;
+            const anchors = wantAnchors ? sharedAnchors(oIdx, mIdx, dfMap(), { exclude: excludeFor(o.area, m.area) }) : [];
+            const lex = { cov: Math.round(cov * 100) / 100, anchors, size: oKeys.size };
+            // Corroboration reads the ROUNDED coverage the receipt reports (the
+            // incident pair measures 0.20 = 10 of 51 stems; a raw 0.196 must not
+            // fail a bar that was set from the rounded measurement).
+            const corroborated = anchors.length >= 1 || lex.cov >= 0.2;
+            // A MEASURED cosine decides the brain tier. The lexical bars exist
+            // for hosts with no vectors; when the embedding has already
+            // measured a pair as NOT near-duplicate, rare shared words must not
+            // overrule it. Measured on the KLYPIX brain sweep (23 pairs): four
+            // of the five false pairs came through the anchor path at cosines
+            // 0.64–0.74 ("core roadmap" ↔ a desktop build, a freeze plan ↔ the
+            // emoji picker); the veto costs one true pair at 0.748 (the single-
+            // writer architecture ↔ the one-write-lock release) — precision-
+            // first, as every sibling surface. The answer tier keeps its own
+            // question-constrained lexical acceptance.
+            const lexOk = scope === 'answer'
+                ? serveTimeAccepts(lex, sameArea)
+                : (sim == null && (cov >= 0.6 || anchorsSufficient(anchors, sameArea, cov)));
+            const embedOk = sim != null && sim >= simBar && corroborated;
+            if (!embedOk && !lexOk) continue;
+            const via = embedOk ? 'embed' : (cov >= 0.6 || lex.cov >= SERVE_COV_BAR ? 'coverage' : 'anchor');
+            accepted.push({ m, score: (sim ?? 0) + cov + anchors.length * 0.2, lex, sim, via });
+        }
+        if (!accepted.length) continue;
+        const top = Math.max(...accepted.map(a => a.score));
+        const band = accepted.filter(a => a.score >= top - 0.1);
+        band.sort((a, b) => ((a.m.createdAt || 0) - (b.m.createdAt || 0))
+            || ((isAgconfTwinId(a.m.id) ? 1 : 0) - (isAgconfTwinId(b.m.id) ? 1 : 0))
+            || (b.score - a.score)
+            || String(a.m.id).localeCompare(String(b.m.id)));
+        const best = band[0];
+        const head = String(best.m.text || '').replace(/\s+/g, ' ').trim().slice(0, 100);
+        out.set(o.id, { kind: 'plan', by: head, byId: best.m.id, cov: best.lex.cov, sim: best.sim == null ? null : Math.round(best.sim * 1000) / 1000, via: best.via, unconfirmed: true, scope });
+    }
+    return out;
+}
 // Imperative-ask cue (2026-07-29): a narrative ❓ card often carries no
 // colon-anchored "remaining:" clause — its ask is an imperative sentence
 // ("Narrow the prune … and verify a packaged answer E2E"). For OPEN-shaped
@@ -4763,7 +5066,10 @@ export function findFulfillmentCandidates(struct, milestones, { coverAt = 0.6, r
         const clauses = extractOpenClauses(o.text);
         // A whole ❓/🎯 card with no prose clause IS the claim (glyph-gated
         // path; never for 🏁 cards — their claim is only the explicit clause).
-        if (!clauses.length && /❓|🎯/.test(o.text) && !/🏁/.test(o.text)) {
+        // A plan-shaped plain card (isPlanCard, 2026-08-23) is the same claim
+        // shape without the glyph: "we will build X" is fulfilled by "🏁 X".
+        const planShaped = isPlanCard(o);
+        if (!clauses.length && (/❓|🎯/.test(o.text) || planShaped) && !/🏁/.test(o.text)) {
             const tk = claimTokens(o.text);
             if (tk.size >= 4) clauses.push({ clause: null, items: [{ text: flat(o.text).slice(0, 120), tokens: tk }] });
         }
@@ -4791,7 +5097,7 @@ export function findFulfillmentCandidates(struct, milestones, { coverAt = 0.6, r
                         viaAnchor = true;
                     }
                     const uncovered = cl.items.filter(x => x !== it && coverageOf(stemSet(x.tokens), mTok) < coverAt).map(x => x.text);
-                    out.push({ open: o, clause: cl.clause, item: it.text, uncovered, milestone: m, cov: Math.round(cov * 100) / 100, resolvable: !viaAnchor && it.tokens.size >= 4, ...(viaAnchor ? { via: 'anchor' } : {}) });
+                    out.push({ open: o, clause: cl.clause, item: it.text, uncovered, milestone: m, cov: Math.round(cov * 100) / 100, resolvable: !viaAnchor && it.tokens.size >= 4, ...(viaAnchor ? { via: 'anchor' } : {}), ...(planShaped ? { kind: 'plan' } : {}) });
                 }
             }
         }
@@ -5087,14 +5393,20 @@ export function corpseRate(struct, { k = 5, maxPairs = 40 } = {}) {
 // the human to close them — never auto-archives (precision-first, suggestion-only,
 // like the migration tripwire). Requires the milestone to post-date the goal so a
 // pre-existing milestone can't "fulfil" a newer goal. No I/O, node-runnable.
-export function findStaleOpenCards(struct, { coverAt = 0.6, max = 5 } = {}) {
-    const empty = { gaps: [], total: 0 };
+export function findStaleOpenCards(struct, { coverAt = 0.6, max = 5, pairSim = null } = {}) {
+    const empty = { gaps: [], total: 0, plans: [], plansTotal: 0 };
     if (!struct || !Array.isArray(struct.cards)) return empty;
     const isArchived = (c) => /^archive$/i.test(c.area || '');
     const live = struct.cards.filter(c => c.type !== 'container' && (c.text || '').trim() && !isArchived(c) && !/↩|✅/.test(c.text));
     const opens = live.filter(isOpenCard);
     const miles = live.filter(isMilestoneCard);
-    if (!opens.length || !miles.length) return empty;
+    // Plan-shaped plain cards (2026-08-23) ask the same "looks done?" question
+    // for proposals that never carried a ❓ — listed separately (plans) so the
+    // footer can word them as BUILT, embedding-first when the caller can pay for
+    // card↔card similarity (pairSim from the warm vector cache), strict lexical
+    // bars without it.
+    const plansLive = live.filter(isPlanCard);
+    if ((!opens.length && !plansLive.length) || !miles.length) return empty;
     // Human dismissals + existing hint edges suppress a pair here exactly as in
     // findFulfillmentCandidates — a rejected hint must never resurface in the
     // self-heal footer either (parity fix, 2026-07-29).
@@ -5145,7 +5457,29 @@ export function findStaleOpenCards(struct, { coverAt = 0.6, max = 5 } = {}) {
         if (best) out.push({ open: o, by: best, cov: Math.round(bestCov * 100) / 100, ...(bestVia === 'anchor' ? { via: 'anchor' } : {}) });
     }
     out.sort((a, b) => b.cov - a.cov);
-    return { gaps: out.slice(0, max), total: out.length };
+    const plans = [];
+    if (plansLive.length) {
+        try {
+            const byId = new Map(live.map(c => [c.id, c]));
+            const hints = planFulfillmentFor(struct, plansLive, { pairSim, scope: 'brain', milestones: miles, df });
+            for (const [id, h] of hints) {
+                const o = byId.get(id), by = byId.get(h.byId);
+                if (o && by) plans.push({ open: o, by, cov: h.cov, sim: h.sim, via: h.via, kind: 'plan' });
+            }
+            // Identical-text twins (merge residue) collapse to ONE row — the
+            // original's id when both exist — so a brain awaiting its Arrange
+            // heal does not list the same plan twice.
+            const byText = new Map();
+            for (const p of plans) {
+                const k = String(p.open.text || '').toLowerCase().replace(/\s+/g, ' ').trim();
+                const prev = byText.get(k);
+                if (!prev || (isAgconfTwinId(prev.open.id) && !isAgconfTwinId(p.open.id))) byText.set(k, p);
+            }
+            plans.length = 0; plans.push(...byText.values());
+            plans.sort((a, b) => ((b.sim ?? 0) + b.cov) - ((a.sim ?? 0) + a.cov));
+        } catch { /* best-effort — the open-card report stands on its own */ }
+    }
+    return { gaps: out.slice(0, max), total: out.length, plans: plans.slice(0, max), plansTotal: plans.length };
 }
 
 // ── Open-question deadline awareness ─────────────────────────────────────────

package/src/semantic-memory.mjs

@@ -624,6 +624,39 @@ ${extra}` : base;
   return map;
 }
 
+// READ-ONLY card vectors from the warm cache: never loads the model, never
+// embeds a missing card, never writes. For fast paths (brain_sync task context)
+// that may USE card↔card similarity when it is already paid for — plan ↔ 🏁
+// pairing — and must degrade to lexical bars when it is not. Cards whose text
+// changed since they were embedded are simply absent from the result.
+// Single-entry memo for the fast path (review 2026-08-23: brain_sync re-parsed
+// a ~36 MB cache on every plan-shaped hit). Keyed by the canonical cache file
+// + mtime + size + the card-hash digest, so a changed card or a rewritten
+// cache invalidates it; ONE brain at a time, vectors only (no parsed JSON
+// retained), so the long-lived worker's heap grows by one vector map, not by
+// every brain it ever touched.
+let _cachedVecMemo = null;
+export function cachedVectorsForBrain(brainPath, cards) {
+  const map = new Map();
+  try {
+    const want = (cards || []).filter((card) => card && card.type !== 'container' && (card.text || '').trim());
+    if (!want.length) return map;
+    const desiredHashes = new Map(want.map((card) => [card.id, sha1(String(card.text))]));
+    const file = cacheCandidates(brainPath)[0].file;
+    let stamp = null;
+    try { const st = fs.statSync(file); stamp = `${st.mtimeMs}|${st.size}`; } catch { stamp = null; }
+    const digest = sha1([...desiredHashes.entries()].map(([id, h]) => `${id}:${h}`).sort().join('\n'));
+    if (stamp && _cachedVecMemo && _cachedVecMemo.file === file && _cachedVecMemo.stamp === stamp && _cachedVecMemo.digest === digest) return _cachedVecMemo.map;
+    const loaded = readCache(brainPath, desiredHashes);
+    for (const card of want) {
+      const entry = loaded?.cache?.cards?.[card.id];
+      if (entry?.v && entry.h === desiredHashes.get(card.id)) map.set(card.id, entry.v);
+    }
+    if (stamp) _cachedVecMemo = { file, stamp, digest, map };
+  } catch { /* cache is best-effort — lexical stays the floor */ }
+  return map;
+}
+
 export async function vectorsForBrain(pipe, brainPath, cards) {
   if (!BOUNDED) return vectorsForBrainUnlocked(pipe, brainPath, cards);
   const key = canonicalBrainKey(brainPath);