@crouton-kit/crouter 0.3.32 → 0.3.33

package/dist/commands/sys/sysprompt.js

@@ -0,0 +1,86 @@
+import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { defineLeaf } from '../../core/command.js';
+import { InputError } from '../../core/io.js';
+import { getNode, jobDir } from '../../core/canvas/index.js';
+import { focusOf, openNodeWindow } from '../../core/runtime/placement.js';
+function shellQuote(s) {
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+export const sysSyspromptLeaf = defineLeaf({
+    name: 'sysprompt',
+    description: 'print a node\'s assembled system prompt',
+    whenToUse: 'you want to inspect a node\'s assembled system prompt headlessly, without paying conversation/context cost — the broker writes it to disk while live, and this command reads that artifact back as markdown.',
+    help: {
+        name: 'sys sysprompt',
+        summary: 'print a node\'s assembled system prompt',
+        params: [
+            { kind: 'positional', name: 'node', required: false, constraint: 'Node id. Defaults to the calling node (CRTR_NODE_ID).' },
+            { kind: 'flag', name: 'window', type: 'bool', required: false, constraint: 'Open the assembled prompt in a NEW tmux window in the session currently showing that node instead of printing to stdout.' },
+        ],
+        output: [
+            { name: 'node_id', type: 'string', required: true, constraint: 'The node whose prompt was read.' },
+            { name: 'captured_at', type: 'string', required: true, constraint: 'File mtime in ISO-8601 UTC.' },
+            { name: 'chars', type: 'number', required: true, constraint: 'Character count of the stored prompt.' },
+            { name: 'prompt', type: 'string', required: true, constraint: 'The assembled system prompt, exactly as pi built it.' },
+            { name: 'session', type: 'string', required: false, constraint: 'tmux session showing the node (only when --window is used).' },
+            { name: 'window', type: 'string', required: false, constraint: 'tmux window opened for the prompt (only when --window is used).' },
+        ],
+        outputKind: 'object',
+        effects: ['Read-only: reads the node\'s job/system-prompt.md artifact, or opens it in a tmux window.'],
+    },
+    run: async (input) => {
+        const nodeId = input['node']?.trim() || process.env['CRTR_NODE_ID'];
+        if (nodeId === undefined || nodeId === '') {
+            throw new InputError({ error: 'empty_node', message: 'a node id is required', field: 'node', next: 'Pass a node id or run from inside a node.' });
+        }
+        if (getNode(nodeId) === null) {
+            throw new InputError({ error: 'not_found', message: `no node: ${nodeId}`, field: 'node', next: 'List nodes with `crtr node inspect list`.' });
+        }
+        const path = join(jobDir(nodeId), 'system-prompt.md');
+        if (!existsSync(path)) {
+            throw new InputError({
+                error: 'not_found',
+                message: `system prompt not captured yet for ${nodeId}`,
+                field: 'node',
+                next: 'Focus or revive the node once while its broker is live, then rerun `crtr sys sysprompt <node>`.',
+            });
+        }
+        const prompt = readFileSync(path, 'utf8');
+        const capturedAt = statSync(path).mtime.toISOString();
+        if (input['window'] === true) {
+            const focus = focusOf(nodeId);
+            if (focus === null || focus.session === null || focus.session === '') {
+                throw new InputError({
+                    error: 'not_focused',
+                    message: `node ${nodeId} is not currently shown in tmux`,
+                    field: 'node',
+                    next: `Focus the node first with \`crtr node focus ${nodeId}\`, then rerun \`crtr sys sysprompt --window ${nodeId}\`.`,
+                });
+            }
+            const tmpPath = join(tmpdir(), `crtr-sysprompt-${nodeId}.md`);
+            writeFileSync(tmpPath, prompt, 'utf8');
+            const q = shellQuote(tmpPath);
+            // Syntax-highlight the prompt (markdown + its structural XML tags both stay visible).
+            // bat pages by default; markdown RENDERERS (termrender, glow) are wrong here — they
+            // silently swallow block-level XML tags, dropping most of the assembled prompt.
+            // Fall back to `less -R` when bat is not installed.
+            const command = `if command -v bat >/dev/null 2>&1; then bat --language=markdown --color=always --paging=always --style=plain ${q}; else less -R ${q}; fi`;
+            const opened = openNodeWindow({ session: focus.session, name: `sysprompt:${nodeId}`, cwd: process.cwd(), env: {}, command });
+            if (opened === null) {
+                throw new InputError({
+                    error: 'window_open_failed',
+                    message: `tmux could not open a window for node ${nodeId}`,
+                    field: 'node',
+                    next: 'Check the tmux server is reachable, then retry.',
+                });
+            }
+            return { node_id: nodeId, session: focus.session, window: opened.window };
+        }
+        return { node_id: nodeId, captured_at: capturedAt, chars: prompt.length, prompt };
+    },
+    render: (r) => ('window' in r)
+        ? `Opened system prompt for node ${r['node_id']} in tmux session ${r['session']} — window ${r['window']}.`
+        : `- node_id: ${r['node_id']}\n- captured_at: ${r['captured_at']}\n- chars: ${r['chars']}\n\n${r['prompt']}`,
+});

package/dist/commands/sys.js

@@ -1,9 +1,13 @@
-// `crtr sys` subtree: config {get,set,path}, doctor, update, version.
+// `crtr sys` subtree: config {get,set,path}, doctor, sync, update, version.
 // Replaces old config.ts + doctor.ts + update.ts command files.
 import { defineBranch } from '../core/command.js';
 import { configBranch } from './sys/config.js';
 import { sysDoctorLeaf } from './sys/doctor.js';
 import { sysFeedbackLeaf } from './sys/feedback.js';
+import { sysSettingsLeaf } from './sys/settings.js';
+import { sysSyspromptLeaf } from './sys/sysprompt.js';
+import { promptReviewLeaf } from './sys/prompt-review.js';
+import { sysPromptStudioLeaf } from './sys/promptstudio.js';
 import { sysSyncLeaf } from './sys/sync.js';
 import { sysUpdateLeaf, sysVersionLeaf } from './sys/update.js';
 export function registerSys() {
@@ -11,13 +15,13 @@ export function registerSys() {
         name: 'sys',
         rootEntry: {
             concept: 'crtr configuration, diagnostics, and self-management',
-            desc: 'config, doctor, sync, update, version, feedback',
-            useWhen: 'managing the crtr installation',
+            desc: 'config, settings, doctor, sysprompt, prompt-review, promptstudio, sync, update, version, feedback',
+            useWhen: 'managing the crtr installation or opening built-in system views',
         },
         help: {
             name: 'sys',
-            summary: 'crtr system configuration, diagnostics, and self-management',
+            summary: 'crtr system configuration, settings, diagnostics, and self-management',
         },
-        children: [configBranch, sysDoctorLeaf, sysFeedbackLeaf, sysSyncLeaf, sysUpdateLeaf, sysVersionLeaf],
+        children: [configBranch, sysSettingsLeaf, sysDoctorLeaf, sysSyspromptLeaf, promptReviewLeaf, sysPromptStudioLeaf, sysFeedbackLeaf, sysUpdateLeaf, sysVersionLeaf, sysSyncLeaf],
     });
 }

package/dist/commands/view-new.js

@@ -3,8 +3,8 @@
 // Writes the four contract files (core.mjs + tui.mjs + web.jsx + text.mjs) under
 // <viewsDir(scope)>/<name>/ from the stubs in prompts/view.ts (mkdir -p first).
 // Refuses if a view of that name already resolves. The scaffold runs as-is via
-// `crtr view run <name>` (TUI) and `crtr view serve <name>` (web). Mirrors how
-// skill authoring scaffolds (resolve scope → ensure dir → write → point at run).
+// `crtr view run <name>` (TUI) and `crtr view serve <name>` (web). Mirrors the
+// scope → ensure dir → write → point-at-run shape of other authoring commands.
 import { mkdirSync, existsSync } from 'node:fs';
 import { writeFileSync } from 'node:fs';
 import { join } from 'node:path';

package/dist/core/__tests__/artifact-paths.test.d.ts

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

package/dist/core/__tests__/artifact-paths.test.js

@@ -0,0 +1,44 @@
+import { test, before, beforeEach, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { interactionsRoot, migrateLegacyWorkspaceDirs, workspaceRoot } from '../artifact.js';
+let home;
+let origHome;
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-workspaces-'));
+    origHome = process.env['HOME'];
+    process.env['HOME'] = home;
+});
+beforeEach(() => {
+    rmSync(home, { recursive: true, force: true });
+    mkdirSync(join(home, '.crouter'), { recursive: true });
+});
+after(() => {
+    rmSync(home, { recursive: true, force: true });
+    if (origHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = origHome;
+});
+test('workspace roots live under ~/.crouter/workspaces/<mangled-cwd>', () => {
+    const cwd = '/Users/silasrhyneer/Code/cli/crouter';
+    const root = join(home, '.crouter', 'workspaces', '-Users-silasrhyneer-Code-cli-crouter');
+    assert.equal(workspaceRoot(cwd), root);
+    assert.equal(interactionsRoot(cwd), join(root, 'interactions'));
+});
+test('migrateLegacyWorkspaceDirs moves only legacy mangled cwd dirs', () => {
+    const legacy = join(home, '.crouter', '-Users-silasrhyneer-Code-cli-crouter');
+    const workspace = join(home, '.crouter', 'workspaces', '-Users-silasrhyneer-Code-cli-crouter');
+    const memory = join(home, '.crouter', 'memory');
+    const canvas = join(home, '.crouter', 'canvas');
+    mkdirSync(legacy, { recursive: true });
+    mkdirSync(memory, { recursive: true });
+    mkdirSync(canvas, { recursive: true });
+    migrateLegacyWorkspaceDirs();
+    assert.ok(!existsSync(legacy));
+    assert.ok(existsSync(workspace));
+    assert.ok(existsSync(memory));
+    assert.ok(existsSync(canvas));
+});

package/dist/core/__tests__/broker-preflight.test.d.ts

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

package/dist/core/__tests__/broker-preflight.test.js

@@ -0,0 +1,85 @@
+// Run with: node --import tsx/esm --test src/core/__tests__/broker-preflight.test.ts
+//
+// Bug-regression: preflight broker launch validation should resolve the default
+// broker package, reject broken custom engines, and fail before a detached broker
+// process is spawned when session args are invalid or missing.
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { preflightBrokerLaunch } from '../runtime/host.js';
+const HERE = dirname(fileURLToPath(import.meta.url));
+const FAKE_ENGINE = join(HERE, 'fixtures', 'fake-engine.ts');
+let home;
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-preflight-'));
+    process.env['CRTR_HOME'] = home;
+});
+after(() => {
+    rmSync(home, { recursive: true, force: true });
+    delete process.env['CRTR_HOME'];
+});
+function assertLaunchWrote(nodeId, inv) {
+    const launchPath = join(home, 'nodes', nodeId, 'broker-launch.json');
+    const parsed = JSON.parse(readFileSync(launchPath, 'utf8'));
+    assert.deepEqual(parsed, inv, 'the launch recipe exists and parses as JSON');
+}
+test('preflightBrokerLaunch uses the installed default broker package when no engine override is set', () => {
+    const nodeId = 'preflight-default-engine';
+    const inv = {
+        argv: ['hello'],
+        env: {},
+    };
+    const prev = process.env['CRTR_BROKER_ENGINE'];
+    delete process.env['CRTR_BROKER_ENGINE'];
+    try {
+        assert.doesNotThrow(() => preflightBrokerLaunch(nodeId, inv, '/tmp/work'));
+    }
+    finally {
+        if (prev === undefined)
+            delete process.env['CRTR_BROKER_ENGINE'];
+        else
+            process.env['CRTR_BROKER_ENGINE'] = prev;
+    }
+    assertLaunchWrote(nodeId, inv);
+});
+test('preflightBrokerLaunch fails fast when the broker engine module cannot be resolved', () => {
+    const nodeId = 'preflight-bad-engine';
+    const inv = {
+        argv: ['hello'],
+        env: { CRTR_BROKER_ENGINE: '@crouton-kit/does-not-exist' },
+    };
+    assert.throws(() => preflightBrokerLaunch(nodeId, inv, '/tmp/work'), /cannot resolve broker engine/i);
+    assertLaunchWrote(nodeId, inv);
+});
+test('preflightBrokerLaunch validates the exact broker engine env passed to the detached broker', () => {
+    const nodeId = 'preflight-empty-engine';
+    const inv = {
+        argv: ['hello'],
+        env: { CRTR_BROKER_ENGINE: '   ' },
+    };
+    assert.throws(() => preflightBrokerLaunch(nodeId, inv, '/tmp/work'), /cannot resolve broker engine/i);
+    assertLaunchWrote(nodeId, inv);
+});
+test('preflightBrokerLaunch fails fast when a bare --session id would be rejected by the broker', () => {
+    const nodeId = 'preflight-bare-session';
+    const inv = {
+        argv: ['--session', 'uuid-123'],
+        env: { CRTR_BROKER_ENGINE: FAKE_ENGINE },
+    };
+    assert.throws(() => preflightBrokerLaunch(nodeId, inv, '/tmp/work'), /bare --session id/i);
+    assertLaunchWrote(nodeId, inv);
+});
+test('preflightBrokerLaunch fails fast when a plainly-encoded session file path is missing', () => {
+    const nodeId = 'preflight-missing-session';
+    const inv = {
+        argv: ['--session', join(home, 'sessions', 'missing.jsonl')],
+        env: { CRTR_BROKER_ENGINE: FAKE_ENGINE },
+    };
+    assert.throws(() => preflightBrokerLaunch(nodeId, inv, '/tmp/work'), /missing session file/i);
+    const launchPath = join(home, 'nodes', nodeId, 'broker-launch.json');
+    const parsed = JSON.parse(readFileSync(launchPath, 'utf8'));
+    assert.deepEqual(parsed, inv, 'the launch recipe exists and parses as JSON');
+});

package/dist/core/__tests__/broker-sdk-wiring.test.js

@@ -71,6 +71,21 @@ test('C3 — services path registers an extension model provider; the broker ses
         rmSync(cwd, { recursive: true, force: true });
     }
 });
+test('C3b — broker splits model thinking suffix before SDK registry lookup', async () => {
+    const cwd = mkdtempSync(join(tmpdir(), 'crtr-c3b-'));
+    try {
+        const { session } = await buildBrokerSession(realEngine, cfg(cwd, { extensionPaths: [C3_EXT], model: 'c3prov/c3model:high' }));
+        try {
+            assert.equal(session.model?.id, 'c3model', 'C3b: suffixed model specs resolve by model id instead of falling back to SDK default');
+        }
+        finally {
+            session.dispose();
+        }
+    }
+    finally {
+        rmSync(cwd, { recursive: true, force: true });
+    }
+});
 // ===========================================================================
 // C4 — project context (AGENTS.md) is injected into the system prompt. The
 // services path loads project context files; on the 0.78.1 pin there is no

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

@@ -1,6 +1,6 @@
 import { test, before, after, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync, statSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, getNode, getRow, updateNode, setStatus, listNodes, subscribe, unsubscribe, setSubscriptionActive, recordSpawn, subscribersOf, subscriptionsOf, view, hasActiveLiveSubscription, rebuildIndex, } from '../canvas/canvas.js';
@@ -139,6 +139,42 @@ test('recordSpawn writes the audit-only spawned_by edge', () => {
     assert.equal(subscriptionsOf('child').length, 0);
     assert.equal(subscribersOf('parent').length, 0);
 });
+// --- Regression: Hearth M0 cold-boot 0-byte meta.json -----------------------
+// A bare write-temp-then-rename WITHOUT fsync left meta.json 0-byte on the guest's
+// durable NFS home after a sandbox recreate (the open inode is silly-renamed and the
+// new content never flushed). Cold-boot's `canvas rebuild-index` + `canvas revive`
+// then JSON.parse('') → "Unexpected end of JSON input" → the chain dies → guest
+// daemon-only, no web on 7878. Fix: writeMeta fsyncs temp+parent dir (durable), and
+// readMeta/rebuildIndex tolerate an empty/corrupt meta as MISSING instead of throwing.
+test('writeMeta produces a durable, non-empty, atomically-named meta.json', () => {
+    createNode(node('a'));
+    const p = nodeMetaPath('a');
+    assert.ok(statSync(p).size > 0, 'meta.json must be non-empty');
+    assert.ok(!existsSync(`${p}.tmp`), 'temp file must be renamed away, not left behind');
+    assert.equal(getNode('a')?.node_id, 'a');
+});
+test('getNode returns null (not throw) on a 0-byte meta.json', () => {
+    createNode(node('a'));
+    writeFileSync(nodeMetaPath('a'), ''); // the observed NFS 0-byte corruption
+    assert.equal(getNode('a'), null);
+});
+test('getNode returns null (not throw) on an unparseable meta.json', () => {
+    createNode(node('a'));
+    writeFileSync(nodeMetaPath('a'), '{ broken json');
+    assert.equal(getNode('a'), null);
+});
+test('rebuildIndex skips a corrupt-meta node instead of throwing', () => {
+    createNode(node('good'));
+    createNode(node('bad'));
+    writeFileSync(nodeMetaPath('bad'), ''); // 0-byte corruption on one node
+    closeDb();
+    rmSync(join(home, 'canvas.db'), { force: true });
+    rmSync(join(home, 'canvas.db-wal'), { force: true });
+    rmSync(join(home, 'canvas.db-shm'), { force: true });
+    assert.doesNotThrow(() => rebuildIndex());
+    assert.equal(getRow('good')?.node_id, 'good'); // healthy node reindexed
+    assert.equal(getRow('bad'), null); // corrupt node skipped, no crash
+});
 test('rebuildIndex reconstructs node rows from on-disk metas', () => {
     createNode(node('a', { parent: null }));
     createNode(node('b', { parent: 'a' }));

package/dist/core/__tests__/chat-view-reconnect.test.d.ts

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

package/dist/core/__tests__/chat-view-reconnect.test.js

@@ -0,0 +1,70 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+// @ts-ignore -- chat core is a plain built view module with no generated .d.ts.
+import core from '../../builtin-views/chat/core.mjs';
+import { openLocalStream } from '../view/stream-local.js';
+const flushMicrotasks = async () => {
+    await Promise.resolve();
+};
+test('local invalid/no-node stream failures close asynchronously after the channel returns', async () => {
+    for (const target of ['not/valid', 'definitely-not-a-real-node-review-5362b32']) {
+        const events = [];
+        const channel = openLocalStream({ kind: 'stream', target, role: 'controller' }, {
+            onFrame() {
+                events.push('frame');
+            },
+            onClose(reason) {
+                events.push(`close:${reason}`);
+            },
+            onError(err) {
+                events.push(`error:${err.kind}`);
+            },
+        });
+        assert.equal(events.length, 0, `${target}: callbacks stay deferred until after openLocalStream returns`);
+        assert.equal(typeof channel.close, 'function', `${target}: channel is returned before failure callbacks fire`);
+        await flushMicrotasks();
+        assert.ok(events[0]?.startsWith('error:'), `${target}: reports the terminal open failure as an error`);
+        assert.equal(events[1]?.startsWith('close:'), true, `${target}: follows with streamClose`);
+    }
+});
+test('control_changed demotion updates reconnect intent without clobbering an explicit controller request', () => {
+    let current = {
+        target: 'n1',
+        desiredRole: 'controller',
+        channel: null,
+        clientId: 'client-1',
+        conn: 'open',
+        role: 'controller',
+        controllerId: 'client-1',
+        session: null,
+        transcript: [],
+        draft: '',
+        notices: [],
+        pendingDialog: null,
+        queued: [],
+        contextTokens: undefined,
+    };
+    const ctx = {
+        get state() {
+            return current;
+        },
+        set(next) {
+            current = typeof next === 'function' ? next(current) : next;
+        },
+        signal: {
+            clearBanner() { },
+            setBanner() { },
+            setStatus() { },
+            setSubtitle() { },
+            setMode() { },
+            quit() { },
+        },
+    };
+    core.intents.streamFrame(ctx, { type: 'control_changed', controller_id: 'other-client' });
+    assert.equal(current.role, 'observer');
+    assert.equal(current.desiredRole, 'observer');
+    current = { ...current, role: 'observer', desiredRole: 'controller' };
+    core.intents.streamFrame(ctx, { type: 'control_changed', controller_id: 'other-client' });
+    assert.equal(current.role, 'observer');
+    assert.equal(current.desiredRole, 'controller');
+});

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

@@ -23,7 +23,7 @@
 // the one genuine-terminal wake that still lives in core: close.ts.
 import { test, before, after, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { spawnSync } from 'node:child_process';
@@ -46,6 +46,15 @@ function node(id, over = {}) {
         ...over,
     };
 }
+/** Write a minimal pi session with one assistant message so the node reads as
+ *  NON-empty (produced AI output) — otherwise closeNode reaps it outright. */
+function withSession(id) {
+    const dir = join(home, 'sessions');
+    mkdirSync(dir, { recursive: true });
+    const f = join(dir, `${id}.jsonl`);
+    writeFileSync(f, JSON.stringify({ type: 'message', message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }] } }) + '\n');
+    return f;
+}
 /** A pid that is guaranteed dead. */
 function deadPid() {
     const r = spawnSync('true', [], { stdio: 'ignore' });
@@ -115,7 +124,7 @@ test('pid-only liveness: a dead-engine booted child is revivable, NOT reaped, an
 test('node close of a child wakes its SURVIVING manager (the parent outside the closing set)', async () => {
     inboxWaitingParent('PARENT');
     // A booted child; closeNode tears its (paneless-for-the-test) engine down.
-    createNode(node('CHILD', { pane: GONE_PANE, tmux_session: 'crtr-cdw', window: '@1', pi_session_id: 'booted', status: 'active' }));
+    createNode(node('CHILD', { pane: GONE_PANE, tmux_session: 'crtr-cdw', window: '@1', pi_session_id: 'booted', pi_session_file: withSession('CHILD'), status: 'active' }));
     subscribe('PARENT', 'CHILD', true); // PARENT is a manager OUTSIDE the close set
     // Closing CHILD: closingSet({CHILD}) cannot pull in PARENT (PARENT is a
     // SUBSCRIBER of CHILD, never a descendant), so PARENT survives + must wake.

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

@@ -1,13 +1,25 @@
 import { test, before, after, beforeEach } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, getNode, subscribe } from '../canvas/canvas.js';
+import { nodeDir } from '../canvas/paths.js';
 import { closeDb } from '../canvas/db.js';
 import { closeNode } from '../runtime/close.js';
 import { readInboxSince } from '../feed/inbox.js';
 let home;
+/** Write a minimal pi session containing one assistant message, so the node
+ *  reads as NON-empty (it produced AI output). Without this a node has no
+ *  session and closeNode reaps it outright instead of cancel+notice — see the
+ *  dedicated empty-reap test below. */
+function withSession(id) {
+    const dir = join(home, 'sessions');
+    mkdirSync(dir, { recursive: true });
+    const f = join(dir, `${id}.jsonl`);
+    writeFileSync(f, JSON.stringify({ type: 'message', message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }] } }) + '\n');
+    return f;
+}
 function node(id, over = {}) {
     return {
         node_id: id,
@@ -18,6 +30,7 @@ function node(id, over = {}) {
         mode: 'base',
         lifecycle: 'terminal',
         status: 'active',
+        pi_session_file: withSession(id),
         ...over,
     };
 }
@@ -132,6 +145,31 @@ test('closing a leaf node closes only itself', () => {
 test('throws on an unknown node', () => {
     assert.throws(() => closeNode('ghost'), /unknown node/);
 });
+// Regression: empty nodes (engine never produced an assistant message) are
+// USELESS shells, so closing one must DELETE it from the graph + disk, not park
+// a canceled husk. (Reported: "many nodes on the canvas that haven't generated
+// anything yet, just taking up space" — close/detach now reap them.)
+test('closing an EMPTY node (no AI output) deletes it from the graph + disk', () => {
+    createNode(node('shell', { pi_session_file: null }));
+    const dir = nodeDir('shell');
+    assert.ok(existsSync(dir), 'dir exists before close');
+    const res = closeNode('shell');
+    assert.deepEqual(res.closed, ['shell']);
+    assert.equal(getNode('shell'), null, 'row deleted from the graph');
+    assert.equal(existsSync(dir), false, 'on-disk dir removed');
+});
+// A close that reaps an EMPTY child still wakes a SURVIVING manager — the child
+// is gone either way, so a parent that delegated must learn it vanished.
+test('reaping an empty child still notifies a surviving external manager', () => {
+    createNode(node('child', { pi_session_file: null })); // empty → reaped
+    createNode(node('mgr')); // external manager, NOT closed
+    spawnEdge('mgr', 'child');
+    closeNode('child');
+    assert.equal(getNode('child'), null, 'empty child reaped');
+    const note = readInboxSince('mgr').at(-1);
+    assert.match(note.label, /Child closed/);
+    assert.equal(note.data?.['child'], 'child');
+});
 // NOTE (broker-host cut): the former "Step 7: closing a FOCUSED node closes its
 // focus row + nulls its pane (tearDownNode)" test was DELETED. close.ts no longer
 // routes through the synchronous tearDownNode — it sends the broker `shutdown`

package/dist/core/__tests__/connection-reconnect-resume.test.d.ts

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

package/dist/core/__tests__/connection-reconnect-resume.test.js

@@ -0,0 +1,37 @@
+// Run with: node --import tsx/esm --test src/core/__tests__/connection-reconnect-resume.test.ts
+//
+// BUG-REGRESSION: connection faults follow the shared broker-owned retry schedule.
+// The broker exercises this policy table directly.
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { nextFaultRetry, policyFor } from '../runtime/fault-recovery.js';
+const NOW = Date.parse('2026-06-23T20:00:00.000Z');
+const ISO = (ms) => new Date(ms).toISOString();
+// ---------------------------------------------------------------------------
+// J1 — the policy table itself: connection faults retry on a 5s → 2x → 60s
+// cap, and the planner advances the next attempt.
+// ---------------------------------------------------------------------------
+test('J1 policy table: connection faults use the shared retry schedule', () => {
+    assert.deepEqual(policyFor('connection'), {
+        kind: 'connection',
+        gate: 'online',
+        max: 8,
+        baseDelayMs: 5_000,
+        capDelayMs: 60_000,
+        fatal: false,
+    });
+    const plan = nextFaultRetry({
+        link: 'pi→provider',
+        op: 'generation turn',
+        kind: 'connection',
+        retry: { disposition: 'auto', by: 'daemon' },
+        message: 'Connection error.',
+        since: ISO(NOW),
+        logPath: '/tmp/crtr-fault.log',
+    }, NOW);
+    assert.equal(plan.attempt, 1, 'the first plan primes attempt 1');
+    assert.equal(plan.max, 8, 'connection max attempts stay at 8');
+    assert.equal(plan.nextAt, ISO(NOW + 5_000), 'connection starts at 5s');
+    assert.equal(plan.fault.retry.attempt, 1, 'planned marker carries the primed attempt');
+    assert.equal(plan.fault.retry.disposition, 'auto', 'planned marker stays auto');
+});