@north-light/crouter 0.3.249 → 0.3.251

package/dist/commands/sys/daemon.js

@@ -8,22 +8,25 @@
 // This subtree starts, checks, and stops the daemon process.
 import { defineLeaf, defineBranch } from '../../core/command.js';
 import { InputError } from '../../core/io.js';
-import { spawnDaemon, stopDaemonProcess, sweepStrayDaemons } from '../../daemon/manage.js';
+import { isDaemonServing, spawnDaemon, stopDaemonProcess, sweepStrayDaemons } from '../../daemon/manage.js';
 import { isDaemonRunning, readPidfile, isPidAlive } from '../../daemon/pidfile.js';
 import { cliClient } from '../api-client.js';
 // daemon start
 const daemonStart = defineLeaf({
     name: 'start',
     description: 'start the daemon in the background',
-    whenToUse: 'bringing the crtrd supervisor up for the first time in a session so node window-exits get handled (no-op if it is already running)',
+    whenToUse: 'bringing the crtrd supervisor up for the first time in a session so node window-exits get handled (no-op only when its Unix API socket already serves)',
     help: {
         name: 'sys daemon start',
-        summary: 'start the crtrd supervisor daemon in the background (no-op if already running)',
+        summary: 'start the crtrd supervisor daemon in the background (no-op only if its Unix API socket serves)',
         params: [],
         output: [
             { name: 'started', type: 'boolean', required: true, constraint: 'True when a new daemon process was spawned; false when one was already running.' },
             { name: 'pid', type: 'number', required: false, constraint: 'PID of the newly spawned daemon.' },
             { name: 'existing_pid', type: 'number', required: false, constraint: 'PID of the already-running daemon (when started=false).' },
+            { name: 'running', type: 'boolean', required: false, constraint: 'True only when a live pidfile owner does not serve its Unix API socket.' },
+            { name: 'serving', type: 'boolean', required: false, constraint: 'False only when a live pidfile owner does not answer /healthz.' },
+            { name: 'next', type: 'string', required: false, constraint: 'Recovery instruction when running=true and serving=false.' },
         ],
         outputKind: 'object',
         effects: [
@@ -46,18 +49,28 @@ const daemonStatus = defineLeaf({
         summary: 'check whether the crtrd supervisor daemon is currently running',
         params: [],
         output: [
-            { name: 'running', type: 'boolean', required: true, constraint: 'True when the daemon is alive.' },
+            { name: 'running', type: 'boolean', required: true, constraint: 'True when the daemon pidfile owner is alive.' },
+            { name: 'serving', type: 'boolean', required: false, constraint: 'True when the live daemon answers /healthz; false when it does not.' },
             { name: 'pid', type: 'number', required: false, constraint: 'PID of the running daemon.' },
+            { name: 'next', type: 'string', required: false, constraint: 'Recovery instruction when running=true and serving=false.' },
         ],
         outputKind: 'object',
-        effects: ['Read-only: reads the pidfile and probes the pid.'],
+        effects: ['Read-only: reads the pidfile, probes the pid, and requests /healthz without autostart.'],
     },
     run: async (_input) => {
         const pid = readPidfile();
         const running = pid !== null && isPidAlive(pid);
-        return running
-            ? { running: true, pid }
-            : { running: false };
+        if (!running)
+            return { running: false };
+        const serving = await isDaemonServing();
+        return serving
+            ? { running: true, serving: true, pid }
+            : {
+                running: true,
+                serving: false,
+                pid,
+                next: 'Run `crtr sys daemon stop` to release the non-serving daemon before starting it again.',
+            };
     },
 });
 // daemon restart

package/dist/commands/sys/setup-core.js

@@ -178,8 +178,8 @@ const PACKAGE_COPY = {
     },
     'crtr-extensions': {
         name: 'pi-crtr-extensions',
-        shortDescription: 'crtr companion extensions — command palette, help gating, statusline, subscription/OAuth rotation, nested context.',
-        longDescription: 'Bundles the extensions built for crtr: a crtr slash-command palette, crtr/crouter help gating, surfacing of Claude Code marketplace plugin commands, nested AGENTS.md/CLAUDE.md loading, a model/subscription/token statusline badge, OAuth login + rotation across multiple Claude subscriptions (provider-rotation), and system-prompt trimming. The OAuth/rotation piece is what lets crtr authenticate your Claude account.',
+        shortDescription: 'crtr companion extensions — command palette, help gating, subscription/OAuth rotation, nested context.',
+        longDescription: 'Bundles the extensions built for crtr: a crtr slash-command palette, crtr/crouter help gating, surfacing of Claude Code marketplace plugin commands, nested AGENTS.md/CLAUDE.md loading, OAuth login + rotation across multiple Claude subscriptions (provider-rotation), and system-prompt trimming. The OAuth/rotation piece is what lets crtr authenticate your Claude account.',
     },
     'oauth-adapter': {
         name: 'pi-claude-oauth-adapter',

package/dist/core/__tests__/broker-stream-watchdog-floor.test.d.ts

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

package/dist/core/__tests__/broker-stream-watchdog-floor.test.js

@@ -0,0 +1,84 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { EventProjection } from '../runtime/broker/event-projection.js';
+import { RebindDriver } from '../runtime/broker/rebind.js';
+function generationFor(session) {
+    return {
+        id: 1,
+        session,
+        fallback: { blocked: false },
+        stagedProviderAgentEnd: null,
+        stagedWatchdogAbort: false,
+        stagedRefreshAbort: false,
+        stagedOverflowFailure: null,
+        executingTools: new Set(),
+    };
+}
+function projectionFor(session, generation) {
+    return new EventProjection({
+        registry: { broadcast: () => undefined },
+        faultRetry: { onEvent: () => undefined, clearTimer: () => undefined },
+        installedGeneration: () => generation,
+        currentSession: () => session,
+        notifyTurnAccepted: () => undefined,
+        emitStartupMilestone: () => undefined,
+        formatModelSpec: () => null,
+        refreshIntent: async () => false,
+        onRefreshIntentError: () => undefined,
+    });
+}
+test('agent_start arms the provider watchdog before another engine event arrives', (t) => {
+    t.mock.timers.enable({ apis: ['setTimeout'] });
+    let aborts = 0;
+    const session = { isStreaming: true, abort: async () => { aborts++; } };
+    const generation = generationFor(session);
+    const projection = projectionFor(session, generation);
+    projection.relayEvent({ type: 'agent_start' }, generation);
+    t.mock.timers.tick(5 * 60_000);
+    assert.equal(aborts, 1, 'the initial streaming event leaves a watchdog floor even if the engine falls silent immediately');
+    assert.equal(generation.stagedWatchdogAbort, true, 'the floor retains watchdog provenance for provider-fault recovery');
+});
+test('tool execution replaces the provider watchdog with the long ceiling', (t) => {
+    t.mock.timers.enable({ apis: ['setTimeout'] });
+    let aborts = 0;
+    const session = { isStreaming: true, abort: async () => { aborts++; } };
+    const generation = generationFor(session);
+    const projection = projectionFor(session, generation);
+    projection.relayEvent({ type: 'agent_start' }, generation);
+    projection.relayEvent({ type: 'tool_execution_start', toolCallId: 'stuck-tool' }, generation);
+    t.mock.timers.tick(5 * 60_000);
+    assert.equal(aborts, 0, 'a tool outlives the ordinary five-minute provider watchdog');
+    t.mock.timers.tick(15 * 60_000);
+    assert.equal(aborts, 1, 'a silent in-process tool cannot clear all watchdog coverage indefinitely');
+});
+test('rebind rearms the watchdog floor for a still-streaming replacement session', async () => {
+    const calls = [];
+    const projection = {
+        reset: () => calls.push('reset'),
+        rearmIfStreaming: (generation) => calls.push(`rearm:${generation.id}`),
+    };
+    const session = {
+        isStreaming: true,
+        systemPrompt: '',
+        bindExtensions: async () => undefined,
+        subscribe: () => () => undefined,
+    };
+    const driver = new RebindDriver({
+        nodeId: 'watchdog-floor-rebind',
+        cfg: {},
+        session,
+        services: {},
+        runtime: undefined,
+        uiContext: () => ({}),
+        registry: {},
+        toolGroups: { resetForSession: () => undefined },
+        faultRetry: () => ({ reset: () => undefined }),
+        projection: () => projection,
+        setActiveSession: () => undefined,
+        disposeAndExit: () => undefined,
+        onSessionRebind: () => undefined,
+        reWelcomeAll: () => undefined,
+    });
+    await driver.enqueueRebind(session, {});
+    assert.deepEqual(calls, ['reset', 'rearm:1'], 'a rebind that resets projection state immediately restores coverage for its live stream');
+});

package/dist/core/__tests__/broker-turn-admission.test.d.ts

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

package/dist/core/__tests__/broker-turn-admission.test.js

@@ -0,0 +1,44 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { createTurnAdmissionGate } from '../runtime/broker/turn-admission.js';
+function deferred() {
+    let resolve;
+    const promise = new Promise((done) => {
+        resolve = done;
+    });
+    return { promise, resolve };
+}
+test('concurrent starts admit one turn and reject the loser without a spurious settlement', async () => {
+    const gate = createTurnAdmissionGate();
+    const preflight = deferred();
+    const turn = deferred();
+    const enteredPreflight = deferred();
+    let streaming = false;
+    let admittedTurns = 0;
+    let settlements = 0;
+    const prompt = async (release) => {
+        enteredPreflight.resolve();
+        await preflight.promise;
+        if (streaming) {
+            release();
+            throw new Error('Agent is already processing');
+        }
+        streaming = true;
+        admittedTurns++;
+        release();
+        await turn.promise;
+        streaming = false;
+        settlements++;
+    };
+    const winner = gate.admit(prompt);
+    await enteredPreflight.promise;
+    const loser = gate.admit(prompt);
+    preflight.resolve();
+    await assert.rejects(loser, /Agent is already processing/);
+    assert.equal(admittedTurns, 1, 'only the winner entered a turn');
+    assert.equal(settlements, 0, 'the rejected call did not settle the live turn');
+    assert.equal(streaming, true, 'the winner remains live after the loser rejects');
+    turn.resolve();
+    await winner;
+    assert.equal(settlements, 1, 'the admitted turn alone settled');
+});

package/dist/core/__tests__/canvas-inbox-watcher-hold.test.js

@@ -13,6 +13,9 @@ import registerCanvasInboxWatcher from '../../pi-extensions/canvas-inbox-watcher
 import { appendInbox, readCursor } from '../feed/inbox.js';
 import { drainBearings } from '../runtime/kickoff.js';
 import { appendSituationalContext } from '../runtime/situational-context.js';
+import { createEngineDriver } from '../runtime/broker/engine-drive.js';
+import { createTurnAdmissionGate } from '../runtime/broker/turn-admission.js';
+import { heldDeferredInboxPromptJoin } from '../runtime/broker/held-deferred-inbox.js';
 import { createNode, getNode, recordPid, setIntent } from '../canvas/canvas.js';
 import { createProfile, pauseProfile, resumeProfile } from '../profiles/manifest.js';
 import { closeDb } from '../canvas/db.js';
@@ -105,7 +108,11 @@ function ensureWatcherNode() {
         cwd: '/tmp',
         kind: 'general',
         mode: 'base',
-        lifecycle: 'terminal',
+        // Resident: these cases are about the watcher's own cursor/handoff/hold
+        // contract at each tier as sent. A terminal node's mail is raised to the
+        // steering tier on append (feed/inbox.ts), which would route every case
+        // here as a steer.
+        lifecycle: 'resident',
         status: 'active',
     });
     recordPid(nodeId, process.pid);
@@ -271,6 +278,98 @@ describe('canvas inbox watcher — hold + idle delivery', () => {
         assert.equal(pi.injected.length, 1);
         assert.equal(pi.injected[0].deliverAs, undefined, 'idle → sendUserMessage triggers a turn, no deliverAs');
     });
+    test('the broker prompt boundary prepends held deferred mail before the human body', async () => {
+        freshNode('node-deferred-engine-prompt');
+        const pi = makeFakePi();
+        disposers.push(registerWatcher(pi));
+        await wait(TICK_MS + 100);
+        const entry = appendInbox('node-deferred-engine-prompt', {
+            from: 'child-4',
+            tier: 'deferred',
+            kind: 'update',
+            label: 'held update',
+        });
+        await wait(SETTLE_MS);
+        const order = [];
+        const session = {
+            isStreaming: false,
+            sendCustomMessage: async ({ content }) => { order.push(content); },
+            prompt: async (text, options) => {
+                order.push(text);
+                options.preflightResult?.(true);
+            },
+        };
+        const drive = createEngineDriver({
+            registry: { sendFrame: () => undefined },
+            replies: {},
+            session: () => session,
+            dispatches: { track: (promise) => promise },
+            memoryRefs: { guidanceFor: () => null },
+            authReloadGate: { inFlight: () => undefined },
+            rebind: { installedGeneration: () => 0 },
+            projection: {},
+            toolGroups: {},
+            turnAdmission: createTurnAdmissionGate(),
+        });
+        await drive({}, { type: 'prompt', text: 'where are we?' });
+        assert.equal(order.length, 2, 'one held card and the one human prompt share the admitted operation');
+        assert.match(order[0], /held update/, 'the held inbox card is first');
+        assert.equal(order[1], 'where are we?', 'the human body follows the held card');
+        assert.equal(readCursor('node-deferred-engine-prompt'), undefined, 'the joined handoff waits for settlement');
+        await pi.fire('agent_start', { type: 'agent_start' }, { isIdle: () => false });
+        await settle(pi);
+        assert.equal(readCursor('node-deferred-engine-prompt'), entry.entry_id, 'agent_settled commits the broker-joined handoff');
+        const staleFollowUpEntry = appendInbox('node-deferred-engine-prompt', {
+            from: 'child-4',
+            tier: 'deferred',
+            kind: 'update',
+            label: 'held after a stale client snapshot',
+        });
+        await wait(SETTLE_MS);
+        const beforeFollowUp = order.length;
+        await drive({}, { type: 'follow_up', text: 'continue from there' });
+        assert.equal(order.length, beforeFollowUp + 2, 'an idle-routed follow_up shares the same prompt boundary');
+        assert.match(order.at(-2), /held after a stale client snapshot/, 'the held card still precedes the stale follow_up body');
+        assert.equal(order.at(-1), 'continue from there');
+        await pi.fire('agent_start', { type: 'agent_start' }, { isIdle: () => false });
+        await settle(pi);
+        assert.equal(readCursor('node-deferred-engine-prompt'), staleFollowUpEntry.entry_id, 'the m-C prompt settles its joined handoff too');
+    });
+    test('a held deferred batch is prepended to an admitted human prompt and replays if that prompt reloads before settlement', async () => {
+        freshNode('node-deferred-human-prompt');
+        const pi = makeFakePi();
+        disposers.push(registerWatcher(pi));
+        await wait(TICK_MS + 100);
+        const entry = appendInbox('node-deferred-human-prompt', {
+            from: 'child-4',
+            tier: 'deferred',
+            kind: 'update',
+            label: 'held update',
+        });
+        await wait(SETTLE_MS);
+        assert.equal(pi.injected.length, 0, 'deferred-only mail remains held while no turn starts');
+        const firstPromptPrefix = [];
+        await heldDeferredInboxPromptJoin()?.({
+            sendCustomMessage: async ({ content }) => { firstPromptPrefix.push(content); },
+        });
+        assert.equal(firstPromptPrefix.length, 1, 'the held card is sent before the human prompt starts');
+        assert.match(firstPromptPrefix[0], /held update/);
+        assert.equal(readCursor('node-deferred-human-prompt'), undefined, 'the pre-prompt handoff is not committed');
+        await shutdown(pi);
+        assert.equal(readCursor('node-deferred-human-prompt'), undefined, 'a reload before agent_settled leaves the held entry replayable');
+        const replacement = makeFakePi();
+        disposers.push(registerWatcher(replacement));
+        await wait(SETTLE_MS);
+        const replayedPrefix = [];
+        await heldDeferredInboxPromptJoin()?.({
+            sendCustomMessage: async ({ content }) => { replayedPrefix.push(content); },
+        });
+        assert.equal(replayedPrefix.length, 1, 'the replacement prompt receives the uncommitted held card again');
+        assert.match(replayedPrefix[0], /held update/);
+        await replacement.fire('agent_start', { type: 'agent_start' }, { isIdle: () => false });
+        await settle(replacement);
+        assert.equal(readCursor('node-deferred-human-prompt'), entry.entry_id, 'only agent_settled commits the prompt-joined handoff');
+    });
     // Pause makes the profile inert while its broker is still alive: the entry
     // must be RETAINED, not consumed. A critical entry is the sharpest case —
     // its route aborts the live turn, exactly the punch-through pause forbids.

package/dist/core/__tests__/child-death-wake.test.js

@@ -48,9 +48,8 @@ function deadPid() {
 const GONE_PANE = '%999999';
 /** A booted child whose engine pid is DEAD and whose viewer pane is gone — the
  *  shape a crashed/finished child leaves behind. `pi_session_id` set so it is
- *  "booted"; `intent:null` so a delivered exit would classify as a crash
- *  (policy row 6, strict resume) — but no exit is delivered here: the tick
- *  alone must not touch it. */
+ *  "booted"; `intent:null` selects policy row 6 (strict resume) when the
+ *  authoritative tick observes the missing engine. */
 function deadEngineChild(id, over = {}) {
     createNode(node(id, {
         pane: GONE_PANE,
@@ -86,7 +85,7 @@ after(() => {
     delete process.env['CRTR_HOME'];
     resetFleetForTests();
 });
-test('exit-event authority: a dead-engine booted child is recovered, NOT reaped, and the tick fans NO wake to its dormant parent', async () => {
+test('a dead-engine booted child enters durable backoff before recovery, is NOT reaped, and fans NO wake to its dormant parent', async () => {
     const originalLaunch = headlessBrokerHost.launch;
     const launches = [];
     headlessBrokerHost.launch = (nodeId) => {
@@ -100,9 +99,14 @@ test('exit-event authority: a dead-engine booted child is recovered, NOT reaped,
         deadEngineChild('CHILD', { cwd: home }); // a cwd that exists — reviveNode's preflight refuses a missing one
         subscribe('PARENT', 'CHILD', true); // the spawn-time spine edge
         await superviseTick();
-        // A stale recorded pid is metadata, not a verdict: the row is relaunched on
-        // its saved session, never reaped to dead/done/idle.
-        assert.deepEqual(launches, ['CHILD'], 'the tick recovers the dead engine through the policy table');
+        const afterFirstTick = getNode('CHILD');
+        assert.deepEqual(launches, [], 'the first tick records the failed launch without relaunching');
+        assert.equal(afterFirstTick.respawn_failures, 1, 'the first tick records failure one durably');
+        assert.ok(afterFirstTick.respawn_not_before, 'the first tick records durable backoff');
+        await superviseTick(Date.parse(afterFirstTick.respawn_not_before));
+        // A stale recorded pid is metadata, not a verdict: once backoff matures,
+        // the row is relaunched on its saved session, never reaped to dead/done/idle.
+        assert.deepEqual(launches, ['CHILD'], 'the matured tick recovers the dead engine through the policy table');
         assert.equal(getNode('CHILD').status, 'active', 'CHILD is recovered, NOT reaped');
         assert.equal(readInboxSince('PARENT').length, 0, 'PARENT inbox EMPTY — no daemon liveness wake');
     }

package/dist/core/__tests__/collectible.test.d.ts

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

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

@@ -0,0 +1,88 @@
+import { after, before, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createNode, getRow, isCollectible, setFrozen, transitionStatusIntent, } from '../canvas/canvas.js';
+import { closeDb } from '../canvas/db.js';
+let home;
+function node(id, over = {}) {
+    return {
+        node_id: id,
+        name: id,
+        created: new Date().toISOString(),
+        cwd: '/tmp/work',
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+        ...over,
+    };
+}
+function terminalRow(id, reason, status = 'done') {
+    createNode(node(id));
+    transitionStatusIntent(id, { status, terminal_reason: reason });
+    return getRow(id);
+}
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-collectible-'));
+    process.env['CRTR_HOME'] = home;
+});
+beforeEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+});
+after(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    delete process.env['CRTR_HOME'];
+});
+test('isCollectible applies the terminal reason truth table and absolute retains', () => {
+    const terminalCases = [
+        ['finalized', 'done', true, true],
+        ['finished', 'done', true, true],
+        ['parked', 'done', true, true],
+        ['closed', 'dead', true, true],
+        ['retired', 'canceled', true, true],
+        ['crashed', 'dead', false, true],
+        ['stranded', 'canceled', false, true],
+        [null, 'done', false, true],
+    ];
+    for (const [reason, status, beforeTtl, pastTtl] of terminalCases) {
+        const row = terminalRow(`reason-${reason ?? 'null'}`, reason, status);
+        assert.equal(isCollectible(row), beforeTtl, `${reason ?? 'null'} before TTL`);
+        assert.equal(isCollectible(row, { pastTtl: true }), pastTtl, `${reason ?? 'null'} past TTL`);
+    }
+    const frozen = terminalRow('frozen', 'closed');
+    setFrozen(frozen.node_id, new Date().toISOString());
+    createNode(node('worktree', {
+        managed_worktree: {
+            state: 'open',
+            path: '/tmp/worktree',
+            branch: 'crtr/worktree',
+            repo_root: '/tmp/repo',
+            base_ref: 'main',
+            base_sha: 'base',
+            created: new Date().toISOString(),
+        },
+    }));
+    transitionStatusIntent('worktree', { status: 'done', terminal_reason: 'closed' });
+    const caller = terminalRow('caller', 'closed');
+    createNode(node('active'));
+    const nonTerminal = getRow('active');
+    const absoluteRows = [getRow(frozen.node_id), getRow('worktree'), caller, nonTerminal];
+    const previousNodeId = process.env['CRTR_NODE_ID'];
+    process.env['CRTR_NODE_ID'] = 'caller';
+    try {
+        for (const row of absoluteRows) {
+            assert.equal(isCollectible(row), false, `${row.node_id} before TTL`);
+            assert.equal(isCollectible(row, { pastTtl: true }), false, `${row.node_id} past TTL`);
+        }
+    }
+    finally {
+        if (previousNodeId === undefined)
+            delete process.env['CRTR_NODE_ID'];
+        else
+            process.env['CRTR_NODE_ID'] = previousNodeId;
+    }
+});

package/dist/core/__tests__/context-intro.test.js

@@ -2,8 +2,8 @@
 //   1. Situational context rides the bearings as a sibling block, and only
 //      once something has been set.
 //   2. canvas-context-intro injects the block as its own session message at
-//      session_start (before the first prompt), idempotent across resumes,
-//      inert without a node id — and its renderer never overruns the terminal.
+//      session_start (before the first prompt), idempotent across resumes, and
+//      inert without a node id.
 //
 // Run: node --import tsx/esm --test src/core/__tests__/context-intro.test.ts
 import { test, before, beforeEach, after, afterEach } from 'node:test';
@@ -15,7 +15,7 @@ import { closeDb } from '../canvas/db.js';
 import { apiSocketPath } from '../canvas/paths.js';
 import { spawnNode } from '../runtime/nodes.js';
 import { appendSituationalContext, formatSituationalProse, situationalContextEnvelope, } from '../runtime/situational-context.js';
-import registerCanvasContextIntro, { renderContextMessage, CONTEXT_INTRO_CUSTOM_TYPE, } from '../../pi-extensions/canvas-context-intro.js';
+import registerCanvasContextIntro, { CONTEXT_INTRO_CUSTOM_TYPE, } from '../../pi-extensions/canvas-context-intro.js';
 import { buildContextBearings as buildContextIntro } from '../runtime/bearings.js';
 import { createApiServer } from '../../daemon/api/server.js';
 let home;
@@ -61,18 +61,16 @@ function makeFakePi(entries = []) {
     return {
         sent: [],
         entries,
-        renderers: {},
         on(e, h) { if (e === 'session_start')
             this.handler = h; },
         sendMessage(m) {
             this.sent.push(m);
             this.entries.push({ type: 'custom_message', ...m });
         },
-        registerMessageRenderer(t, r) { this.renderers[t] = r; },
     };
 }
 function fakeCtx(pi) {
-    return { sessionManager: { getEntries: () => pi.entries } };
+    return { sessionManager: { getBranch: () => pi.entries } };
 }
 test('session_start injects the block as the first message of an empty session', async () => {
     const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
@@ -111,38 +109,3 @@ test('session_start is inert when CRTR_NODE_ID is absent', async () => {
     await pi.handler({ reason: 'startup' }, fakeCtx(pi));
     assert.equal(pi.sent.length, 0);
 });
-test('renderer registered for the customType; collapsed hides body, ctrl+o expand reveals it', () => {
-    const pi = makeFakePi();
-    registerCanvasContextIntro(pi);
-    const renderer = pi.renderers[CONTEXT_INTRO_CUSTOM_TYPE];
-    assert.ok(renderer, 'message renderer registered for crtr-context');
-    const body = '<crtr-bearings>\nshared document store\n</crtr-bearings>';
-    const message = { customType: CONTEXT_INTRO_CUSTOM_TYPE, content: body };
-    const theme = {}; // no fg → plain text, easy to assert
-    // Collapsed (default): a single stub line, NONE of the body.
-    const collapsed = renderContextMessage(message, { expanded: false }, theme).render(80);
-    assert.equal(collapsed.length, 1, 'collapsed is one line');
-    assert.match(collapsed[0], /ctrl\+o to expand/);
-    assert.ok(!collapsed.join('\n').includes('shared document store'), 'body hidden when collapsed');
-    // Expanded (Ctrl+O): label + full body.
-    const expanded = renderContextMessage(message, { expanded: true }, theme).render(80);
-    const joined = expanded.join('\n');
-    assert.ok(joined.includes('shared document store'), 'body shown when expanded');
-    assert.ok(joined.includes(`[${CONTEXT_INTRO_CUSTOM_TYPE}]`), 'expanded shows the label');
-});
-test('renderer never emits a line wider than the terminal (truncates the collapsed stub)', () => {
-    // Regression: a fixed-width stub crashed pi's TUI at narrow widths
-    // ("Rendered line 1 exceeds terminal width"). Every emitted line — collapsed
-    // or expanded — must fit within the width handed to render().
-    const body = Array.from({ length: 6 }, () => 'x'.repeat(200)).join('\n');
-    const message = { customType: CONTEXT_INTRO_CUSTOM_TYPE, content: body };
-    const theme = {}; // no fg → plain text, so .length == visible width
-    for (const w of [1, 2, 5, 10, 20, 42, 80]) {
-        for (const expanded of [false, true]) {
-            const lines = renderContextMessage(message, { expanded }, theme).render(w);
-            for (const line of lines) {
-                assert.ok([...line].length <= w, `width=${w} expanded=${expanded}: line ${[...line].length} cols exceeds ${w}: ${JSON.stringify(line)}`);
-            }
-        }
-    }
-});