@north-light/crouter 0.3.282 → 0.3.283

package/dist/daemon/__tests__/node-deadline-lane.test.js

@@ -0,0 +1,76 @@
+import { after, afterEach, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { closeDb } from '../../core/canvas/db.js';
+import { createNode, dueNodeDeadlines, getRow } from '../../core/canvas/canvas.js';
+import { pushFinal } from '../../core/feed/feed.js';
+import { transition } from '../../core/runtime/lifecycle.js';
+import { NodeDeadlineReconciler } from '../reconcilers/node-deadline.js';
+let home;
+const priorHome = process.env['CRTR_HOME'];
+const now = Date.parse('2026-08-31T00:00:10.000Z');
+const pastDeadline = '2026-08-31T00:00:00.000Z';
+const futureDeadline = '2026-08-31T00:01:00.000Z';
+function node(nodeId, opts = {}) {
+    return {
+        node_id: nodeId,
+        name: nodeId,
+        created: new Date(now - 1_000).toISOString(),
+        cwd: home,
+        kind: opts.kind ?? 'general',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: opts.status ?? 'active',
+        deadline_at: opts.deadlineAt ?? null,
+    };
+}
+beforeEach(() => {
+    closeDb();
+    home = mkdtempSync(join(tmpdir(), 'crtr-node-deadline-'));
+    process.env['CRTR_HOME'] = home;
+});
+afterEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+});
+after(() => {
+    closeDb();
+    if (priorHome === undefined)
+        delete process.env['CRTR_HOME'];
+    else
+        process.env['CRTR_HOME'] = priorHome;
+});
+test('due node deadlines select only live, non-human, un-outcomed past-due rows', () => {
+    createNode(node('active-due', { deadlineAt: pastDeadline }));
+    createNode(node('idle-due', { status: 'idle', deadlineAt: pastDeadline }));
+    createNode(node('human-due', { kind: 'human', deadlineAt: pastDeadline }));
+    createNode(node('future', { deadlineAt: futureDeadline }));
+    createNode(node('outcomed', { deadlineAt: pastDeadline }));
+    transition('outcomed', 'crash');
+    transition('outcomed', 'revive');
+    createNode(node('done', { status: 'done', deadlineAt: pastDeadline }));
+    assert.deepEqual(dueNodeDeadlines(new Date(now).toISOString()).map((row) => row.node_id), ['active-due', 'idle-due']);
+});
+test('expiry commits cancellation and outcome before its asynchronous teardown request', async () => {
+    createNode(node('expired', { deadlineAt: pastDeadline }));
+    new NodeDeadlineReconciler().run(now);
+    const expired = getRow('expired');
+    assert.deepEqual({ status: expired.status, reason: expired.outcome_reason, kind: expired.outcome_kind }, {
+        status: 'canceled', reason: 'deadline_exceeded', kind: 'failure',
+    });
+    assert.equal(expired.outcome_at === null, false, 'the durable outcome is committed before the queued teardown can run');
+    await new Promise((resolve) => setImmediate(resolve));
+});
+test('a canonical final that wins after deadline selection is not overwritten', async () => {
+    createNode(node('finalized', { deadlineAt: pastDeadline }));
+    const staleCandidate = dueNodeDeadlines(new Date(now).toISOString()).find((row) => row.node_id === 'finalized');
+    assert.ok(staleCandidate, 'the row was eligible when the deadline lane selected it');
+    await pushFinal('finalized', 'finished before the deadline cancellation committed');
+    new NodeDeadlineReconciler().expire(staleCandidate, now);
+    const finalized = getRow('finalized');
+    assert.deepEqual({ status: finalized.status, reason: finalized.outcome_reason, kind: finalized.outcome_kind }, {
+        status: 'done', reason: 'finalized', kind: 'result',
+    });
+});

package/dist/daemon/__tests__/node-outcome-birth-invariants.test.d.ts

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

package/dist/daemon/__tests__/node-outcome-birth-invariants.test.js

@@ -0,0 +1,122 @@
+import { after, afterEach, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { closeDb } from '../../core/canvas/db.js';
+import { createNode, getRow, transitionStatusIntent } from '../../core/canvas/canvas.js';
+import { armOutcomeDelivery, readOutcomeDelivery } from '../../core/canvas/node-outcome-deliveries.js';
+import { pushFinal } from '../../core/feed/feed.js';
+import { transition } from '../../core/runtime/lifecycle.js';
+import { spawnNode } from '../../core/runtime/nodes.js';
+import { spawnChildPrepared } from '../../core/runtime/spawn.js';
+let home;
+const priorHome = process.env.CRTR_HOME;
+function node(nodeId, opts = {}) {
+    return {
+        node_id: nodeId,
+        name: nodeId,
+        created: new Date().toISOString(),
+        cwd: home,
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+        ...opts,
+    };
+}
+const binding = {
+    actionName: 'test-action',
+    argv: ['/bin/true'],
+    cwd: '/tmp',
+    configOrigin: 'test',
+    payload: { callback: 'one' },
+};
+beforeEach(() => {
+    closeDb();
+    home = mkdtempSync(join(tmpdir(), 'crtr-outcome-birth-'));
+    process.env.CRTR_HOME = home;
+});
+afterEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+});
+after(() => {
+    if (priorHome === undefined)
+        delete process.env.CRTR_HOME;
+    else
+        process.env.CRTR_HOME = priorHome;
+});
+test('birth commits the requested deadline and outcome registration before spawn orchestration can launch a broker', () => {
+    const deadlineAt = '2026-01-01T00:00:00.000Z';
+    const born = spawnNode({
+        kind: 'general',
+        cwd: home,
+        lifecycle: 'terminal',
+        deadlineAt,
+        outcomeDelivery: binding,
+    });
+    assert.equal(getRow(born.node_id)?.deadline_at, deadlineAt);
+    assert.deepEqual(readOutcomeDelivery(born.node_id) && {
+        state: readOutcomeDelivery(born.node_id).state,
+        action: readOutcomeDelivery(born.node_id).actionName,
+        payload: readOutcomeDelivery(born.node_id).payload,
+    }, {
+        state: 'armed',
+        action: 'test-action',
+        payload: { callback: 'one' },
+    });
+});
+test('a pre-launch spawn failure leaves its caller-requested outcome delivery pending', async () => {
+    let nodeId;
+    await assert.rejects(() => spawnChildPrepared({
+        kind: 'general',
+        cwd: process.cwd(),
+        root: true,
+        profile: null,
+        prompt: '',
+        deadlineAt: '2026-01-01T00:00:00.000Z',
+        outcomeDelivery: binding,
+    }, (id) => {
+        nodeId = id;
+        throw new Error('simulated pre-launch failure');
+    }), /simulated pre-launch failure/);
+    assert.ok(nodeId);
+    assert.equal(getRow(nodeId)?.outcome_reason, 'launch_failed');
+    assert.equal(readOutcomeDelivery(nodeId)?.state, 'pending');
+    assert.ok(readOutcomeDelivery(nodeId)?.document);
+});
+test('an armed delivery cannot become pending without its outcome document', () => {
+    createNode(node('guarded'));
+    armOutcomeDelivery({ nodeId: 'guarded', ...binding });
+    transitionStatusIntent('guarded', { status: 'dead', terminal_reason: 'crashed' }, {
+        outcome: {
+            kind: 'failure',
+            reason: 'crashed',
+            detailJson: null,
+            at: '2026-01-01T00:00:00.000Z',
+            documentJson: null,
+        },
+    });
+    const delivery = readOutcomeDelivery('guarded');
+    assert.equal(delivery?.state, 'armed');
+    assert.equal(delivery?.document, null);
+});
+test('late registration composes the latched terminal view from hydrated node identity', () => {
+    createNode(node('late', { spawned_by: 'origin' }));
+    transition('late', 'crash');
+    transition('late', 'revive');
+    const delivery = armOutcomeDelivery({ nodeId: 'late', ...binding });
+    const document = delivery?.document;
+    assert.equal(document.node.status, 'dead');
+    assert.equal(document.node.terminalReason, 'crashed');
+    assert.equal(document.node.spawnedBy, 'origin');
+});
+test('human bridges transition and finalize without latching outcomes', async () => {
+    createNode(node('human-transition', { kind: 'human' }));
+    transition('human-transition', 'finish');
+    assert.equal(getRow('human-transition')?.outcome_at, null);
+    createNode(node('human-final', { kind: 'human' }));
+    await pushFinal('human-final', 'bridge answer');
+    assert.equal(getRow('human-final')?.outcome_at, null);
+});

package/dist/daemon/__tests__/node-outcome-delivery.test.d.ts

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

package/dist/daemon/__tests__/node-outcome-delivery.test.js

@@ -0,0 +1,86 @@
+import { after, afterEach, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { closeDb } from '../../core/canvas/db.js';
+import { createNode } from '../../core/canvas/canvas.js';
+import { isPidAlive, killProcessGroup } from '../../core/canvas/pid.js';
+import { armOutcomeDelivery, claimOutcomeDelivery, readOutcomeDelivery } from '../../core/canvas/node-outcome-deliveries.js';
+import { transition } from '../../core/runtime/lifecycle.js';
+import { OUTCOME_DELIVERY_TIMEOUT_MS, deliverOutcome } from '../node-outcome/deliver-outcome.js';
+let home;
+let processGroupFiles;
+const priorHome = process.env.CRTR_HOME;
+function node(nodeId) {
+    return { node_id: nodeId, name: nodeId, created: new Date().toISOString(), cwd: home, kind: 'general', mode: 'base', lifecycle: 'terminal', status: 'active' };
+}
+function claimScript(id, script) {
+    const path = join(home, `${id}.sh`);
+    writeFileSync(path, script);
+    chmodSync(path, 0o755);
+    createNode(node(id));
+    armOutcomeDelivery({ nodeId: id, actionName: 'test', argv: [path], cwd: home, configOrigin: 'test' });
+    transition(id, 'crash');
+    const delivery = claimOutcomeDelivery(id, Date.now(), 'test-daemon');
+    assert.ok(delivery);
+    return delivery;
+}
+beforeEach(() => {
+    closeDb();
+    home = mkdtempSync(join(tmpdir(), 'crtr-outcome-delivery-'));
+    process.env.CRTR_HOME = home;
+    processGroupFiles = [];
+});
+afterEach(() => {
+    for (const path of processGroupFiles) {
+        if (!existsSync(path))
+            continue;
+        const pid = Number(readFileSync(path, 'utf8').trim());
+        if (Number.isInteger(pid) && pid > 0)
+            killProcessGroup(pid, 'SIGKILL');
+    }
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+});
+after(() => {
+    if (priorHome === undefined)
+        delete process.env.CRTR_HOME;
+    else
+        process.env.CRTR_HOME = priorHome;
+});
+test('exit acknowledgments settle outcome delivery durably', async () => {
+    const accepted = claimScript('accepted', '#!/bin/sh\necho ignored\necho diagnostic >&2\nexit 0\n');
+    await deliverOutcome(accepted, 'test-daemon');
+    assert.equal(readOutcomeDelivery('accepted')?.state, 'accepted');
+    const permanent = claimScript('permanent', '#!/bin/sh\nexit 78\n');
+    await deliverOutcome(permanent, 'test-daemon');
+    assert.equal(readOutcomeDelivery('permanent')?.state, 'permanent_failed');
+    const retry = claimScript('retry', '#!/bin/sh\necho retry-stderr >&2\nexit 1\n');
+    await deliverOutcome(retry, 'test-daemon');
+    const row = readOutcomeDelivery('retry');
+    assert.equal(row?.state, 'pending');
+    assert.ok(row.nextAttemptAt > Date.now());
+    assert.equal(row?.lastFailure?.kind, 'exit');
+    assert.equal(row?.lastFailure?.stderr, 'retry-stderr\n');
+});
+test('timeout SIGKILL escalation reaps a SIGTERM-ignoring descendant after its leader exits', async () => {
+    const childPid = join(home, 'descendant.pid');
+    const processGroupPid = join(home, 'process-group.pid');
+    processGroupFiles.push(processGroupPid);
+    const delivery = claimScript('timeout', `#!/bin/sh\necho $$ > ${processGroupPid}\n(\n  trap '' TERM\n  while :; do sleep 30; done\n) &\necho $! > ${childPid}\ntrap 'exit 0' TERM\nwhile :; do sleep 30; done\n`);
+    const originalSetTimeout = global.setTimeout;
+    global.setTimeout = ((callback, delay, ...args) => originalSetTimeout(callback, delay === OUTCOME_DELIVERY_TIMEOUT_MS ? 1_000 : delay, ...args));
+    try {
+        await deliverOutcome(delivery, 'test-daemon');
+    }
+    finally {
+        global.setTimeout = originalSetTimeout;
+    }
+    const row = readOutcomeDelivery('timeout');
+    assert.equal(row?.state, 'pending');
+    assert.equal(row?.lastFailure?.kind, 'timeout');
+    const pid = Number(readFileSync(childPid, 'utf8').trim());
+    await new Promise((resolve) => originalSetTimeout(resolve, 2_100));
+    assert.equal(isPidAlive(pid), false);
+});

package/dist/daemon/api/__tests__/broker-settle-park.test.js

@@ -1,22 +1,24 @@
 // Run with: node --conditions=crtr-src --import tsx/esm --test src/daemon/api/__tests__/broker-settle-park.test.ts
 //
-// The park clock hands terminalization to broker settlement: it arms a pending
-// park, delivers one summary prompt to the live engine, and this handler
-// decides what the ending turn meant. The defect surface is the re-evaluation —
-// the verdict the clock reached 15 minutes ago must not be enacted when the
-// summary turn itself created live work (a human ask, new wake-worthy mail, a
-// pushed final), and the pending park must be consumed exactly once regardless.
+// The park clock arms one pending marker, then an isolated parking turn reports
+// completion through its own operation. Main-session settlement must not consume
+// that marker: a user turn can settle while the shadow turn still runs. The
+// completion re-evaluates whether parking still applies exactly once.
 import { after, before, beforeEach, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { createNode, getNode } from '../../../core/canvas/canvas.js';
+import { mkdtempSync, rmSync, writeFileSync, utimesSync } from 'node:fs';
+import { join } from 'node:path';
+import { createNode, getNode, updateNode } from '../../../core/canvas/canvas.js';
 import { closeDb } from '../../../core/canvas/db.js';
-import { appendInbox } from '../../../core/feed/inbox.js';
+import { appendInbox, writeCursor } from '../../../core/feed/inbox.js';
+import { markBusy } from '../../../core/runtime/busy.js';
 import { beginPendingPark, isPendingPark } from '../../park-pending.js';
 import { brokerOperationRoutes } from '../handlers/broker-ops.js';
 let home = '';
 let originalHome;
 const settleRoute = brokerOperationRoutes.find((route) => route.method === 'POST' && route.pattern === '/v1/nodes/:id/broker/settle');
+const parkCompleteRoute = brokerOperationRoutes.find((route) => route.method === 'POST' && route.pattern === '/v1/nodes/:id/broker/park-complete');
+const parkActivityRoute = brokerOperationRoutes.find((route) => route.method === 'POST' && route.pattern === '/v1/nodes/:id/broker/park-activity');
 before(() => {
     originalHome = process.env['CRTR_HOME'];
     home = mkdtempSync('/tmp/crtr-settle-park-');
@@ -34,8 +36,7 @@ after(() => {
     else
         process.env['CRTR_HOME'] = originalHome;
 });
-/** A live resident mid-parking-turn: the clock armed the park and the summary
- *  turn is what is now settling. */
+/** A live resident with an isolated parking turn in flight. */
 function residentMidParkingTurn(id) {
     const meta = {
         node_id: id,
@@ -66,9 +67,29 @@ async function settle(id, over = {}) {
     };
     return (await settleRoute.handler(ctx)).body;
 }
-test('a summary turn that ends with nothing new parks the node: done + intent=parked, no latch', async () => {
+async function completePark(id) {
+    const ctx = {
+        method: 'POST',
+        path: `/v1/nodes/${id}/broker/park-complete`,
+        params: { id },
+        query: new URLSearchParams(),
+        body: { outcome: 'completed' },
+    };
+    return (await parkCompleteRoute.handler(ctx)).body;
+}
+async function recordParkActivity(id) {
+    const ctx = {
+        method: 'POST',
+        path: `/v1/nodes/${id}/broker/park-activity`,
+        params: { id },
+        query: new URLSearchParams(),
+        body: {},
+    };
+    return (await parkActivityRoute.handler(ctx)).body;
+}
+test('a completed park turn with nothing new parks the node: done + intent=parked, no latch', async () => {
     residentMidParkingTurn('summarized');
-    const directive = await settle('summarized');
+    const directive = await completePark('summarized');
     assert.deepEqual(directive, { action: 'shutdown' });
     const parked = getNode('summarized');
     assert.equal(parked.status, 'done');
@@ -76,27 +97,74 @@ test('a summary turn that ends with nothing new parks the node: done + intent=pa
     assert.equal(parked.final_report ?? null, null, 'a park never sets the finalization latch');
     assert.equal(isPendingPark('summarized'), false, 'the pending park is consumed');
 });
-test('a human ask raised during the parking turn keeps the node live instead of parking it', async () => {
+test('a human ask raised during the parking turn does not consume the pending marker', async () => {
     residentMidParkingTurn('asked');
     const directive = await settle('asked', { requestedHumanReply: true });
     assert.deepEqual(directive, { action: 'stay_dormant' });
     assert.equal(getNode('asked').status, 'active', 'the node stays live awaiting its answer');
     assert.equal(getNode('asked').intent ?? null, null);
-    assert.equal(isPendingPark('asked'), false, 'the park is discarded, not held for the next settle');
+    assert.equal(isPendingPark('asked'), true, 'main-session settlement leaves completion to the shadow turn');
+});
+test('a main turn racing shadow completion keeps the broker live', async () => {
+    residentMidParkingTurn('busy-main');
+    markBusy('busy-main');
+    const directive = await completePark('busy-main');
+    assert.deepEqual(directive, { action: 'stay_dormant' });
+    assert.equal(getNode('busy-main').status, 'active');
+    assert.equal(getNode('busy-main').intent ?? null, null);
+    assert.equal(isPendingPark('busy-main'), false, 'shadow completion consumes the marker after releasing the main turn');
 });
 test('wake-worthy mail arriving during the parking turn flips the verdict back to release', async () => {
     residentMidParkingTurn('mailed');
     appendInbox('mailed', { from: null, tier: 'normal', kind: 'message', label: 'x', data: { body: 'work' } });
-    const directive = await settle('mailed');
+    const directive = await completePark('mailed');
     assert.equal(directive.action, 'stay_dormant');
     assert.equal(getNode('mailed').status, 'active', 're-evaluation saw the new obligation and did not park');
     assert.equal(getNode('mailed').intent ?? null, null);
     assert.equal(isPendingPark('mailed'), false);
 });
-test('a final pushed during the parking turn finishes the node rather than parking it', async () => {
+test('a message already consumed by the main turn still releases the parking completion', async () => {
+    residentMidParkingTurn('consumed-mail');
+    const entry = appendInbox('consumed-mail', { from: null, tier: 'normal', kind: 'message', label: 'work', data: { body: 'work' } });
+    writeCursor('consumed-mail', entry.entry_id);
+    const directive = await completePark('consumed-mail');
+    assert.deepEqual(directive, { action: 'stay_dormant' });
+    assert.equal(getNode('consumed-mail').status, 'active');
+    assert.equal(getNode('consumed-mail').intent ?? null, null);
+    assert.equal(isPendingPark('consumed-mail'), false);
+});
+test('a bound but absent main-session file is not activity', async () => {
+    residentMidParkingTurn('empty-session');
+    updateNode('empty-session', { pi_session_file: join(home, 'not-created-yet.jsonl') });
+    const directive = await completePark('empty-session');
+    assert.deepEqual(directive, { action: 'shutdown' });
+    assert.equal(getNode('empty-session').status, 'done');
+});
+test('accepted broker input atomically keeps the shadow completion live', async () => {
+    residentMidParkingTurn('admitted-input');
+    assert.deepEqual(await recordParkActivity('admitted-input'), { activity: 'recorded' });
+    const directive = await completePark('admitted-input');
+    assert.deepEqual(directive, { action: 'stay_dormant' });
+    assert.equal(getNode('admitted-input').status, 'active');
+    assert.equal(isPendingPark('admitted-input'), false);
+});
+test('main-session activity already settled before completion releases parking', async () => {
+    residentMidParkingTurn('interactive-mail');
+    const sessionFile = join(home, 'interactive-mail.jsonl');
+    writeFileSync(sessionFile, 'main turn');
+    const afterParkStart = new Date(Date.now() + 1000);
+    utimesSync(sessionFile, afterParkStart, afterParkStart);
+    updateNode('interactive-mail', { pi_session_file: sessionFile });
+    const directive = await completePark('interactive-mail');
+    assert.deepEqual(directive, { action: 'stay_dormant' });
+    assert.equal(getNode('interactive-mail').status, 'active');
+    assert.equal(getNode('interactive-mail').intent ?? null, null);
+    assert.equal(isPendingPark('interactive-mail'), false);
+});
+test('a final pushed during the parking turn does not consume the pending marker', async () => {
     residentMidParkingTurn('finished');
     const directive = await settle('finished', { pushedFinal: true });
     assert.deepEqual(directive, { action: 'shutdown' });
     assert.equal(getNode('finished').intent ?? null, null, 'a pushed final is not a park');
-    assert.equal(isPendingPark('finished'), false);
+    assert.equal(isPendingPark('finished'), true, 'main-session settlement does not claim the shadow turn marker');
 });

package/dist/daemon/api/__tests__/profile-launch-gates.test.js

@@ -12,6 +12,7 @@ import { reviveNode } from '../../../core/runtime/revive.js';
 import { resolveLaunchTarget } from '../../../core/runtime/launch-target.js';
 import { spawnNode } from '../../../core/runtime/nodes.js';
 import { handleConfig, handleCreate, resolveCreateKind } from '../handlers/nodes.js';
+import { profileRoutes } from '../handlers/profiles.js';
 const previousCrtrHome = process.env['CRTR_HOME'];
 const previousHome = process.env.HOME;
 let home = '';
@@ -44,7 +45,15 @@ after(() => {
 });
 test('create rejects a paused profile before a node exists', async () => {
     const profile = createProfile('paused profile', [{ path: cwd, memory: 'content' }]);
-    pauseProfile(profile.profileId);
+    const pauseRoute = profileRoutes.find((route) => route.method === 'POST' && route.pattern === '/v1/profiles/:name/pause');
+    assert.ok(pauseRoute, 'profile pause API route is registered');
+    await pauseRoute.handler({
+        method: 'POST',
+        path: `/v1/profiles/${profile.profileId}/pause`,
+        params: { name: profile.profileId },
+        query: new URLSearchParams(),
+        body: {},
+    });
     const ctx = {
         method: 'POST',
         path: '/v1/nodes',

package/dist/daemon/api/__tests__/seam/node-outcome-api.test.d.ts

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

package/dist/daemon/api/__tests__/seam/node-outcome-api.test.js

@@ -0,0 +1,159 @@
+// Run with: npm run build && node --test --test-timeout=180000 dist/daemon/api/__tests__/seam/node-outcome-api.test.js
+//
+// Pins the public node-outcome routes against the compiled API server on its
+// Unix socket. The fixture node is written through the canvas, then finalized
+// through the API, so the pending and settled documents cross the real wire.
+import { after, before, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { request as httpRequest } from 'node:http';
+import { chmodSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CrtrClient } from '../../../../api/index.js';
+import { createNode } from '../../../../core/canvas/canvas.js';
+import { resetScopeCache } from '../../../../core/scope.js';
+import { createHeadlessHarness } from '../../../../core/__tests__/helpers/harness.js';
+let h;
+let client;
+let nodeId;
+function assertKeys(value, expected, label) {
+    assert.deepEqual(Object.keys(value).sort(), [...expected].sort(), `${label} has the pinned wire fields`);
+}
+async function rawRequest(method, path, body) {
+    const encoded = body === undefined ? undefined : JSON.stringify(body);
+    return new Promise((resolve, reject) => {
+        const request = httpRequest({
+            socketPath: join(h.home, 'crtrd.sock'),
+            method,
+            path,
+            headers: encoded === undefined ? undefined : {
+                'content-type': 'application/json',
+                'content-length': Buffer.byteLength(encoded),
+            },
+        }, (response) => {
+            let content = '';
+            response.setEncoding('utf8');
+            response.on('data', (chunk) => { content += chunk; });
+            response.on('end', () => {
+                try {
+                    resolve({ status: response.statusCode ?? 0, body: content === '' ? null : JSON.parse(content) });
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+        request.on('error', reject);
+        request.end(encoded);
+    });
+}
+function assertError(response, status, code) {
+    assert.equal(response.status, status);
+    const body = response.body;
+    assert.equal(body.error.code, code);
+    assert.equal(typeof body.error.message, 'string');
+}
+before(async () => {
+    h = await createHeadlessHarness({ sessionPrefix: 'crtr-node-outcome-api' });
+    client = new CrtrClient({ socketPath: join(h.home, 'crtrd.sock'), autostart: false });
+    const actions = join(h.home, 'actions');
+    mkdirSync(actions, { recursive: true });
+    writeFileSync(join(actions, 'capture'), '#!/bin/sh\ncat >/dev/null\nexit 0\n');
+    chmodSync(join(actions, 'capture'), 0o755);
+    mkdirSync(join(h.home, '.crouter'), { recursive: true });
+    writeFileSync(join(h.home, '.crouter', 'config.json'), JSON.stringify({
+        humanActions: {
+            capture: { argv: ['actions/capture'], cwd: '.' },
+            broken: { argv: ['actions/missing'], cwd: '.' },
+        },
+    }));
+    resetScopeCache();
+    nodeId = `outcome-api-${process.pid}`;
+    createNode({
+        node_id: nodeId,
+        name: 'outcome API fixture',
+        created: new Date().toISOString(),
+        cwd: h.home,
+        kind: 'developer',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+        parent: null,
+    });
+});
+after(async () => {
+    resetScopeCache();
+    await h?.dispose();
+});
+test('node outcome and delivery routes preserve their public response and error contracts', async () => {
+    assertError(await rawRequest('GET', '/v1/nodes/missing-node/outcome'), 404, 'node_not_found');
+    assertError(await rawRequest('GET', `/v1/nodes/${nodeId}/outcome?wait=26.5`), 400, 'invalid_request');
+    assertError(await rawRequest('PUT', '/v1/nodes/missing-node/outcome-delivery', { action: 'capture' }), 404, 'node_not_found');
+    const pendingResponse = await rawRequest('GET', `/v1/nodes/${nodeId}/outcome`);
+    assert.equal(pendingResponse.status, 200, 'GET outcome → 200');
+    const pending = pendingResponse.body;
+    assertKeys(pending, ['node_id', 'state', 'outcome', 'node_status', 'deadline_at'], 'pending outcome response');
+    assert.deepEqual(pending, {
+        node_id: nodeId,
+        state: 'pending',
+        outcome: null,
+        node_status: 'active',
+        deadline_at: null,
+    }, 'GET outcome returns the complete pending NodeOutcomeResponseDTO');
+    assertError(await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: '' }), 400, 'invalid_request');
+    assertError(await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'unknown-action' }), 422, 'unknown_action');
+    const invalidAction = await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'broken' });
+    assertError(invalidAction, 422, 'invalid_action');
+    assertKeys(invalidAction.body.error.details, ['reason', 'configOrigin'], 'invalid_action details');
+    assertError(await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'capture', payload: 'x'.repeat(65 * 1024) }), 413, 'payload_too_large');
+    assertError(await rawRequest('GET', `/v1/nodes/${nodeId}/outcome-delivery`), 404, 'outcome_delivery_not_found');
+    const payload = { callback: 'fixture', sequence: [1, 2, 3] };
+    const armedResponse = await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'capture', payload });
+    assert.equal(armedResponse.status, 200, 'PUT delivery → 200');
+    const armed = armedResponse.body;
+    assertKeys(armed, ['node_id', 'state', 'action', 'attempt', 'next_attempt_at', 'accepted_at', 'permanent_failed_at', 'last_failure', 'created_at', 'updated_at'], 'armed delivery response');
+    assert.equal(armed.node_id, nodeId);
+    assert.equal(armed.state, 'armed');
+    assert.equal(armed.action, 'capture');
+    assert.equal(armed.attempt, 0);
+    assert.equal(armed.next_attempt_at, null);
+    assert.equal(armed.accepted_at, null);
+    assert.equal(armed.permanent_failed_at, null);
+    assert.equal(armed.last_failure, null);
+    assert.match(armed.created_at, /^\d{4}-\d{2}-\d{2}T/);
+    assert.match(armed.updated_at, /^\d{4}-\d{2}-\d{2}T/);
+    const registered = await rawRequest('GET', `/v1/nodes/${nodeId}/outcome-delivery`);
+    assert.equal(registered.status, 200, 'GET delivery → 200');
+    assert.deepEqual(registered.body, armed, 'GET delivery returns the registered DTO unchanged');
+    assert.equal((await rawRequest('DELETE', `/v1/nodes/${nodeId}/outcome-delivery`)).status, 204, 'DELETE armed delivery → 204');
+    assert.equal((await rawRequest('DELETE', `/v1/nodes/${nodeId}/outcome-delivery`)).status, 204, 'DELETE absent delivery remains idempotent → 204');
+    assertError(await rawRequest('GET', `/v1/nodes/${nodeId}/outcome-delivery`), 404, 'outcome_delivery_not_found');
+    const final = await client.pushReport(nodeId, { tier: 'final', body: 'outcome API canonical final' });
+    const settledResponse = await rawRequest('GET', `/v1/nodes/${nodeId}/outcome`);
+    assert.equal(settledResponse.status, 200, 'GET settled outcome → 200');
+    const settled = settledResponse.body;
+    assertKeys(settled, ['node_id', 'state', 'outcome', 'node_status', 'deadline_at'], 'settled outcome response');
+    assert.equal(settled.node_id, nodeId);
+    assert.equal(settled.state, 'settled');
+    assert.equal(settled.node_status, 'done');
+    assert.equal(settled.deadline_at, null);
+    assert.notEqual(settled.outcome, null, 'a canonical final settles an outcome');
+    const outcome = settled.outcome;
+    assertKeys(outcome, ['node_id', 'revision', 'kind', 'reason', 'settled_at', 'final_report', 'final_report_path', 'structured_result', 'detail', 'declined'], 'settled NodeOutcomeDTO');
+    assert.equal(outcome.node_id, nodeId);
+    assert.equal(outcome.revision, 1);
+    assert.equal(outcome.kind, 'result');
+    assert.equal(outcome.reason, 'finalized');
+    assert.match(outcome.settled_at, /^\d{4}-\d{2}-\d{2}T/);
+    assert.equal(outcome.final_report_path, final.report_path);
+    assert.ok(outcome.final_report !== null && outcome.final_report.length > 0, 'result carries its report basename');
+    assert.equal(outcome.structured_result, null);
+    assert.equal(outcome.detail, null);
+    const repeated = await rawRequest('GET', `/v1/nodes/${nodeId}/outcome`);
+    assert.equal(repeated.status, 200, 'repeat GET outcome → 200');
+    assert.deepEqual(repeated.body, settled, 'repeat GET returns the identical durable outcome response');
+    const pendingDelivery = await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'capture', payload });
+    assert.equal(pendingDelivery.status, 200, 'PUT delivery after settlement → 200');
+    assert.equal(pendingDelivery.body.state, 'pending', 'PUT after settlement arms immediate delivery');
+    assertError(await rawRequest('PUT', `/v1/nodes/${nodeId}/outcome-delivery`, { action: 'capture', payload }), 409, 'outcome_delivery_settled');
+    assertError(await rawRequest('DELETE', `/v1/nodes/${nodeId}/outcome-delivery`), 409, 'outcome_delivery_settled');
+});

package/dist/daemon/api/__tests__/submit-result.test.d.ts

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