@north-light/crouter 0.3.310 → 0.3.312

package/dist/commands/__tests__/integration/dashboard-snapshot.test.d.ts

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

package/dist/commands/__tests__/integration/dashboard-snapshot.test.js

@@ -0,0 +1,212 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { createNode, subscribe } from '../../../core/canvas/canvas.js';
+import { closeDb } from '../../../core/canvas/db.js';
+import { apiSocketPath } from '../../../core/canvas/paths.js';
+import { Router } from '../../../daemon/api/router.js';
+import { createApiServer } from '../../../daemon/api/server.js';
+function node(id, parent) {
+    return {
+        node_id: id,
+        name: `${id}-handle`,
+        description: `${id} task`,
+        created: new Date().toISOString(),
+        cwd: '/tmp/dashboard-test',
+        kind: 'developer',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+        parent,
+    };
+}
+function runCanvas(home, command, extraEnv = {}) {
+    return new Promise((resolve, reject) => {
+        const args = ['--conditions=crtr-src', '--import', 'tsx/esm', 'src/cli.ts', '--json', ...command];
+        const child = spawn(process.execPath, args, {
+            cwd: process.cwd(),
+            env: {
+                ...process.env,
+                ...extraEnv,
+                CRTR_HOME: home,
+                CRTR_NO_DAEMON_AUTOSTART: '1',
+                CRTR_NO_AUTO_INIT: '1',
+                CRTR_NO_AUTO_UPDATE: '1',
+                CRTR_NO_EXPORTS: '1',
+            },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => { stdout += chunk; });
+        child.stderr.on('data', (chunk) => { stderr += chunk; });
+        child.on('error', reject);
+        child.on('close', (code) => resolve({ code, stdout, stderr }));
+    });
+}
+function runDashboard(home, root, extraEnv) {
+    return runCanvas(home, ['canvas', 'dashboard', ...(root === undefined ? [] : ['--root', root])], extraEnv);
+}
+/** The capability this file exists for: a dashboard render issues a fixed
+ *  number of requests whatever the graph's size, and never reads one node at
+ *  a time. Which order those requests go out in is an implementation detail —
+ *  the scoped and full renders already differ there. */
+function assertSnapshotReads(requests, label) {
+    assert.equal(requests.length, 3, `${label} issued ${requests.length} requests: ${requests.join(' ')}`);
+    assert.ok(!requests.some((url) => /^\/v1\/nodes\/./.test(url)), `${label} made a per-node read: ${requests.join(' ')}`);
+}
+function startMockRemoteCanvas(route) {
+    return new Promise((resolve) => {
+        const requests = [];
+        const server = createServer((req, res) => {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => {
+                const { args } = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                requests.push(args);
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ ok: true, exitCode: 0, stdout: JSON.stringify(route(args)), stderr: '' }));
+            });
+        });
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address !== null ? address.port : 0;
+            resolve({
+                url: `http://127.0.0.1:${port}`,
+                requests,
+                close: () => new Promise((done) => server.close(() => done())),
+            });
+        });
+    });
+}
+test('canvas dashboard renders scoped and full cycles from one node snapshot without per-node API reads', async (t) => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-dashboard-'));
+    const home = join(root, 'canvas');
+    mkdirSync(home, { recursive: true });
+    const previousHome = process.env['CRTR_HOME'];
+    const originalHandle = Router.prototype.handle;
+    const requests = [];
+    try {
+        process.env['CRTR_HOME'] = home;
+        closeDb();
+        createNode(node('root', null));
+        createNode(node('left', 'root'));
+        createNode(node('right', 'root'));
+        createNode(node('shared', 'left'));
+        subscribe('root', 'left');
+        subscribe('root', 'right');
+        subscribe('left', 'shared');
+        subscribe('right', 'shared');
+        subscribe('shared', 'left');
+        Router.prototype.handle = async function (req, res) {
+            requests.push(req.url ?? '');
+            await originalHandle.call(this, req, res);
+        };
+        const server = createApiServer();
+        await server.ready;
+        assert.ok(existsSync(apiSocketPath()), 'the isolated API socket is bound before the CLI starts');
+        t.after(async () => {
+            Router.prototype.handle = originalHandle;
+            await server.close();
+        });
+        for (let i = 0; i < 32; i++) {
+            const id = `worker-${i}`;
+            createNode(node(id, i === 0 ? 'shared' : `worker-${i - 1}`));
+            subscribe(i === 0 ? 'shared' : `worker-${i - 1}`, id);
+        }
+        requests.length = 0;
+        const large = await runDashboard(home, 'root');
+        assert.equal(large.code, 0, large.stderr);
+        const largeOutput = JSON.parse(large.stdout);
+        assert.equal(largeOutput.nodes, 36);
+        assert.equal(largeOutput.rows.length, 36);
+        assert.equal(new Set(largeOutput.rows.map((row) => row.node_id)).size, 36, 'shared descendants remain one row each');
+        assert.ok(largeOutput.rows.every((row) => row.ctx_tokens === 0 && row.asks === 0), 'the emitted row fields remain populated from the snapshot');
+        assert.match(largeOutput.tree, /worker-31-handle worker-31 task \[developer\/base\] ctx 0k/);
+        assertSnapshotReads(requests, 'the scoped dashboard');
+        requests.length = 0;
+        const full = await runDashboard(home);
+        assert.equal(full.code, 0, full.stderr);
+        const fullOutput = JSON.parse(full.stdout);
+        assert.equal(fullOutput.nodes, 36);
+        assert.equal(fullOutput.rows.length, 36);
+        assert.match(fullOutput.tree, /root-handle root task \[developer\/base\] ctx 0k/);
+        assert.match(fullOutput.tree, /↺ <cycle: left>/);
+        assert.match(fullOutput.tree, /↺ <cycle: shared>/);
+        assertSnapshotReads(requests, 'the full dashboard');
+        Router.prototype.handle = async function (req, res) {
+            requests.push(req.url ?? '');
+            if (req.url === '/v1/canvas/attention/counts') {
+                res.writeHead(503, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({ error: 'unavailable' }));
+                return;
+            }
+            await originalHandle.call(this, req, res);
+        };
+        requests.length = 0;
+        const degradedDashboard = await runDashboard(home);
+        assert.equal(degradedDashboard.code, 0, degradedDashboard.stderr);
+        const degradedOutput = JSON.parse(degradedDashboard.stdout);
+        assert.ok(degradedOutput.rows.every((row) => row.asks === 0), 'unavailable ticket counts render as default badges');
+        assert.match(degradedOutput.tree, /worker-31-handle worker-31 task/, 'the dashboard keeps its topology when ticket counts fail');
+        const roster = await runCanvas(home, ['canvas', 'roster']);
+        assert.equal(roster.code, 0, roster.stderr);
+        const rosterOutput = JSON.parse(roster.stdout);
+        assert.ok(rosterOutput.edges.some((edge) => edge.from_id === 'root' && edge.to_id === 'left'), 'the roster retains authoritative edges when ticket counts fail');
+        assert.deepEqual(rosterOutput.subscriptions['root'], ['left', 'right']);
+    }
+    finally {
+        Router.prototype.handle = originalHandle;
+        closeDb();
+        if (previousHome === undefined)
+            delete process.env['CRTR_HOME'];
+        else
+            process.env['CRTR_HOME'] = previousHome;
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+test('canvas dashboard reads full-forest ticket counts from the selected remote canvas', async (t) => {
+    const root = mkdtempSync(join(tmpdir(), 'crtr-dashboard-remote-'));
+    const home = join(root, 'canvas');
+    const userHome = join(root, 'user');
+    const remote = await startMockRemoteCanvas((args) => {
+        if (args[1] === 'node' && args[2] === 'inspect' && args[3] === 'list') {
+            return { nodes: [node('root', null), node('child', 'root')] };
+        }
+        if (args[1] === 'canvas' && args[2] === 'attention') {
+            return { counts: { root: 2, child: 3 } };
+        }
+        if (args[1] === 'canvas' && args[2] === 'roster') {
+            return { edges: [{ from_id: 'root', to_id: 'child', active: true, created: '' }] };
+        }
+        throw new Error(`unexpected remote command: ${args.join(' ')}`);
+    });
+    t.after(() => remote.close());
+    try {
+        mkdirSync(join(userHome, '.crouter'), { recursive: true });
+        writeFileSync(join(userHome, '.crouter', 'config.json'), JSON.stringify({
+            remoteCanvas: { targets: { remote: { previewEndpoint: remote.url, relayTokenRef: 'remote' } } },
+        }));
+        writeFileSync(join(userHome, '.crouter', 'state.json'), JSON.stringify({ activeCanvas: 'remote' }));
+        writeFileSync(join(userHome, '.crouter', 'secrets.json'), JSON.stringify({ relayTokens: { remote: 'test-token' } }));
+        const result = await runDashboard(home, undefined, { HOME: userHome });
+        assert.equal(result.code, 0, result.stderr);
+        const output = JSON.parse(result.stdout);
+        assert.deepEqual(output.rows.map((row) => ({ node_id: row.node_id, asks: row.asks })), [
+            { node_id: 'root', asks: 2 },
+            { node_id: 'child', asks: 3 },
+        ]);
+        assert.match(output.tree, /⚑2/);
+        assert.match(output.tree, /⚑3/);
+        // The mock route throws on any command it does not recognise, so this only
+        // has to pin that topology comes from one roster call rather than one per edge.
+        assert.equal(remote.requests.length, 3, `remote issued ${remote.requests.length} commands: ${remote.requests.map((args) => args.join(' ')).join(' | ')}`);
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/dist/commands/api-client.d.ts

@@ -76,6 +76,7 @@ export declare class ApiCanvasSource implements CanvasSource {
      * be per-node. Request only this view's ids: using the
      * enriched full-canvas snapshot for a five-second viewer poll blocked crtrd
      * behind metadata and telemetry reads for every historical node. */
+    ticketCountsForNodes(nodeIds: readonly string[]): Promise<Record<string, number>>;
     ticketCountsForView(root: string): Promise<Record<string, number>>;
     /** True when `nodeId` has at least one active (`active` edge flag, not just a
      *  live subscriber) subscription to a node that is currently live

package/dist/commands/api-client.js

@@ -247,9 +247,11 @@ export class ApiCanvasSource {
      * be per-node. Request only this view's ids: using the
      * enriched full-canvas snapshot for a five-second viewer poll blocked crtrd
      * behind metadata and telemetry reads for every historical node. */
+    async ticketCountsForNodes(nodeIds) {
+        return (await this.client.attentionCounts([...nodeIds])).counts;
+    }
     async ticketCountsForView(root) {
-        const ids = [root, ...await this.view(root)];
-        return (await this.client.attentionCounts(ids)).counts;
+        return this.ticketCountsForNodes([root, ...await this.view(root)]);
     }
     /** True when `nodeId` has at least one active (`active` edge flag, not just a
      *  live subscriber) subscription to a node that is currently live

package/dist/commands/canvas-roster.js

@@ -23,6 +23,12 @@ export const canvasRosterLeaf = defineLeaf({
                 required: true,
                 constraint: 'Authoritative subscribes_to adjacency map: each node id maps to its publisher/child node ids in edge order.',
             },
+            {
+                name: 'edges',
+                type: 'object[]',
+                required: true,
+                constraint: 'Subscription edges with from_id, to_id, active, and created fields.',
+            },
         ],
         outputKind: 'object',
         effects: [
@@ -38,25 +44,26 @@ export const canvasRosterLeaf = defineLeaf({
         // (`GET /v1/canvas/roster`). Attention counts stay a SEPARATE bounded read
         // (`POST /v1/canvas/attention/counts`) — never folded into the roster query
         // itself, which must stay indexed-scan-only.
+        const dto = await cliClient().canvasRoster().catch((err) => rethrowAsCliError(err));
+        const ids = dto.nodes.map((n) => n.node_id);
+        let counts = {};
         try {
-            const dto = await cliClient().canvasRoster();
-            const ids = dto.nodes.map((n) => n.node_id);
-            const counts = ids.length > 0 ? (await cliClient().attentionCounts(ids)).counts : {};
-            const nodes = dto.nodes.map((n) => ({ ...n, attention_count: counts[n.node_id] ?? 0 }));
-            const subscriptions = {};
-            for (const n of dto.nodes)
-                subscriptions[n.node_id] = [];
-            for (const e of dto.edges) {
-                const list = subscriptions[e.from_id];
-                if (list !== undefined)
-                    list.push(e.to_id);
-                else
-                    subscriptions[e.from_id] = [e.to_id];
-            }
-            return { generated_at: dto.generated_at, nodes, subscriptions };
+            counts = ids.length > 0 ? (await cliClient().attentionCounts(ids)).counts : {};
+        }
+        catch {
+            // Ticket counts decorate the authoritative roster topology.
         }
-        catch (err) {
-            rethrowAsCliError(err);
+        const nodes = dto.nodes.map((n) => ({ ...n, attention_count: counts[n.node_id] ?? 0 }));
+        const subscriptions = {};
+        for (const n of dto.nodes)
+            subscriptions[n.node_id] = [];
+        for (const e of dto.edges) {
+            const list = subscriptions[e.from_id];
+            if (list !== undefined)
+                list.push(e.to_id);
+            else
+                subscriptions[e.from_id] = [e.to_id];
         }
+        return { generated_at: dto.generated_at, nodes, subscriptions, edges: dto.edges };
     },
 });

package/dist/commands/dashboard.js

@@ -7,7 +7,7 @@
 // Exported as a leaf; `crtr canvas` (canvas.ts) mounts it.
 import { defineLeaf } from '../core/command.js';
 import { InputError } from '../core/io.js';
-import { cliClient, cliCanvasSource } from './api-client.js';
+import { cliCanvasSource } from './api-client.js';
 import { renderTreeFromSource, renderForestFromSource, dashboardRowsFromSource, dashboardRowsAllFromSource, enrichRowsFromSource, } from '../core/canvas/render-source.js';
 // dashboard show — the main leaf
 export const dashboardLeaf = defineLeaf({
@@ -37,40 +37,47 @@ export const dashboardLeaf = defineLeaf({
     run: async (input) => {
         const rootId = input['root'];
         const source = cliCanvasSource();
+        const allNodes = await source.listNodes();
         if (rootId !== undefined) {
-            // Scoped to a single root — validate the node exists (via the daemon API).
-            const node = await source.getNode(rootId);
-            if (node === null) {
+            if (!allNodes.some((node) => node.node_id === rootId)) {
                 throw new InputError({
                     error: 'not_found',
                     message: `no node: ${rootId}`,
                     next: 'List nodes with `crtr node inspect list` to find a valid id.',
                 });
             }
-            const rows = await dashboardRowsFromSource(source, rootId);
+            let asks = {};
+            let ticketsUnavailable;
+            try {
+                asks = await source.ticketCountsForView(rootId);
+            }
+            catch (err) {
+                ticketsUnavailable = err instanceof Error ? err.message : String(err);
+            }
+            const rows = await dashboardRowsFromSource(source, rootId, allNodes, asks);
             return {
-                tree: await renderTreeFromSource(source, rootId),
+                tree: await renderTreeFromSource(source, rootId, allNodes, asks, ticketsUnavailable),
                 nodes: rows.length,
                 rows,
             };
         }
         // Full forest: all nodes on the canvas.
-        const allNodes = await source.listNodes();
         // dashboardRowsAllFromSource is the cheap-boot builder: ctx_tokens/asks are 0
         // and `name` is the handle only until enriched. The JSON consumer wants the
         // real values, so fold the deferred fields in before emitting (the rendered
         // TREE is unaffected). Ask counts are per-node: attention follows each human
-        // bridge's parent relation. The daemon's canvas snapshot carries that count
-        // (`attention_count`, server-side `enrichRows`), so read it straight off the
-        // roster.
-        const rows = await dashboardRowsAllFromSource(source);
-        const snapshot = await cliClient().canvasSnapshot();
-        const asks = {};
-        for (const n of snapshot.nodes)
-            asks[n.node_id] = n.attention_count;
+        // bridge's parent relation, so fetch all displayed counts in one batch.
+        const rows = await dashboardRowsAllFromSource(source, new Set(), false, allNodes);
+        let asks = {};
+        try {
+            asks = await source.ticketCountsForNodes(allNodes.map((node) => node.node_id));
+        }
+        catch {
+            // Ticket counts decorate the dashboard; the source snapshot remains authoritative.
+        }
         await enrichRowsFromSource(source, rows, asks);
         return {
-            tree: await renderForestFromSource(source),
+            tree: await renderForestFromSource(source, allNodes, asks),
             nodes: allNodes.length,
             rows,
         };

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

@@ -48,8 +48,8 @@ after(() => {
     delete process.env['CRTR_HOME'];
     delete process.env['CRTR_NODE_ID'];
 });
-test('the stored situational card rides the bearings body; absent when unset', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+test('the stored situational card rides the bearings body; absent when unset', async () => {
+    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     assert.equal(situationalContextEnvelope(meta.node_id), null, 'no card until something is set');
     assert.doesNotMatch(buildContextIntro(meta.node_id), /kind="situational"/, 'bearings carry no card when unset');
     appendSituationalContext(meta.node_id, formatSituationalProse('user is looking at the billing applet'));
@@ -73,7 +73,7 @@ function fakeCtx(pi) {
     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 });
+    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     process.env['CRTR_NODE_ID'] = meta.node_id;
     const pi = makeFakePi();
     registerCanvasContextIntro(pi);
@@ -87,7 +87,7 @@ test('session_start injects the block as the first message of an empty session',
     assert.match(pi.sent[0].content, /<crtr-bearings>/);
 });
 test('session_start is idempotent across resume (skips if already in history)', async () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     process.env['CRTR_NODE_ID'] = meta.node_id;
     // Restored session already carries OUR block (which names this node id) → no
     // duplicate injection. The content matters: the guard is fork-aware and only

package/dist/core/__tests__/cron-timeout-descendants.test.d.ts

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

package/dist/core/__tests__/cron-timeout-descendants.test.js

@@ -0,0 +1,102 @@
+// Run with: node --import tsx/esm --test src/core/__tests__/cron-timeout-descendants.test.ts
+//
+// #1037: a cron descendant living outside the shell's own process group held
+// the run's output pipes open, and settlement waited on those pipes. Teardown
+// signalled the group and moved on, so the timeout was recorded only when the
+// descendant finally exited by itself — 732 seconds for a 240-second timeout
+// in the field. Teardown must reap the tree it captured by ancestry, and the
+// record must wait for those processes to be dead rather than merely quiet.
+//
+// GNU `timeout` is the wrapper that produced the field report, but nothing
+// here is specific to it: a detached child reproduces the same shape on any
+// platform, so this never skips.
+import { after, before, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { closeDb } from '../canvas/db.js';
+import { armCron, getCron } from '../canvas/crons.js';
+import { isPidAlive } from '../canvas/pid.js';
+import { executeCron } from '../../daemon/cron-run.js';
+// The shell starts a live intermediate that keeps a detached grandchild in a
+// process group of its own. The grandchild inherits the cron's stdout and
+// stderr and ignores TERM, so the pipes stay open until something kills it.
+const INTERMEDIATE = `
+const { spawn } = require('node:child_process');
+spawn(process.execPath, [process.argv[2], process.argv[3]], { detached: true, stdio: 'inherit' }).unref();
+setInterval(() => {}, 1000);
+`;
+const DESCENDANT = `
+process.on('SIGTERM', () => {});
+require('node:fs').writeFileSync(process.argv[2], String(process.pid));
+setInterval(() => {}, 1000);
+`;
+let home;
+let realHome;
+let marker;
+let command;
+function arm(overrides) {
+    armCron({
+        name: overrides.cron_id,
+        created_by: null,
+        fire_at: new Date(Date.now() - 1_000).toISOString(),
+        recur: null,
+        tz: null,
+        expires_at: null,
+        anchor_node: null,
+        cancel_on_wake: false,
+        cwd: home,
+        env_json: null,
+        profile: null,
+        scope: 'profile',
+        run_timeout_s: 1,
+        overlap: 'skip',
+        on_output: 'silent',
+        sink: '{}',
+        tier: 'normal',
+        ...overrides,
+    });
+}
+before(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-cron-timeout-descendants-'));
+    realHome = process.env['CRTR_HOME'];
+    process.env['CRTR_HOME'] = home;
+    marker = join(home, 'descendant.pid');
+    const intermediate = join(home, 'intermediate.cjs');
+    const descendant = join(home, 'descendant.cjs');
+    writeFileSync(intermediate, INTERMEDIATE);
+    writeFileSync(descendant, DESCENDANT);
+    // Two statements, so the shell stays alive as the tree's root rather than
+    // exec-replacing itself with the intermediate.
+    command = `${JSON.stringify(process.execPath)} ${JSON.stringify(intermediate)} ${JSON.stringify(descendant)} ${JSON.stringify(marker)}; printf 'shell survived\\n'`;
+});
+after(() => {
+    if (existsSync(marker)) {
+        const stranded = Number.parseInt(readFileSync(marker, 'utf8').trim(), 10);
+        if (Number.isInteger(stranded) && stranded > 0 && isPidAlive(stranded)) {
+            try {
+                process.kill(stranded, 'SIGKILL');
+            }
+            catch {
+                // It exited between the liveness probe and the signal.
+            }
+        }
+    }
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    if (realHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = realHome;
+});
+test('a TERM-ignoring descendant outside the shell process group is reaped before the timeout is recorded', async () => {
+    arm({ cron_id: 'timeout-descendants', command });
+    const record = await executeCron(getCron('timeout-descendants'), { outOfBand: true });
+    assert.ok(record !== null, 'the run settles instead of hanging on held pipes');
+    assert.equal(record.exit_code, -1, 'the configured deadline is recorded as a timeout');
+    assert.ok(record.duration_ms < 5_000, `settlement is bounded by the deadline and teardown, got ${record.duration_ms}ms`);
+    const descendant = Number.parseInt(readFileSync(marker, 'utf8').trim(), 10);
+    assert.ok(Number.isInteger(descendant) && descendant > 0, 'the scenario actually started an out-of-group descendant');
+    assert.equal(isPidAlive(descendant), false, 'the descendant is dead, not merely detached from the pipes it was holding');
+});

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

@@ -45,9 +45,9 @@ async function withMutedStdout(fn) {
         process.stdout.write = originalWrite;
     }
 }
-function bridgeUnder() {
-    const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
-    const bridge = spawnNode({ kind: 'human', parent, creator: parent, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
+async function bridgeUnder() {
+    const parent = (await spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' })).node_id;
+    const bridge = (await spawnNode({ kind: 'human', parent, creator: parent, cwd: home, name: 'human-page', lifecycle: 'terminal' })).node_id;
     return { parent, bridge };
 }
 function submitBridgePage(bridge) {
@@ -97,7 +97,7 @@ after(() => {
 });
 describe('enqueue is producer-only', () => {
     test('send preserves title and subtitle from the authored page', async () => {
-        const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
+        const parent = (await spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' })).node_id;
         process.env['CRTR_NODE_ID'] = parent;
         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');
@@ -117,7 +117,7 @@ describe('enqueue is producer-only', () => {
         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;
+        const parent = (await 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 }));
@@ -128,7 +128,7 @@ describe('enqueue is producer-only', () => {
 });
 describe('terminal ticket delivery', () => {
     test("resolvePageTicket pushFinals the person's words once and wakes the subscribed parent", async () => {
-        const { parent, bridge } = bridgeUnder();
+        const { parent, bridge } = await bridgeUnder();
         const dir = submitBridgePage(bridge);
         const result = await resolvePageTicket(bridge, { question: { text: 'yes, ship', edited: true } });
         assert.equal(result.kind, 'page');
@@ -142,7 +142,7 @@ describe('terminal ticket delivery', () => {
         assert.ok(!body.includes(join(dir, 'response.json')));
     });
     test('settlement delivers feedback outside the human-answer entry', async () => {
-        const { parent, bridge } = bridgeUnder();
+        const { parent, bridge } = await bridgeUnder();
         const dir = submitBridgePage(bridge);
         writeFileSync(pageFeedbackPath(dir), JSON.stringify({
             schema: 'crtr.page-feedback/v1',
@@ -167,7 +167,7 @@ describe('terminal ticket delivery', () => {
         assert.deepEqual(answer, { kind: 'final', disposition: 'human-answer', body: `yes, ship\n\nRead this report with \`crtr canvas history read ${final.ref}\`.`, ref: final.ref });
     });
     test('a replay against a terminal bridge is a no-op', async () => {
-        const { parent, bridge } = bridgeUnder();
+        const { parent, bridge } = await bridgeUnder();
         submitBridgePage(bridge);
         await resolvePageTicket(bridge, { question: { text: 'yes', edited: true } });
         assert.equal(await deliverTerminalResult(bridge), true);
@@ -176,9 +176,9 @@ describe('terminal ticket delivery', () => {
         assert.equal(finals.length, 1, 'replay after a terminal bridge pushes nothing further');
     });
     test('approved companions receive one canonical final while dismissed companions remain canceled', async () => {
-        const { bridge } = bridgeUnder();
+        const { bridge } = await bridgeUnder();
         const dir = submitBridgePage(bridge);
-        const companion = spawnNode({ kind: 'general', parent: bridge, creator: bridge, cwd: home, name: 'feedback companion', lifecycle: 'resident' }).node_id;
+        const companion = (await spawnNode({ kind: 'general', parent: bridge, creator: bridge, cwd: home, name: 'feedback companion', lifecycle: 'resident' })).node_id;
         createPageFeedbackComment(dir, { quote: 'Ship it?', note: 'Confirm the release.', companionNodeId: companion });
         transition(companion, 'finish');
         await resolvePageTicket(bridge, { question: { text: 'yes', edited: true } });
@@ -193,9 +193,9 @@ describe('terminal ticket delivery', () => {
         assert.equal(getNode(companion)?.final_report, finalReport, 'terminal replay preserves the first canonical final');
         assert.equal(getNode(companion)?.finalized_at, finalizedAt, 'terminal replay preserves the first finalization time');
         await assert.rejects(reviveNode(companion, { resume: true, capacity: 'freeze' }), /finalization latch/);
-        const { bridge: dismissedBridge } = bridgeUnder();
+        const { bridge: dismissedBridge } = await bridgeUnder();
         const dismissedDir = submitBridgePage(dismissedBridge);
-        const dismissedCompanion = spawnNode({ kind: 'general', parent: dismissedBridge, creator: dismissedBridge, cwd: home, name: 'dismissed feedback companion', lifecycle: 'resident' }).node_id;
+        const dismissedCompanion = (await spawnNode({ kind: 'general', parent: dismissedBridge, creator: dismissedBridge, cwd: home, name: 'dismissed feedback companion', lifecycle: 'resident' })).node_id;
         createPageFeedbackComment(dismissedDir, { quote: 'Ship it?', note: 'Do not ship.', companionNodeId: dismissedCompanion });
         await cancelHumanTicket(dismissedBridge, { reason: 'dismissed', actor: 'human' });
         assert.equal(getNode(dismissedCompanion)?.status, 'canceled');
@@ -206,9 +206,9 @@ describe('terminal ticket delivery', () => {
         assert.equal(getNode(dismissedCompanion)?.final_report, null);
     });
     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, creator: actor, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
-        const other = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'other' }).node_id;
+        const actor = (await spawnNode({ kind: 'general', parent: null, cwd: home, name: 'actor' })).node_id;
+        const bridge = (await spawnNode({ kind: 'human', parent: actor, creator: actor, cwd: home, name: 'human-page', lifecycle: 'terminal' })).node_id;
+        const other = (await spawnNode({ kind: 'general', parent: null, cwd: home, name: 'other' })).node_id;
         const { subscribe } = await import('../canvas/canvas.js');
         subscribe(other, bridge, true);
         submitBridgePage(bridge);
@@ -222,9 +222,9 @@ describe('terminal ticket delivery', () => {
         assert.match(notes[0].label, /canceled/);
     });
     test('cancellation reaches subscribers when the bridge is already done, and retries conflict rather than fail', async () => {
-        const actor = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'actor' }).node_id;
-        const bridge = spawnNode({ kind: 'human', parent: actor, creator: actor, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
-        const other = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'other' }).node_id;
+        const actor = (await spawnNode({ kind: 'general', parent: null, cwd: home, name: 'actor' })).node_id;
+        const bridge = (await spawnNode({ kind: 'human', parent: actor, creator: actor, cwd: home, name: 'human-page', lifecycle: 'terminal' })).node_id;
+        const other = (await spawnNode({ kind: 'general', parent: null, cwd: home, name: 'other' })).node_id;
         const { subscribe } = await import('../canvas/canvas.js');
         subscribe(other, bridge, true);
         submitBridgePage(bridge);

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

@@ -88,8 +88,8 @@ function reportBody(ref) {
     return resolved.body;
 }
 test('malformed resolves leave the mounted ticket claim in place', async () => {
-    const parent = spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' }).node_id;
-    const pageBridge = spawnNode({ kind: 'human', parent, creator: parent, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
+    const parent = (await spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' })).node_id;
+    const pageBridge = (await spawnNode({ kind: 'human', parent, creator: parent, cwd: home, name: 'human-page', lifecycle: 'terminal' })).node_id;
     const pageDir = submitBridgePage(pageBridge);
     const pageClaim = claimTicket(pageDir);
     assert.ok(pageClaim !== null);
@@ -101,7 +101,7 @@ test('malformed resolves leave the mounted ticket claim in place', async () => {
         await expectReviewSubmitGuidance(pageBridge, body);
         assert.equal(readTicketClaim(pageDir)?.token, pageClaim.token, 'feedback-shaped input must not take over the live claim');
     }
-    const reviewBridge = spawnNode({ kind: 'human', parent, creator: parent, cwd: home, name: 'human-review', lifecycle: 'terminal' }).node_id;
+    const reviewBridge = (await spawnNode({ kind: 'human', parent, creator: parent, cwd: home, name: 'human-review', lifecycle: 'terminal' })).node_id;
     const reviewDir = ticketDir(reviewBridge);
     const file = join(home, 'review.md');
     writeFileSync(file, '# Review\n');
@@ -113,8 +113,8 @@ test('malformed resolves leave the mounted ticket claim in place', async () => {
     assert.equal(readTicketClaim(reviewDir)?.token, reviewClaim.token, 'review ticket resolve must not take over the live claim');
 });
 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, creator: parent, cwd: home, name: 'human-page', lifecycle: 'terminal' }).node_id;
+    const parent = (await spawnNode({ kind: 'general', parent: null, cwd: home, name: 'asker' })).node_id;
+    const bridge = (await spawnNode({ kind: 'human', parent, creator: 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 } } });
     assert.deepEqual(result, { completed: true, reply_delivered: true, kind: 'page' });