@crouton-kit/crouter 0.3.32 → 0.3.33

package/dist/core/__tests__/fixtures/fake-engine.d.ts

@@ -1,3 +1,4 @@
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
 /** Test seam (M-1 regression): a FRESH-start kickoff prompt carrying this token
  *  makes the fake engine THROW inside bindExtensions BEFORE it fires
  *  session_start — the exact failure mode that records no pid and no session, so
@@ -64,10 +65,23 @@ interface ResourceLoader {
         runtime: ExtRuntime;
     };
 }
+interface TreeEntry {
+    type: 'message';
+    id: string;
+    parentId: string | null;
+    timestamp: string;
+    message: AgentMessage;
+}
+interface SessionTreeNode {
+    entry: TreeEntry;
+    children: SessionTreeNode[];
+}
 declare class FakeSession {
     private readonly sm;
     private readonly loader;
     private readonly dir;
+    private readonly tree;
+    private promptFailuresRemaining;
     private extensions;
     private readonly injected;
     private uiContext;
@@ -78,14 +92,25 @@ declare class FakeSession {
     private timer;
     private readonly listeners;
     private readonly messageLog;
+    private turnEndLeafId;
     constructor(sm: SessionManager, loader: ResourceLoader | undefined);
-    get messages(): unknown[];
+    get messages(): AgentMessage[];
     get sessionManager(): {
         buildSessionContext: () => {
-            messages: unknown[];
+            messages: AgentMessage[];
             thinkingLevel: string;
             model: null;
         };
+        getLeafId: () => string | null;
+        getEntry: (id: string) => TreeEntry | undefined;
+        getTree: () => SessionTreeNode[];
+        getUserMessagesForForking: () => Array<{
+            entryId: string;
+            text: string;
+            timestamp?: string;
+        }>;
+        getSessionId: () => string;
+        getSessionFile: () => string;
     };
     get sessionId(): string;
     get sessionFile(): string | undefined;
@@ -98,6 +123,7 @@ declare class FakeSession {
     }): Promise<void>;
     get isStreaming(): boolean;
     getSessionStats(): Record<string, unknown>;
+    private syncTreeSnapshot;
     setSessionName(_name: string): void;
     prompt(text: string, _options?: unknown): Promise<void>;
     steer(_text: string): Promise<void>;
@@ -106,8 +132,8 @@ declare class FakeSession {
     /** In-place tree rewind (broker `navigate_tree`). Mirrors the real SDK's
      *  contract: the session file is unchanged, the live history is truncated,
      *  and the navigated-to user message's text comes back as `editorText`. The
-     *  fake's "rewind" drops the last accrued turn so a re-welcome snapshot is
-     *  observably shorter (the navigate-tree-rewelcome regression lock). */
+     *  fake's "rewind" re-anchors the active branch without deleting the abandoned
+     *  tail so the welcome snapshot can prove the one-nudge property. */
     navigateTree(targetId: string, _options?: unknown): Promise<{
         editorText?: string;
         cancelled: boolean;

package/dist/core/__tests__/fixtures/fake-engine.js

@@ -140,10 +140,86 @@ function assistantMessage(text, pad = 0) {
 function textDelta(partial, delta) {
     return { type: 'text_delta', contentIndex: 0, delta, partial };
 }
+class SessionTree {
+    entries = new Map();
+    children = new Map();
+    leafId = null;
+    append(message) {
+        const entry = {
+            type: 'message',
+            id: randomUUID().slice(0, 8),
+            parentId: this.leafId,
+            timestamp: new Date().toISOString(),
+            message,
+        };
+        this.entries.set(entry.id, entry);
+        const siblings = this.children.get(entry.parentId) ?? [];
+        siblings.push(entry.id);
+        this.children.set(entry.parentId, siblings);
+        this.leafId = entry.id;
+        return entry;
+    }
+    navigateTree(targetId) {
+        const entry = this.entries.get(targetId);
+        if (entry === undefined)
+            throw new Error(`[fake-engine] navigateTree: unknown entry ${targetId}`);
+        this.leafId = targetId;
+        return { cancelled: false, editorText: this.textOf(entry.message) };
+    }
+    getLeafId() {
+        return this.leafId;
+    }
+    getEntry(id) {
+        return this.entries.get(id);
+    }
+    getTree() {
+        return (this.children.get(null) ?? []).map((id) => this.node(id)).filter((node) => node !== null);
+    }
+    getUserMessagesForForking() {
+        return [...this.entries.values()]
+            .filter((entry) => entry.message.role === 'user')
+            .map((entry) => ({ entryId: entry.id, text: this.textOf(entry.message), timestamp: entry.timestamp }));
+    }
+    buildSessionContext() {
+        return { messages: this.branchMessages(), thinkingLevel: 'off', model: null };
+    }
+    branchMessages() {
+        const ids = [];
+        let cur = this.leafId;
+        while (cur !== null) {
+            const entry = this.entries.get(cur);
+            if (entry === undefined)
+                break;
+            ids.push(cur);
+            cur = entry.parentId;
+        }
+        ids.reverse();
+        return ids.map((id) => this.entries.get(id)?.message).filter((m) => m !== undefined);
+    }
+    node(id) {
+        const entry = this.entries.get(id);
+        if (entry === undefined)
+            return null;
+        return {
+            entry,
+            children: (this.children.get(id) ?? []).map((child) => this.node(child)).filter((node) => node !== null),
+        };
+    }
+    textOf(message) {
+        const content = Array.isArray(message.content) ? message.content : [];
+        for (const part of content) {
+            if (typeof part?.text === 'string' && part.text !== '')
+                return part.text;
+        }
+        return '';
+    }
+}
 class FakeSession {
     sm;
     loader;
     dir;
+    tree = new SessionTree();
+    promptFailuresRemaining;
     extensions = [];
     injected = [];
     uiContext;
@@ -156,25 +232,35 @@ class FakeSession {
     // accumulating message history the catch-up snapshot serializes (G3).
     listeners = new Set();
     messageLog = [];
+    turnEndLeafId = null;
     constructor(sm, loader) {
         this.sm = sm;
         this.loader = loader;
         this.dir = nodeDirFromEnv();
+        const configured = Number(process.env['CRTR_FAKE_ENGINE_PROMPT_FAILS'] ?? '0');
+        this.promptFailuresRemaining = Number.isFinite(configured) && configured > 0 ? Math.floor(configured) : 0;
+        this.syncTreeSnapshot();
     }
     // --- broker-read getters. buildSnapshot (on a client hello) reads messages/
     //     stats/model: T8 clients attach and assert on welcome.snapshot, so messages
     //     returns the accrued history; stats/model stay cheap stubs. ---------------
     get messages() {
-        return this.messageLog;
+        return this.tree.buildSessionContext().messages;
     }
     // The broker's catch-up snapshot reconstructs history from the persisted
     // session tree (sessionManager.buildSessionContext) — the single source of
     // truth, since `session.messages` can be sliced by pi's retry/overflow/
     // compaction recovery. Mirror that surface so the fake's snapshot still serves
-    // the accrued history (G2/G3). The fake's persisted analog IS messageLog.
+    // the accrued history (G2/G3). The fake's persisted analog is the active branch.
     get sessionManager() {
         return {
-            buildSessionContext: () => ({ messages: this.messageLog, thinkingLevel: 'off', model: null }),
+            buildSessionContext: () => this.tree.buildSessionContext(),
+            getLeafId: () => this.tree.getLeafId(),
+            getEntry: (id) => this.tree.getEntry(id),
+            getTree: () => this.tree.getTree(),
+            getUserMessagesForForking: () => this.tree.getUserMessagesForForking(),
+            getSessionId: () => this.sm.getSessionId(),
+            getSessionFile: () => this.sm.getSessionFile(),
         };
     }
     get sessionId() {
@@ -200,19 +286,33 @@ class FakeSession {
     getSessionStats() {
         return { messages: 0, tokens: 0 };
     }
+    syncTreeSnapshot() {
+        try {
+            writeFileSync(join(this.dir, 'fake-pi.tree.json'), JSON.stringify({
+                leafId: this.tree.getLeafId(),
+                activeBranch: this.tree.buildSessionContext().messages,
+                tree: this.tree.getTree(),
+                userMessagesForForking: this.tree.getUserMessagesForForking(),
+            }, null, 2));
+        }
+        catch {
+            /* best effort */
+        }
+    }
     // --- naming is cosmetic (broker calls it in a try/catch) ---------------------
     setSessionName(_name) {
         /* no-op recording stub */
     }
     // --- controller-drive stubs (no controller connects in these tests) ----------
     prompt(text, _options) {
-        // The broker calls this for BOTH the fresh-start kickoff AND a controller's
-        // `prompt` frame (G1/G4). Either way emit a realistic streaming turn on the
-        // subscribe channel; the broker fans it out to every attached viewer VERBATIM.
-        // This is the SUBSCRIBE channel only — it does NOT run the canvas stophook
-        // (that fires via the separate extension-handler channel in dispatch()/fire()),
-        // so it never tears the broker down. The broker fire-and-forgets the promise.
-        return this.emitTurn(text);
+        // The broker calls this for the controller-less retry path. Emit the turn
+        // on the broker's subscribe channel and also run the real extension hooks so
+        // the canvas stophook records the fault marker and the broker can schedule
+        // the next retry.
+        const fail = this.promptFailuresRemaining > 0;
+        if (fail)
+            this.promptFailuresRemaining--;
+        return this.emitTurn(text, { fail, runHooks: true });
     }
     steer(_text) {
         return Promise.resolve();
@@ -226,11 +326,12 @@ class FakeSession {
     /** In-place tree rewind (broker `navigate_tree`). Mirrors the real SDK's
      *  contract: the session file is unchanged, the live history is truncated,
      *  and the navigated-to user message's text comes back as `editorText`. The
-     *  fake's "rewind" drops the last accrued turn so a re-welcome snapshot is
-     *  observably shorter (the navigate-tree-rewelcome regression lock). */
+     *  fake's "rewind" re-anchors the active branch without deleting the abandoned
+     *  tail so the welcome snapshot can prove the one-nudge property. */
     navigateTree(targetId, _options) {
-        this.messageLog.pop();
-        return Promise.resolve({ cancelled: false, editorText: `rewound-to:${targetId}` });
+        const result = this.tree.navigateTree(targetId);
+        this.syncTreeSnapshot();
+        return Promise.resolve(result);
     }
     // --- the single engine event stream the broker fans out (broker.ts subscribes
     //     here and broadcasts each event VERBATIM to every attached viewer) --------
@@ -266,6 +367,7 @@ class FakeSession {
         const updates = opts.updates ?? 3;
         const pad = opts.padBytes ?? 0;
         const withTool = opts.tool ?? true;
+        const fail = opts.fail === true;
         const small = assistantMessage(text);
         // A normal turn yields with setImmediate (fast). A sized flood (G8, pad>0) is
         // PACED with a small real delay so a fast (reading) viewer always drains each
@@ -274,6 +376,9 @@ class FakeSession {
         // pace the burst outruns the reader's event loop and sheds the fast viewer too.
         const yieldTick = () => pad > 0 ? new Promise((r) => setTimeout(r, 3)) : new Promise((r) => setImmediate(r));
         this.streaming = true;
+        if (opts.runHooks === true) {
+            await this.fire('agent_start', {}, this.buildCtx());
+        }
         this.emit({ type: 'agent_start' });
         this.emit({ type: 'turn_start' });
         this.emit({ type: 'message_start', message: small });
@@ -337,14 +442,39 @@ class FakeSession {
         }
         if (this.disposed)
             return;
-        const finalMsg = assistantMessage(text);
+        const userMsg = {
+            role: 'user',
+            content: [{ type: 'text', text }],
+            timestamp: Date.now(),
+        };
+        this.tree.append(userMsg);
+        this.syncTreeSnapshot();
+        const finalMsg = fail
+            ? { ...assistantMessage(text), stopReason: 'error', errorMessage: 'Connection error.' }
+            : assistantMessage(text);
         this.emit({ type: 'message_end', message: finalMsg });
         this.emit({ type: 'turn_end', message: finalMsg, toolResults: [] });
         this.messageLog.push(finalMsg);
+        const anchorBeforeFinal = this.tree.getLeafId();
+        this.turnEndLeafId = anchorBeforeFinal;
+        this.tree.append(finalMsg);
+        this.syncTreeSnapshot();
+        if (opts.runHooks === true) {
+            const hookCtx = this.buildCtx();
+            await this.fire('turn_end', { message: finalMsg, toolResults: [] }, hookCtx);
+            const hookMessages = fail
+                ? [...this.tree.buildSessionContext().messages, finalMsg]
+                : this.tree.buildSessionContext().messages.slice();
+            await this.fire('agent_end', { messages: hookMessages, willRetry: false }, hookCtx);
+        }
+        this.turnEndLeafId = null;
         this.streaming = false;
         // agent_end on the SUBSCRIBE channel is a relayed frame ONLY (willRetry=false);
         // it never runs the stophook, so the broker stays alive (G2/G3/G4/G8).
-        this.emit({ type: 'agent_end', messages: this.messageLog.slice(), willRetry: false });
+        const agentEndMessages = fail
+            ? [...this.tree.buildSessionContext().messages, finalMsg]
+            : this.tree.buildSessionContext().messages.slice();
+        this.emit({ type: 'agent_end', messages: agentEndMessages, willRetry: false });
     }
     dispose() {
         this.disposed = true;
@@ -470,6 +600,7 @@ class FakeSession {
             sessionManager: {
                 getSessionId: () => this.sm.getSessionId(),
                 getSessionFile: () => this.sm.getSessionFile(),
+                getLeafId: () => this.turnEndLeafId ?? this.tree.getLeafId(),
             },
             getContextUsage: () => ({ tokens: 1000 }),
             // Wired to the broker's shutdownHandler: the stophook calls ctx.shutdown()
@@ -557,7 +688,15 @@ class FakeSession {
                 this.streaming = false;
                 await this.fire('agent_end', {
                     messages: [
-                        { role: 'assistant', stopReason: cmd.reason ?? 'stop', content: [{ type: 'text', text: cmd.text ?? '' }] },
+                        {
+                            role: 'assistant',
+                            stopReason: cmd.reason ?? 'stop',
+                            // A real engine attaches errorMessage on a stopReason:'error'
+                            // turn; the stophook classifies it for the active-fault marker.
+                            // Forward it so a test can drive a CONNECTION stall faithfully.
+                            ...(cmd.errorMessage === undefined ? {} : { errorMessage: cmd.errorMessage }),
+                            content: [{ type: 'text', text: cmd.text ?? '' }],
+                        },
                     ],
                 }, ctx);
                 break;

package/dist/core/__tests__/fixtures/fake-pi-host.js

@@ -255,7 +255,16 @@ async function dispatch(cmd) {
             streaming = false;
             await fire('agent_end', {
                 messages: [
-                    { role: 'assistant', stopReason: cmd.reason ?? 'stop', content: [{ type: 'text', text: cmd.text ?? '' }] },
+                    {
+                        role: 'assistant',
+                        stopReason: cmd.reason ?? 'stop',
+                        // A real engine attaches errorMessage on a stopReason:'error' turn;
+                        // the stophook classifies it (connection/rate-limit/…) for the
+                        // active-fault marker. Forward it so a test can drive a CONNECTION
+                        // stall faithfully.
+                        ...(cmd.errorMessage === undefined ? {} : { errorMessage: cmd.errorMessage }),
+                        content: [{ type: 'text', text: cmd.text ?? '' }],
+                    },
                 ],
             }, ctx);
             ack(id, { ok: true });

package/dist/core/__tests__/full/human-new-window-regression.test.js

@@ -1,6 +1,6 @@
 // Run with: node --import tsx/esm --test src/core/__tests__/human-new-window-regression.test.ts
 //
-// BUG REGRESSION: `crtr human ask|approve|review|notify` opened NO pane at all.
+// BUG REGRESSION: `crtr human ask|review|notify` opened NO pane at all.
 //
 // spawnAndDetach's 'new-window' placement passed a tmux PANE id straight to
 // `new-window -t` (`new-window -d -a -t %<pane>`). tmux REJECTS a pane id for

package/dist/core/__tests__/helpers/harness.d.ts

@@ -76,7 +76,7 @@ export interface Harness {
     spawnHeadlessChild(parentId: string, task: string, o?: SpawnOpts): Promise<string>;
     spawnHeadlessChildNoBoot(parentId: string, task: string, o?: SpawnOpts): Promise<string>;
     turn(nodeId: string, text?: string): Promise<void>;
-    stop(nodeId: string, reason?: 'stop' | 'length' | 'aborted' | 'error'): Promise<void>;
+    stop(nodeId: string, reason?: 'stop' | 'length' | 'aborted' | 'error', errorMessage?: string): Promise<void>;
     finish(nodeId: string, finalText: string): Promise<void>;
     tick(now?: number): Promise<void>;
     awaitBoot(nodeId: string, o?: {

package/dist/core/__tests__/helpers/harness.js

@@ -389,9 +389,9 @@ export async function createHarness(opts = {}) {
             sendCmd(nodeId, { cmd: 'turn', id: `turn-${Date.now()}`, text });
             await awaitAgentEnd(nodeId, base, `turn agent_end for ${nodeId}`);
         },
-        async stop(nodeId, reason = 'stop') {
+        async stop(nodeId, reason = 'stop', errorMessage) {
             const base = eventCount(nodeId, 'agent_end');
-            sendCmd(nodeId, { cmd: 'stop', id: `stop-${Date.now()}`, reason });
+            sendCmd(nodeId, { cmd: 'stop', id: `stop-${Date.now()}`, reason, errorMessage });
             await awaitAgentEnd(nodeId, base, `stop agent_end for ${nodeId}`);
         },
         async finish(nodeId, finalText) {

package/dist/core/__tests__/human-stranded-deliver.test.js

@@ -22,7 +22,7 @@ import { closeDb } from '../canvas/db.js';
 import { readInboxSince } from '../feed/inbox.js';
 import { interactionDir, interactionsRoot } from '../artifact.js';
 import { atomicWriteJson, deckPath } from '@crouton-kit/humanloop';
-import { finalizeResolvedInteraction } from '../../commands/human/queue.js';
+import { finalizeResolvedInteraction, acquireInteractionClaim } from '../../commands/human/queue.js';
 let home;
 // A unique cwd so interactionDir (keyed off the REAL homedir + mangled cwd, NOT
 // CRTR_HOME) lands in an isolated, cleanable subtree.
@@ -96,6 +96,43 @@ test('a canceled-on-disk response reaps the bridge without delivering a result',
     const blob = JSON.stringify(readInboxSince('A'));
     assert.match(blob, /no answer is coming/);
 });
+test('the _run held-claim path delivers, and finalize without the claim self-conflicts', async () => {
+    // BUG REGRESSION (_run ask self-claim): the detached `_run` ask worker holds
+    // the exclusive resolve.lock across the blocking ask(), then must deliver the
+    // answer. If it calls finalizeResolvedInteraction WITHOUT passing its held
+    // claim, finalize re-acquires the same lock, sees this very process's live
+    // lock (EEXIST, owner.pid == self, pidAlive true) -> 'claimed' -> returns
+    // false, and the human's answer never reaches the asker. Passing the held
+    // claim lets finalize run under the worker's own lock.
+    createNode(node('A', null));
+    createNode(node('B', 'A'));
+    subscribe('A', 'B');
+    // Set up the deck + run.json but NOT the answer yet, then hold the claim
+    // exactly as the _run worker does (no opts) BEFORE ask() resolves the deck.
+    const idir = interactionDir('B', workCwd);
+    mkdirSync(idir, { recursive: true });
+    atomicWriteJson(deckPath(idir), { interactions: [] });
+    atomicWriteJson(join(idir, 'run.json'), { mode: 'ask', job_id: 'B' });
+    const claim = acquireInteractionClaim(idir, 'B');
+    assert.equal(typeof claim === 'object', true, 'claim must be acquired');
+    if (typeof claim !== 'object')
+        return;
+    // ask() then writes the human's answer to disk while the claim is held.
+    atomicWriteJson(join(idir, 'response.json'), {
+        responses: [{ id: 'q', selectedOptionId: 'resync', freetext: 'go ahead' }],
+        completedAt: '2026-06-10T22:27:07.000Z',
+    });
+    // Without the held claim, finalize from the SAME pid self-conflicts on the
+    // live lock and must NOT deliver (this is the stranding regression).
+    assert.equal(await finalizeResolvedInteraction('B'), false, 'self-held lock must block claimless finalize');
+    assert.equal(getNode('B')?.status, 'active', 'bridge must still be live after the self-conflicting call');
+    // Passing the held claim lets finalize run under the worker's own lock and
+    // deliver the answer back to the asker, then reap the bridge.
+    assert.equal(await finalizeResolvedInteraction('B', claim), true, 'held claim must deliver');
+    assert.equal(getNode('B')?.status, 'done', 'bridge reaped after held-claim deliver');
+    assert.match(JSON.stringify(readInboxSince('A')), /resync/, 'asker must receive the human selection');
+    claim.release();
+});
 test('an unresolved (no response.json) live bridge is left untouched', async () => {
     createNode(node('A', null));
     createNode(node('B', 'A'));

package/dist/core/__tests__/human-surface-target.test.js

@@ -1,6 +1,6 @@
 // Run with: node --import tsx/esm --test src/core/__tests__/human-surface-target.test.ts
 //
-// BUG REGRESSION: `crtr human ask|approve|review|notify` surfaced its humanloop
+// BUG REGRESSION: `crtr human ask|review|notify` surfaced its humanloop
 // TUI in the backstage `crtr` session (the asking node's own pane) — a session
 // the user never watches — because spawnAndDetach was called with no `-t`
 // target. The fix routes the TUI to the HIGHEST FOCUSED node of the asking

package/dist/core/__tests__/kickoff.test.js

@@ -8,7 +8,7 @@
 import { test, before, after, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { homedir } from 'node:os';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, subscribe } from '../canvas/canvas.js';
 import { reportsDir } from '../canvas/paths.js';
@@ -29,9 +29,7 @@ function node(id) {
     };
 }
 before(() => {
-    // Under homedir (not tmpdir) so report paths fall under the home prefix and
-    // exercise the tildify() collapse in reportHistoryLines.
-    home = mkdtempSync(join(homedir(), '.crtr-kickoff-'));
+    home = mkdtempSync(join(tmpdir(), 'crtr-kickoff-'));
     process.env['CRTR_HOME'] = home;
 });
 beforeEach(() => {
@@ -76,10 +74,10 @@ test('the feed block frames awaiting workers as alive + auto-waking, so a fresh
 test('a fresh revive is pointed at its subscriptions\' on-disk report history (catch-up bug)', () => {
     // Regression for the fresh-revive catch-up bug: on a refresh-yield
     // (resume:false) the old conversation is gone AND the inbox cursor has already
-    // advanced past everything drained pre-yield, so the revived node loses sight
-    // of reports its subscriptions pushed BEFORE the yield. The bodies persist
-    // forever at reports/<ts>-<kind>.md; the kickoff must point the node at those
-    // existing paths so it can catch up. Asserts the paths are rendered.
+    // advanced past everything drained pre-yield, so the revived node needs a
+    // durable catch-up breadcrumb for reports its subscriptions pushed BEFORE the
+    // yield. The bodies persist forever at reports/<ts>-<kind>.md; the kickoff
+    // surfaces a collapsed index with the newest ref and expansion commands.
     const parent = createNode(node('p1'));
     const worker = createNode(node('w1'));
     subscribe(parent.node_id, worker.node_id);
@@ -91,17 +89,18 @@ test('a fresh revive is pointed at its subscriptions\' on-disk report history (c
     writeFileSync(older, '---\n---\nearly progress', 'utf8');
     writeFileSync(newer, '---\n---\nthe result', 'utf8');
     const msg = buildReviveKickoff(parent, drainBearings(parent));
-    // Both existing report PATHS surface (most recent first), so the revived node
-    // can dereference the history its advanced cursor would otherwise hide. They
-    // render home-relative with a leading ~ (the absolute home prefix is wasted
-    // context tokens; ~ is still dereferenceable by the revived node).
-    const olderRel = '~' + older.slice(homedir().length);
-    const newerRel = '~' + newer.slice(homedir().length);
-    assert.ok(msg.includes(olderRel), 'older report path surfaced, home-relative (~)');
-    assert.ok(msg.includes(newerRel), 'newer report path surfaced, home-relative (~)');
-    assert.ok(!msg.includes(older), 'absolute home prefix not rendered');
-    assert.ok(msg.indexOf(newerRel) < msg.indexOf(olderRel), 'most recent report listed first');
-    // ...and the hint that the full inbox history is replayable cursor-independently.
+    // The feed block stays condensed: it reports that history exists and surfaces
+    // the newest report ref for immediate dereference, while older refs stay one
+    // command away instead of being preloaded into the revive prompt.
+    const olderRef = `${worker.node_id}:reports/20260608T120000-update.md`;
+    const newerRef = `${worker.node_id}:reports/20260608T130000-final.md`;
+    assert.ok(/Report history on disk \(collapsed\): 2 reports across 1 subscribed node/.test(msg));
+    assert.ok(msg.includes(`latest final: ${newerRef}`), 'newest report ref surfaced');
+    assert.ok(!msg.includes(olderRef), 'older report ref omitted from collapsed kickoff');
+    assert.ok(!msg.includes(older), 'absolute report paths not rendered');
+    assert.ok(!msg.includes(newer), 'absolute report paths not rendered');
+    assert.ok(/canvas history read <ref>/.test(msg), 'points at one-report expansion');
+    assert.ok(/canvas history show <node-id> --type report/.test(msg), 'points at full per-node expansion');
     assert.ok(/feed read --all/.test(msg), 'points at the cursor-independent full-history replay');
 });
 test('buildReviveKickoff is pure — building twice eats nothing', () => {

package/dist/core/__tests__/memory-resolver.test.js

@@ -26,7 +26,7 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { resolveMemoryDoc } from '../memory-resolver.js';
+import { listAllMemoryDocs, resolveMemoryDoc } from '../memory-resolver.js';
 import { resetScopeCache } from '../scope.js';
 // Fixture: a temp PROJECT scope (a `.crouter/` dir discovered by walking up from
 // cwd) holding both a native memory/ tree and one enabled fixture plugin whose
@@ -55,6 +55,9 @@ before(() => {
     writeFileSync(join(pluginMem, 'widget.md'), doc('plugin-widget'));
     writeFileSync(join(pluginMem, 'area', 'zone.md'), doc('plugin-zone'));
     writeFileSync(join(pluginMem, 'shared.md'), doc('plugin-shared'));
+    writeFileSync(join(pluginMem, 'SKILL.md'), doc('legacy-plugin-skill'));
+    mkdirSync(join(memDir, 'legacy'), { recursive: true });
+    writeFileSync(join(memDir, 'legacy', 'SKILL.md'), doc('legacy-native-skill'));
     // Plugin-root INDEX.md: a BARE plugin name must resolve this (mirrors the
     // native bare-dir-name -> INDEX.md contract for the plugin mount root).
     writeFileSync(join(pluginMem, 'INDEX.md'), doc('plugin-root-index'));
@@ -106,3 +109,11 @@ test('native doc wins over a plugin doc of the same canonical name', () => {
     assert.ok(d.path.endsWith(join('memory', PLUGIN, 'shared.md')));
     assert.ok(!d.path.includes(join('plugins', PLUGIN)));
 });
+test('legacy SKILL.md bundles are not memory docs', () => {
+    const names = listAllMemoryDocs('project').map((d) => d.name);
+    assert.ok(!names.includes('legacy'));
+    assert.ok(!names.includes(`${PLUGIN}/SKILL`));
+    assert.throws(() => resolveMemoryDoc('legacy'), /memory document not found/);
+    assert.throws(() => resolveMemoryDoc('legacy/SKILL'), /memory document not found/);
+    assert.throws(() => resolveMemoryDoc(`${PLUGIN}/SKILL`), /memory document not found/);
+});

package/dist/core/__tests__/migration.test.js

@@ -219,20 +219,55 @@ test('v4 is idempotent on re-open', () => {
     assert.equal(userVersion(db2), MIGRATIONS.length);
     assert.equal(edgeCount(db2), 1);
 });
-test('migration is idempotent on re-open and on re-run', () => {
-    // First open migrates v0 -> latest.
+function buildV4DbWithLaterColumns() {
+    ensureHome();
+    const raw = new DatabaseSync(canvasDbPath());
+    raw.exec(`
+    CREATE TABLE nodes (
+      node_id    TEXT PRIMARY KEY,
+      name       TEXT NOT NULL,
+      kind       TEXT NOT NULL,
+      mode       TEXT NOT NULL DEFAULT 'base',
+      lifecycle  TEXT NOT NULL DEFAULT 'terminal',
+      status     TEXT NOT NULL DEFAULT 'active',
+      cwd        TEXT NOT NULL,
+      parent     TEXT,
+      created    TEXT NOT NULL,
+      intent       TEXT,
+      pi_pid       INTEGER,
+      window       TEXT,
+      tmux_session TEXT,
+      pane         TEXT,
+      host_kind    TEXT
+    );
+    CREATE TABLE edges (
+      type     TEXT NOT NULL,
+      from_id  TEXT NOT NULL,
+      to_id    TEXT NOT NULL,
+      active   INTEGER NOT NULL DEFAULT 1,
+      created  TEXT NOT NULL,
+      PRIMARY KEY (type, from_id, to_id)
+    );
+    PRAGMA user_version = 4;
+  `);
+    raw
+        .prepare('INSERT INTO nodes (node_id, name, kind, status, cwd, created, pane, host_kind) VALUES (?,?,?,?,?,?,?,?)')
+        .run('stale', 'Stale', 'general', 'idle', '/tmp/work', '2020-01-01T00:00:00Z', '%9', 'broker');
+    return raw;
+}
+test('bug #99: a stale v4 db with later columns already present migrates cleanly', () => {
+    const raw = buildV4DbWithLaterColumns();
+    assert.equal(userVersion(raw), 4);
+    assert.equal(nodeColumns(raw).includes('pane'), true, 'precondition: pane already exists even though user_version is stale');
+    raw.close();
     const db = openDb();
     assert.equal(userVersion(db), MIGRATIONS.length);
-    // Re-running migrate() directly is a no-op (the gate skips applied steps).
-    // If the gate were broken, the second ALTER ADD COLUMN would throw.
-    assert.doesNotThrow(() => migrate(db));
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    // Re-opening from disk is likewise a no-op — no duplicate-column error.
-    closeDb();
-    const db2 = openDb();
-    assert.equal(userVersion(db2), MIGRATIONS.length);
-    const cols = nodeColumns(db2);
-    for (const c of RUNTIME_COLUMNS) {
-        assert.ok(cols.includes(c), `expected nodes.${c} to persist`);
-    }
+    const cols = nodeColumns(db);
+    assert.ok(cols.includes('pane'), 'pane survives the migration');
+    assert.ok(cols.includes('host_kind'), 'host_kind survives the migration');
+    const row = db
+        .prepare('SELECT pane, host_kind FROM nodes WHERE node_id = ?')
+        .get('stale');
+    assert.equal(row.pane, '%9');
+    assert.equal(row.host_kind, 'broker');
 });

package/dist/core/__tests__/model-ladders.test.d.ts

@@ -0,0 +1 @@
+export {};