@north-light/crouter 0.3.197 → 0.3.199

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

@@ -6,15 +6,15 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { Readable } from 'node:stream';
 import { createApiServer } from '../../daemon/api/server.js';
 import { cancelHumanTicket, deliverTerminalResult, resolvePageTicket } from '../../daemon/human/finish.js';
-import { humanAsk, humanNotify } from '../../commands/human/prompts.js';
+import { humanSend } from '../../commands/human/prompts.js';
 import { getNode, listNodes, closeDb } from '../canvas/index.js';
 import { readInboxSince } from '../feed/inbox.js';
 import { resolveRef } from '../canvas/history.js';
 import { apiSocketPath } from '../canvas/paths.js';
 import { spawnNode } from '../runtime/nodes.js';
+import { bindTicketReplyRoute } from '../human/convention.js';
 import { ticketDir } from '../human/root.js';
 import { readTicketResult, submitPage } from '../human/tickets.js';
 let home;
@@ -28,18 +28,6 @@ async function waitForSocket(path) {
     }
     throw new Error(`api socket never bound at ${path}`);
 }
-async function withPipedStdin(body, fn) {
-    const original = process.stdin;
-    const stdin = Readable.from([Buffer.from(body)]);
-    Object.defineProperty(stdin, 'isTTY', { value: false, configurable: true });
-    Object.defineProperty(process, 'stdin', { value: stdin, configurable: true });
-    try {
-        return await fn();
-    }
-    finally {
-        Object.defineProperty(process, 'stdin', { value: original, configurable: true });
-    }
-}
 async function withMutedStdout(fn) {
     const originalWrite = process.stdout.write;
     process.stdout.write = (() => true);
@@ -52,26 +40,17 @@ async function withMutedStdout(fn) {
 }
 function bridgeUnder() {
     const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
-    const bridge = spawnNode({ kind: 'human', parent, cwd: home, name: 'human-ask', lifecycle: 'terminal' }).node_id;
+    const bridge = spawnNode({ kind: 'human', parent, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
     return { parent, bridge };
 }
 function submitBridgePage(bridge) {
     const dir = ticketDir(bridge);
     const sourceDir = mkdtempSync(join(tmpdir(), 'crtr-deliver-page-'));
-    const sourceFile = join(sourceDir, 'page.md');
-    writeFileSync(sourceFile, [
-        '---',
-        'title: Ship it?',
-        'subtitle: Decide whether to ship now so the release can proceed.',
-        '---',
-        '',
-        '```slot:text',
-        '{ "id": "question", "initialText": "", "editable": true }',
-        '```',
-        '',
-    ].join('\n'));
+    const sourceFile = join(sourceDir, 'page.tsx');
+    writeFileSync(sourceFile, 'export default () => (\n  <Page title="Ship it?" subtitle="Decide whether to ship now so the release can proceed.">\n    <UserText id="question" initialText="" />\n  </Page>\n);\n');
     try {
-        submitPage({ dir, sourceFile, dialect: 'md' });
+        bindTicketReplyRoute(dir, bridge);
+        submitPage({ dir, sourceFile, delivery: { placement: 'inline', inbox: true, reply: true } });
     }
     finally {
         rmSync(sourceDir, { recursive: true, force: true });
@@ -110,41 +89,54 @@ after(() => {
     delete process.env['CRTR_NODE_ID'];
 });
 describe('enqueue is producer-only', () => {
-    test('ask requires and preserves an explicit title instead of deriving one from the body', async () => {
+    test('send preserves title and subtitle from the authored page', async () => {
         const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
         process.env['CRTR_NODE_ID'] = parent;
-        await assert.rejects(() => humanAsk.run({ question: 'This first line must never become the title.' }), /require a non-empty --title/);
-        const result = (await humanAsk.run({ title: 'Release decision', subtitle: 'Decide whether to release now so the launch can proceed.', question: 'This first line must never become the title.' }));
-        assert.equal(typeof result['job_id'], 'string');
+        const page = join(home, 'release-decision.tsx');
+        writeFileSync(page, 'export default () => (\n  <Page title="Release decision" subtitle="Decide whether to release now so the launch can proceed.">\n    <p>This first line stays page content.</p>\n    <UserText id="question" initialText="" />\n  </Page>\n);\n');
+        await assert.rejects(() => humanSend.run({}), /a page source is required/);
+        await assert.rejects(() => humanSend.run({ page, document: 'export default () => <Page title="Dup" />;' }), /received both --page and a piped page document/);
+        const result = (await humanSend.run({ page, document: '' }));
+        assert.equal(typeof result['page_id'], 'string');
+        assert.equal(result['reply'], true);
         assert.equal(typeof result['dir'], 'string');
         for (const forbidden of ['pane_id', 'render_pane_id', 'pid', 'worker_pid'])
-            assert.ok(!(forbidden in result), `ask result must not expose ${forbidden}`);
+            assert.ok(!(forbidden in result), `send result must not expose ${forbidden}`);
         const manifest = JSON.parse(readFileSync(join(result['dir'], 'page.json'), 'utf8'));
         assert.equal(manifest.title, 'Release decision');
         assert.equal(manifest.subtitle, 'Decide whether to release now so the launch can proceed.');
-        const document = readFileSync(join(result['dir'], 'page.md'), 'utf8');
-        assert.ok(document.includes('This first line must never become the title.'));
-        assert.equal(manifest.slots.filter((slot) => slot.kind === 'text').length, 1, 'the synthesized question page carries one response slot');
+        const document = readFileSync(join(result['dir'], 'page.tsx'), 'utf8');
+        assert.ok(document.includes('This first line stays page content.'));
+        assert.equal(manifest.slots.filter((slot) => slot.kind === 'text').length, 1);
+    });
+    test('send materializes a piped page before validation and publication', async () => {
+        const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
+        process.env['CRTR_NODE_ID'] = parent;
+        const document = 'export default () => (\n  <Page title="Piped question" subtitle="Answer the question to unblock this task.">\n    <UserText id="question" initialText="" />\n  </Page>\n);\n';
+        const result = (await humanSend.run({ document }));
+        const manifest = JSON.parse(readFileSync(join(result['dir'], 'page.json'), 'utf8'));
+        assert.equal(manifest.title, 'Piped question');
+        assert.equal(readFileSync(join(result['dir'], 'page.tsx'), 'utf8'), document);
     });
 });
 describe('terminal ticket delivery', () => {
     test('resolvePageTicket pushFinals the readable answer once and wakes the subscribed parent', async () => {
         const { parent, bridge } = bridgeUnder();
         const dir = submitBridgePage(bridge);
-        const result = await resolvePageTicket(bridge, { question: { text: 'yes, ship', edited: true, comments: [] } });
+        const result = await resolvePageTicket(bridge, { question: { text: 'yes, ship', edited: true } });
         assert.equal(result.kind, 'page');
         closeDb();
         assert.equal(getNode(bridge)?.status, 'done');
         const finals = readInboxSince(parent).filter((entry) => entry.from === bridge && entry.kind === 'final');
         assert.equal(finals.length, 1, 'exactly one pushFinal reached the parent');
         const body = reportBody(finals[0].ref);
-        assert.ok(body.includes('"text":"yes, ship"'), 'the slot answer is inlined in the report');
+        assert.ok(body.includes('“yes, ship”'), 'the readable slot answer is inlined in the report');
         assert.ok(body.includes(join(dir, 'response.json')));
     });
     test('a replay against a terminal bridge is a no-op', async () => {
         const { parent, bridge } = bridgeUnder();
         submitBridgePage(bridge);
-        await resolvePageTicket(bridge, { question: { text: 'yes', edited: true, comments: [] } });
+        await resolvePageTicket(bridge, { question: { text: 'yes', edited: true } });
         assert.equal(await deliverTerminalResult(bridge), true);
         closeDb();
         const finals = readInboxSince(parent).filter((entry) => entry.from === bridge && entry.kind === 'final');
@@ -152,7 +144,7 @@ describe('terminal ticket delivery', () => {
     });
     test('cancelHumanTicket finishes the bridge and notifies non-actor subscribers', async () => {
         const actor = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'actor' }).node_id;
-        const bridge = spawnNode({ kind: 'human', parent: actor, cwd: home, name: 'human-ask', lifecycle: 'terminal' }).node_id;
+        const bridge = spawnNode({ kind: 'human', parent: actor, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
         const other = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'other' }).node_id;
         const { subscribe } = await import('../canvas/canvas.js');
         subscribe(other, bridge, true);
@@ -162,15 +154,19 @@ describe('terminal ticket delivery', () => {
         assert.equal(getNode(bridge)?.status, 'done');
         assert.equal(readInboxSince(actor).length, 0, 'the canceling actor is not messaged');
         const notes = readInboxSince(other);
-        assert.equal(notes.length, 1, 'the other waiter gets one deferred note');
-        assert.equal(notes[0].tier, 'deferred');
+        assert.equal(notes.length, 1, 'the other waiter gets one waking note');
+        assert.equal(notes[0].tier, 'normal');
         assert.match(notes[0].label, /canceled/);
     });
 });
-test('notify enqueues a durable page and creates no canvas node', async () => {
+test('a display-only page publishes passively and creates no canvas node', async () => {
+    const page = join(home, 'build-done.tsx');
+    writeFileSync(page, 'export default () => (\n  <Page title="Build done" subtitle="The build passed, so the change is ready to review.">\n    <p>Build output is ready.</p>\n  </Page>\n);\n');
     const before = listNodes().length;
-    const result = (await humanNotify.run({ title: 'Build done', subtitle: 'The build passed, so the change is ready to review.' }));
-    assert.equal(result['queued'], true);
+    const result = (await humanSend.run({ page }));
+    assert.equal(result['reply'], false);
+    assert.equal(result['inbox'], false);
+    assert.equal(typeof result['page_id'], 'string');
     assert.equal(typeof result['dir'], 'string');
     assert.ok(existsSync(join(result['dir'], 'page.json')));
     assert.ok(readTicketResult(result['dir']) === null);

package/dist/core/__tests__/human-node-not-supervised.test.js

@@ -1,7 +1,7 @@
 // Run with: node --import tsx/esm --test src/core/__tests__/human-node-not-supervised.test.ts
 //
 // BUG REGRESSION (issue #2 — "Headless node can't reach human-ask: human-kind
-// TUI dies at boot"): a headless orchestrator's every `crtr human ask` node died
+// TUI dies at boot"): a headless orchestrator's every reply-bearing `crtr human send` bridge died
 // at boot with "pi vehicle exited before the session came up".
 //
 // ROOT CAUSE: a kind:'human' row is NOT a broker-hosted agent node — it is a

package/dist/core/__tests__/plugin-page-components.test.js

@@ -0,0 +1,157 @@
+// Run with: node --conditions=crtr-src --import tsx/esm --test src/core/__tests__/plugin-page-components.test.ts
+//
+// Wiring pins for plugin-contributed page components — the layer whose absence
+// is SILENT: every authoring, validation, daemon, inbox, and TUI consumer takes
+// the catalog as a parameter, so if `resolvePageComponents` stopped reading
+// installed plugins' manifest `page_components` blocks, every plugin-shipped
+// component would simply stop being authorable with all suites green.
+// Plus the archive path: `validatePluginBundle` must carry a valid bundle.json
+// `page_components` block into `ValidatedBundle.page_components` (what the
+// installer copies into the synthesized manifest) and reject an invalid one.
+import { test, before, beforeEach, afterEach, after } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, realpathSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import * as tar from 'tar';
+import { resetScopeCache } from '../scope.js';
+import { resolvePageComponents } from '../config.js';
+import { validatePluginBundle } from '../command-plugins/bundle.js';
+let isolatedHome;
+let isolatedCwd;
+let prevHome;
+let prevCwd;
+before(() => {
+    prevHome = process.env.HOME;
+    prevCwd = process.cwd();
+});
+beforeEach(() => {
+    isolatedHome = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-page-components-home-')));
+    isolatedCwd = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-page-components-cwd-')));
+    process.env.HOME = isolatedHome;
+    process.chdir(isolatedCwd);
+    resetScopeCache();
+});
+afterEach(() => {
+    process.chdir(prevCwd);
+    rmSync(isolatedHome, { recursive: true, force: true });
+    rmSync(isolatedCwd, { recursive: true, force: true });
+});
+after(() => {
+    process.chdir(prevCwd);
+    process.env.HOME = prevHome;
+    resetScopeCache();
+});
+/** Plant a manifest-only plugin (page components need no commands or executable). */
+function plantPlugin(scopeRootPath, name, pageComponents) {
+    const root = join(scopeRootPath, 'plugins', name, '.crouter-plugin');
+    mkdirSync(root, { recursive: true });
+    writeFileSync(join(root, 'plugin.json'), JSON.stringify({ name, version: '0.1.0', page_components: pageComponents }));
+}
+function userRoot() {
+    const root = join(isolatedHome, '.crouter');
+    mkdirSync(root, { recursive: true });
+    return root;
+}
+test('an enabled user-scope plugin contributes its page components; a disabled one contributes nothing', () => {
+    const root = userRoot();
+    plantPlugin(root, 'northlight', [
+        { kind: 'connector', description: 'Connector decision', useWhen: 'Use for a connector decision.', doc: 'Product contract.' },
+        { kind: 'applet-card', display: true },
+    ]);
+    plantPlugin(root, 'zzz-disabled', ['ghost']);
+    writeFileSync(join(root, 'config.json'), JSON.stringify({ plugins: { 'zzz-disabled': { enabled: false } } }));
+    const components = resolvePageComponents();
+    assert.deepEqual(components, [
+        { kind: 'connector', description: 'Connector decision', useWhen: 'Use for a connector decision.', doc: 'Product contract.' },
+        { kind: 'applet-card', display: true },
+    ]);
+});
+test('user config entries and plugin contributions resolve together, and a colliding kind is rejected', () => {
+    const root = userRoot();
+    plantPlugin(root, 'northlight', ['connector']);
+    writeFileSync(join(root, 'config.json'), JSON.stringify({ page_components: ['approval'] }));
+    assert.deepEqual(resolvePageComponents().map((component) => component.kind), ['approval', 'connector']);
+    writeFileSync(join(root, 'config.json'), JSON.stringify({ page_components: ['connector'] }));
+    assert.throws(() => resolvePageComponents(), /page component kind "connector" is registered by both config.json and plugin "northlight"/);
+});
+test('two plugins whose kinds derive one JSX tag are rejected, naming both sources', () => {
+    const root = userRoot();
+    plantPlugin(root, 'alpha', ['foo-bar']);
+    plantPlugin(root, 'beta', ['foo--bar']);
+    assert.throws(() => resolvePageComponents(), /kind "foo--bar" \(plugin "beta"\) derives JSX tag "FooBar", which duplicates kind "foo-bar" from plugin "alpha"/);
+});
+// --- archive path -----------------------------------------------------------
+function minimalCommandsJson() {
+    return {
+        schemaVersion: 1,
+        mounts: [
+            {
+                parent: [],
+                node: {
+                    kind: 'branch',
+                    name: 'app',
+                    description: 'application lifecycle and inspection',
+                    whenToUse: 'you need to inspect an application',
+                    rootEntry: {
+                        concept: 'applications hosted by a crouter home',
+                        description: 'application lifecycle and inspection',
+                        whenToUse: 'you need to inspect an application',
+                    },
+                    summary: 'application lifecycle and inspection',
+                    model: 'Applications are product resources owned by the selected home.',
+                    children: [
+                        {
+                            kind: 'leaf',
+                            name: 'show',
+                            description: 'show one application',
+                            whenToUse: 'inspect a single application by id',
+                            tier: 'important',
+                            summary: 'show one application details',
+                            params: [{ kind: 'positional', name: 'app-id', required: true, constraint: 'the application id' }],
+                            output: [{ name: 'app_id', type: 'string', required: true, constraint: 'the echoed application id' }],
+                            effects: ['None. Read-only.'],
+                            rest: { method: 'GET', path: '/v1/apps/{app-id}', params: { 'app-id': { in: 'path' } } },
+                        },
+                    ],
+                },
+            },
+        ],
+    };
+}
+function makeArchive(bundleJson) {
+    const dir = mkdtempSync(join(tmpdir(), 'crtr-page-components-tar-'));
+    try {
+        writeFileSync(join(dir, 'bundle.json'), JSON.stringify(bundleJson));
+        writeFileSync(join(dir, 'commands.json'), JSON.stringify(minimalCommandsJson()));
+        const pack = tar.create({ sync: true, cwd: dir, portable: true }, ['bundle.json', 'commands.json']);
+        const chunks = [];
+        let chunk;
+        while ((chunk = pack.read()) !== null)
+            chunks.push(chunk);
+        return new Uint8Array(Buffer.concat(chunks));
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+test('validatePluginBundle carries a valid bundle.json page_components block into ValidatedBundle', async () => {
+    const archive = makeArchive({
+        bundleVersion: 1,
+        page_components: ['connector', { kind: 'applet-card', description: 'Applet card', display: true }],
+    });
+    const validated = await validatePluginBundle(archive, { reservedCoreNames: new Set(['node']) });
+    assert.deepEqual(validated.issues, []);
+    assert.deepEqual(validated.bundle?.page_components, [
+        { kind: 'connector' },
+        { kind: 'applet-card', description: 'Applet card', display: true },
+    ]);
+});
+test('validatePluginBundle rejects an invalid page_components block loudly', async () => {
+    const archive = makeArchive({ bundleVersion: 1, page_components: [{ kind: 'connector', use_when: 'typo field' }] });
+    const validated = await validatePluginBundle(archive, { reservedCoreNames: new Set(['node']) });
+    assert.equal(validated.bundle, undefined);
+    assert.equal(validated.issues.length, 1);
+    assert.match(validated.issues[0].message, /page_components block is invalid/);
+    assert.match(validated.issues[0].received, /use_when/);
+});

package/dist/core/__tests__/seam/broker-crash-teardown.test.js

@@ -2,9 +2,10 @@
 //
 // Daemon-epoch broker ownership, real-process crash and teardown. The broker's
 // exit event is the sole death authority: a SIGTERM of a streaming broker
-// aborts cleanly and resumes the saved session with a continuation (policy row
-// 5); a SIGKILL mid-turn leaves no certificate and starts a fresh cycle (row
-// 6). Each replacement starts only after the
+// aborts cleanly and resumes the saved session with a continuation, and a
+// SIGKILL mid-turn — no certificate, only the durable busy marker — resumes
+// that same saved session in place and re-drives the stopped turn with the
+// same continuation (both policy row 5). Each replacement starts only after the
 // prior process has exited, preserving one writer per session. A clean `node
 // lifecycle close` then tears the replacement down (shutdown frame → exit,
 // socket unlinked, status canceled, daemon leaves it).
@@ -77,7 +78,7 @@ test('SIGTERM of a busy broker aborts cleanly and resumes with a continuation',
     assert.notEqual(revivedPid, oldPid, 'the revived pid is distinct from the crashed one');
     assert.equal(isPidAlive(oldPid), false, 'one-writer: the crashed pid never resurrected');
 });
-test('SIGKILL of a busy broker stays a dirty recovery cycle; close tears down the replacement', { timeout: 30_000 }, async () => {
+test('SIGKILL of a busy broker resumes the interrupted turn in place; close tears down the replacement', { timeout: 30_000 }, async () => {
     const id = await h.spawnHeadlessChild(root, 'headless worker — dirty crash+teardown');
     const boot1 = await h.awaitBoot(id);
     const boots = h.bootCount(id);
@@ -85,9 +86,10 @@ test('SIGKILL of a busy broker stays a dirty recovery cycle; close tears down th
     assert.equal(busyPid, boot1.pid, 'canvas pid identifies the broker that owns the dirty-crash session');
     assert.equal(isPidAlive(busyPid), true, 'busy broker is alive before SIGKILL');
     // This broker has only the durable busy marker — SIGKILL cannot run the abort
-    // handler or write clean-abort evidence. Strict resume would only reopen the
-    // transcript at an idle prompt; policy must select resume:false and inject the
-    // normal fresh-cycle kickoff after this journey's first 5s backoff.
+    // handler or write clean-abort evidence. The saved transcript is still
+    // resumable (pi persists whole entries), so policy resumes it strictly and
+    // the respawn continuation re-drives the stopped turn, after this journey's
+    // first 5s backoff. A dirty death is not a reason to throw the branch away.
     markBusy(id);
     process.kill(busyPid, 'SIGKILL');
     await h.waitFor(() => !isPidAlive(busyPid), { label: 'mid-turn crashed broker pid is dead' });
@@ -96,11 +98,11 @@ test('SIGKILL of a busy broker stays a dirty recovery cycle; close tears down th
     // path, including a cycle; production distinguishes cycling with the argv
     // token and non-null kickoff. Assert those load-bearing inputs directly.
     const recoveryArgv = boot2.rawArgv;
-    assert.ok(recoveryArgv.includes('--crtr-new-cycle'), 'a surviving busy marker selects --crtr-new-cycle');
-    assert.match(boot2.prompt ?? '', /You have been revived fresh after a context refresh/, 'the recovery cycle receives a real roadmap\/feed\/context kickoff');
+    assert.ok(!recoveryArgv.includes('--crtr-new-cycle'), 'a surviving busy marker resumes the saved session — it never opens a fresh cycle');
+    assert.equal(boot2.prompt, RUNTIME_RESTART_CONTINUATION, 'the strict resume injects the runtime-restart continuation that re-drives the interrupted turn');
     const recoveryPid = h.node(id).pi_pid;
-    assert.ok(recoveryPid != null && isPidAlive(recoveryPid), 'the recovery-cycle broker pid is alive');
-    assert.notEqual(recoveryPid, busyPid, 'the recovery cycle uses a distinct broker pid');
+    assert.ok(recoveryPid != null && isPidAlive(recoveryPid), 'the recovered broker pid is alive');
+    assert.notEqual(recoveryPid, busyPid, 'the recovery uses a distinct broker pid');
     assert.equal(isPidAlive(busyPid), false, 'one-writer: the interrupted pid never resurrected');
     // --- Item 5: clean teardown of the (revived, live) broker. node lifecycle close marks
     //     canceled BEFORE teardown (crash-safe order), then hostFor(broker).teardown

package/dist/core/__tests__/seam/dormancy-release.test.js

@@ -7,16 +7,22 @@
 //      before the broker exits, and the daemon may only revive for a row strictly
 //      after the committed cursor.
 //  (2) The observed 57-broker / ~5.4GB leak — DAEMON SUPERVISION, not an agent
-//      event, owns the unattended clock. A resident with no live obligation
-//      completes into prunable history; one awaiting a child remains wakeable.
-//      Both release their broker and fleet slot.
+//      event, owns the unattended clock. A node with no live obligation is
+//      terminalized into prunable history (a resident completed its
+//      conversation; a terminal node parked without a final was torn down
+//      before finishing); one awaiting a child remains wakeable; an unclaimed
+//      warm-pool spare is exempt, because the booted broker it holds is its
+//      entire purpose. All of them release their broker and fleet slot except
+//      the spare, which keeps both.
 //
 // Both drive a real broker process through the real watcher/supervision paths, so
 // they belong to the compiled seam tier; neither needs tmux.
 import { after, before, test } from 'node:test';
 import assert from 'node:assert/strict';
+import { writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { appendInbox, readCursor, readInboxSince } from '../../feed/inbox.js';
-import { subscribe, updateNode } from '../../canvas/index.js';
+import { registerWarmSpare, subscribe, updateNode } from '../../canvas/index.js';
 import { isPidAlive } from '../../canvas/pid.js';
 import { reviveNode } from '../../runtime/revive.js';
 import { createHarness } from '../helpers/harness.js';
@@ -172,6 +178,99 @@ test('an unattended resident with no live obligation completes on the daemon clo
             process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
     }
 });
+test('a connected broker viewer keeps an obligation-free resident live', { timeout: 30_000 }, async () => {
+    const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
+    process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';
+    const nodeId = h.fabricateBrokerNode({
+        id: 'settled-with-viewer',
+        parent: root,
+        lifecycle: 'resident',
+        status: 'idle',
+        intent: 'idle-release',
+    });
+    updateNode(nodeId, {
+        launch: {
+            extensions: [],
+            tools: [],
+            systemPrompt: '',
+            env: {},
+        },
+    });
+    reviveNode(nodeId, { resume: true });
+    const boot = await h.awaitBoot(nodeId);
+    // This is the presence written by a helloed direct attach, which has no
+    // focuses-table row because it did not pass through the focus opener.
+    writeFileSync(join(h.home, 'nodes', nodeId, 'job', 'attach.json'), JSON.stringify({ viewers: 1 }));
+    try {
+        const seenAt = 15_000;
+        await h.tick(seenAt);
+        await h.tick(seenAt + 1500);
+        assert.equal(h.fleet.has(nodeId), true, 'an attached viewer keeps the broker fleet-owned');
+        assert.equal(isPidAlive(boot.pid), true, 'an attached viewer keeps the broker process alive');
+        assert.ok(['active', 'idle'].includes(h.node(nodeId)?.status ?? ''), 'an attached viewer keeps the node live');
+    }
+    finally {
+        if (priorParkMs === undefined)
+            delete process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
+        else
+            process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
+    }
+});
+test('an already idle terminal node with no live obligation reconciles into canceled', async () => {
+    const nodeId = h.fabricateBrokerNode({
+        id: 'idle-terminal-without-obligation',
+        parent: root,
+        status: 'idle',
+        intent: 'idle-release',
+        pi_session_id: 'parked-terminal-session',
+    });
+    await h.tick();
+    assert.equal(h.node(nodeId)?.status, 'canceled', 'a terminal row that never pushed a final settles as torn down, not completed');
+});
+test('the unattended park clock cancels an obligation-free terminal node and spares the warm pool', { timeout: 40_000 }, async () => {
+    const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
+    process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';
+    try {
+        const boot = async (id) => {
+            updateNode(id, { launch: { extensions: [], tools: [], systemPrompt: '', env: {} } });
+            reviveNode(id, { resume: true });
+            return (await h.awaitBoot(id)).pid;
+        };
+        const settled = h.fabricateBrokerNode({ id: 'terminal-no-work', parent: root, status: 'idle', intent: 'idle-release' });
+        const awaiting = h.fabricateBrokerNode({ id: 'terminal-awaiting-child', parent: root, status: 'idle', intent: 'idle-release' });
+        const child = h.fabricateBrokerNode({ parent: awaiting, status: 'idle', intent: 'idle-release' });
+        subscribe(awaiting, child, true);
+        // Production spares mint as unparented residents, so this is the row shape
+        // the park clock actually meets in the fleet.
+        const spare = h.fabricateBrokerNode({ id: 'unclaimed-warm-spare', lifecycle: 'resident', status: 'idle', intent: 'idle-release' });
+        registerWarmSpare(spare, 'test-recipe-key');
+        const settledPid = await boot(settled);
+        const awaitingPid = await boot(awaiting);
+        const sparePid = await boot(spare);
+        const seenAt = 30_000;
+        await h.tick(seenAt);
+        await h.tick(seenAt + 1500);
+        await h.waitFor(() => h.node(settled)?.status === 'canceled' && !isPidAlive(settledPid), {
+            timeoutMs: 10_000,
+            intervalMs: 20,
+            label: 'unattended terminal cancellation and broker exit',
+        });
+        await h.awaitFleetExit(settled);
+        assert.equal(h.node(settled)?.status, 'canceled', 'a terminal node torn down without a final is prunable canceled history');
+        await h.waitFor(() => !isPidAlive(awaitingPid), { timeoutMs: 10_000, intervalMs: 20, label: 'awaiting terminal release' });
+        await h.awaitFleetExit(awaiting);
+        assert.equal(h.node(awaiting)?.status, 'idle', 'a live child keeps a terminal node eligible for an automatic wake');
+        assert.equal(h.fleet.has(spare), true, 'the park clock never reaps an unclaimed spare out from under the pool');
+        assert.equal(isPidAlive(sparePid), true, 'the spare keeps the booted broker that is its whole value');
+        assert.ok(['active', 'idle'].includes(h.node(spare)?.status ?? ''), 'the spare row stays claimable, left for reapStaleSpares to own');
+    }
+    finally {
+        if (priorParkMs === undefined)
+            delete process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
+        else
+            process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
+    }
+});
 test('an unattended resident awaiting a live child remains wakeable', { timeout: 30_000 }, async () => {
     const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
     process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';

package/dist/core/__tests__/serial/flagship-lifecycle.test.js

@@ -150,7 +150,7 @@ test('flagship: full node lifecycle — spawn, dormancy, one-hop wake, promote,
         //      ('natural stop while awaiting a live worker → idle-release …').
         // ===================================================================
         {
-            const stop = evaluateStop(B, { pushedFinal: false, askedHuman: false });
+            const stop = evaluateStop(B, { pushedFinal: false, requestedHumanReply: false });
             assert.equal(stop.action, 'allow', 'awaiting terminal B → allow (legit idle-release)');
             assert.equal(stop.reason, 'awaiting', "B classified awaiting on its ACTIVE live sub to C");
         }
@@ -225,7 +225,7 @@ test('flagship: full node lifecycle — spawn, dormancy, one-hop wake, promote,
             assert.deepEqual(drift?.from, { mode: 'base', lifecycle: 'terminal' }, 'drift.from = the acked base×terminal');
             assert.deepEqual(drift?.to, { mode: 'orchestrator', lifecycle: 'terminal' }, 'drift.to = the new orchestrator persona');
             assert.match(drift?.guidance ?? '', /ORCHESTRATOR/i, 'the steer carries the base→orchestrator guidance');
-            const stop = evaluateStop(B, { pushedFinal: false, askedHuman: false });
+            const stop = evaluateStop(B, { pushedFinal: false, requestedHumanReply: false });
             assert.equal(stop.action, 'reprompt', 'orchestrator B with no live sub, no final → reprompt');
             assert.equal(stop.reason, 'stalled', 'classified stalled');
             assert.equal(stop.action === 'reprompt' ? stop.message : '', STALL_REPROMPT, 'the stall reprompt nudge');

package/dist/core/__tests__/serial/human-deliver-e2e.test.js

@@ -11,6 +11,7 @@ import { ApiError, CrtrClient } from '../../../api/index.js';
 import { createApiServer } from '../../../daemon/api/server.js';
 import { apiSocketPath } from '../../canvas/paths.js';
 import { claimTicket, readTicketClaim } from '../../human/claim.js';
+import { bindTicketReplyRoute } from '../../human/convention.js';
 import { ticketDir } from '../../human/root.js';
 import { submitPage, submitReview } from '../../human/tickets.js';
 import { spawnNode } from '../../runtime/nodes.js';
@@ -66,20 +67,14 @@ async function expectReviewSubmitGuidance(nodeId, body) {
 function submitBridgePage(bridge) {
     const dir = ticketDir(bridge);
     const sourceDir = mkdtempSync(join(tmpdir(), 'crtr-e2e-page-'));
-    const sourceFile = join(sourceDir, 'page.md');
-    writeFileSync(sourceFile, [
-        '---',
-        'title: Ship it?',
-        'subtitle: Decide whether to ship now so the release can proceed.',
-        '---',
-        '',
-        '```slot:text',
-        '{ "id": "question", "initialText": "", "editable": true }',
-        '```',
-        '',
-    ].join('\n'));
+    const sourceFile = join(sourceDir, 'page.tsx');
+    writeFileSync(sourceFile, 'export default () => (\n  <Page title="Ship it?" subtitle="Decide whether to ship now so the release can proceed.">\n    <UserText id="question" initialText="" />\n  </Page>\n);\n');
     try {
-        submitPage({ dir, sourceFile, dialect: 'md' });
+        bindTicketReplyRoute(dir, bridge);
+        // The delivery `human send` derives for a terminal bridge page: a
+        // response-bearing slot gives it a reply route, and a terminal sender's page
+        // always projects to the inbox.
+        submitPage({ dir, sourceFile, delivery: { placement: 'inline', inbox: true, reply: true } });
     }
     finally {
         rmSync(sourceDir, { recursive: true, force: true });
@@ -110,6 +105,7 @@ test('malformed resolves leave the mounted ticket claim in place', async () => {
     const reviewDir = ticketDir(reviewBridge);
     const file = join(home, 'review.md');
     writeFileSync(file, '# Review\n');
+    bindTicketReplyRoute(reviewDir, reviewBridge);
     submitReview({ dir: reviewDir, review: { title: 'Review', subtitle: 'Review this file so implementation can proceed safely.', source: {}, file } });
     const reviewClaim = claimTicket(reviewDir);
     assert.ok(reviewClaim !== null);
@@ -118,10 +114,10 @@ test('malformed resolves leave the mounted ticket claim in place', async () => {
 });
 test('the ticket resolve route pushFinals the readable answer to the parent', async () => {
     const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
-    const bridge = spawnNode({ kind: 'human', parent, cwd: home, name: 'human-ask', lifecycle: 'terminal' }).node_id;
+    const bridge = spawnNode({ kind: 'human', parent, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
     const dir = submitBridgePage(bridge);
-    const result = await client.resolveHumanTicket(bridge, { responses: { question: { text: 'yes, ship', edited: true, comments: [] } } });
-    assert.deepEqual(result, { delivered: true, kind: 'page' });
+    const result = await client.resolveHumanTicket(bridge, { responses: { question: { text: 'yes, ship', edited: true } } });
+    assert.deepEqual(result, { completed: true, reply_delivered: true, kind: 'page' });
     assert.equal(getNode(bridge)?.status, 'done', 'bridge finalized by crtrd');
     const finals = readInboxSince(parent).filter((entry) => entry.from === bridge && entry.kind === 'final');
     assert.equal(finals.length, 1, 'exactly one pushFinal reached the parent');

package/dist/core/__tests__/serial/live-mutation.test.js

@@ -48,7 +48,7 @@ import { evaluateStop } from '../../runtime/stop-guard.js';
 function persona(m) {
     return { mode: m.mode, lifecycle: m.lifecycle };
 }
-const SIGNALS = { pushedFinal: false, askedHuman: false };
+const SIGNALS = { pushedFinal: false, requestedHumanReply: false };
 // ===========================================================================
 // (a) LIFECYCLE FLIP — `crtr node config --lifecycle` on a LIVE node, both directions,
 //     observing the idle-release DECISION change. A round-trip on ONE node

package/dist/core/__tests__/serial/tmux-surface.test.js

@@ -186,7 +186,7 @@ test('tmux installer remaps owned pairs and preserves occupied user bindings', (
         const defaultMenu = tmuxBinding(socket, 'root', 'M-c') ?? '';
         assert.match(defaultMenu, /display-menu/);
         // The inbox toggle installs at its default key (alt+i → M-i) in the same sweep.
-        assert.match(tmuxBinding(socket, 'root', 'M-i') ?? '', /crtr human inbox toggle/);
+        assert.match(tmuxBinding(socket, 'root', 'M-i') ?? '', /crtr surface inbox/);
         const remapped = installTmuxBindings(resolveKeybindings({
             'crtr.tmux.menu.open': ['alt+shift+z'],
             'crtr.tmux.menu.graph': ['shift+z'],
@@ -242,11 +242,13 @@ test('tmux installer reads pair-array manifests and replaces owned pairs', (t) =
     try {
         // Current-scope releases wrote the pair array before wrappers were added.
         isolatedTmux(socket, ['set-option', '-s', '@crtr_keybindings_manifest', JSON.stringify([{ table: 'root', key: 'M-i' }])]);
+        // Seeded with the pre-move command path, so the assertion below distinguishes a
+        // genuine replacement from a no-op.
         isolatedTmux(socket, ['bind-key', '-T', 'root', 'M-i', 'run-shell', '-b', 'crtr human inbox toggle --quiet']);
         const result = installTmuxBindings(resolveKeybindings());
         assert.equal(result.ok, true, JSON.stringify(result.diagnostics));
         assert.ok(!result.diagnostics.some((d) => d.bindingId === 'crtr.tmux.inbox.toggle'), JSON.stringify(result.diagnostics));
-        assert.match(tmuxBinding(socket, 'root', 'M-i') ?? '', /crtr human inbox toggle/);
+        assert.match(tmuxBinding(socket, 'root', 'M-i') ?? '', /crtr surface inbox/);
         assert.match(tmuxBinding(socket, 'root', 'M-c') ?? '', /background running bash/);
     }
     finally {