@north-light/crouter 0.3.282 → 0.3.284

package/dist/commands/sys/settings-shell.js

@@ -66,6 +66,12 @@ export class SettingsShell {
                 label: "Models",
                 panel: this.models,
             },
+            {
+                id: "provider-options",
+                group: "Intelligence",
+                label: "Provider options",
+                panel: prefs("providers", "Provider options", "How a provider serves your turns, once it is authenticated."),
+            },
             {
                 id: "keybindings",
                 group: "Interface",

package/dist/commands/sys/settings.js

@@ -9,11 +9,11 @@ import { BROKER_LIMIT_OVERRIDE_PRECEDENCE } from './setup.js';
 /** Rail destinations, in rail order. Kept here rather than imported from the
  *  shell so registering the `sys` subtree still costs no pi module graph. */
 const PAGES = [
-    'providers', 'models', 'keybindings', 'display', 'profiles', 'panes', 'broker-limits', 'updates',
+    'providers', 'models', 'provider-options', 'keybindings', 'display', 'profiles', 'panes', 'broker-limits', 'updates',
 ];
 export const sysSettingsLeaf = defineLeaf({
     name: 'settings',
-    description: 'open the settings page — providers, models, keybindings, display, profiles, panes, broker limits, updates',
+    description: 'open the settings page — providers, models, provider options, keybindings, display, profiles, panes, broker limits, updates',
     whenToUse: 'the user wants to change crouter configuration interactively. Agents should use sys config get/set, which is scriptable; sys setup installs a fresh machine.',
     help: {
         name: 'sys settings',
@@ -31,7 +31,7 @@ export const sysSettingsLeaf = defineLeaf({
         output: [],
         outputKind: 'object',
         effects: [
-            'Opens a pi-tui page whose left rail groups ongoing configuration: Intelligence (providers, models), Interface (keybindings, display), and Workspace (profiles, panes, broker limits, updates).',
+            'Opens a pi-tui page whose left rail groups ongoing configuration: Intelligence (providers, models, provider options), Interface (keybindings, display), and Workspace (profiles, panes, broker limits, updates).',
             'Profiles edits are immediate: adding or removing a project directory, cycling its memory rung, setting a home, renaming, pausing and pinning a directory default all write the same profile manifests and pin file as the `crtr profile` leaves; deleting a profile runs the same cascade as `crtr profile delete --force`.',
             'Preference, model-ladder and keybinding edits save to the user config as you make them; saved keybinding changes also refresh crouter-owned tmux bindings without overwriting occupied user keys.',
             `Broker warning and automatic-revive hard-cap values save under user config brokerThresholds; crtrd reads them on its next supervision tick. ${BROKER_LIMIT_OVERRIDE_PRECEDENCE}`,

package/dist/core/__tests__/fixtures/fake-engine.d.ts

@@ -171,6 +171,8 @@ declare class FakeSession {
     get model(): FakeModel | undefined;
     private currentModel;
     private currentThinkingLevel;
+    private bashAbort;
+    private bashRun;
     get thinkingLevel(): ThinkingLevel | undefined;
     setThinkingLevel(level: ThinkingLevel): void;
     cycleThinkingLevel(): ThinkingLevel;

package/dist/core/__tests__/fixtures/fake-engine.js

@@ -35,6 +35,7 @@ import { join, dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { DefaultResourceLoader, getAgentDir } from '@earendil-works/pi-coding-agent';
 import { MANAGED_PROVIDER_COOLING_DIAGNOSTIC } from '../../runtime/managed-provider-cooling.js';
+import registerCanvasBashValve, { createValveOperations } from '../../../pi-extensions/canvas-bash-valve.js';
 /** Test seams for prompt-scoped failures before session_start. The one-shot
  *  variant records its first failure per node so the next cycling retry can
  *  reach boot confirmation. */
@@ -369,6 +370,8 @@ class FakeSession {
     // this getter — store whatever it hands us.
     currentModel;
     currentThinkingLevel;
+    bashAbort;
+    bashRun;
     get thinkingLevel() {
         return this.currentThinkingLevel;
     }
@@ -517,10 +520,12 @@ class FakeSession {
     }
     abort() {
         const held = this.heldTurn;
-        if (held === undefined)
-            return Promise.resolve();
-        held.release();
-        return held.settled;
+        if (held !== undefined) {
+            held.release();
+            return held.settled;
+        }
+        this.bashAbort?.abort();
+        return this.bashRun ?? Promise.resolve();
     }
     /** In-place tree rewind (broker `navigate_tree`). Mirrors the real SDK's
      *  contract: the session file is unchanged, the live history is truncated,
@@ -975,6 +980,39 @@ class FakeSession {
                     tool: cmd.tool,
                 });
                 break;
+            case 'bash': {
+                const nodeId = process.env['CRTR_NODE_ID'];
+                const contextDir = process.env['CRTR_CONTEXT_DIR'];
+                if (nodeId === undefined || contextDir === undefined)
+                    throw new Error('bash control requires canvas node paths');
+                this.streaming = true;
+                await this.fire('agent_start', {}, ctx);
+                this.emit({ type: 'agent_start' });
+                // The resource loader imports extensions through jiti while this fixture
+                // imports its valve operations through Node. Register the same module
+                // instance here so its SIGTERM listener owns this real test job too.
+                registerCanvasBashValve({ on: () => { } });
+                const controller = new AbortController();
+                this.bashAbort = controller;
+                const run = createValveOperations(nodeId, contextDir).exec(cmd.command ?? 'true', process.cwd(), {
+                    onData: () => { },
+                    signal: controller.signal,
+                }).then(() => { });
+                this.bashRun = run;
+                try {
+                    await run;
+                }
+                finally {
+                    this.bashAbort = undefined;
+                    this.bashRun = undefined;
+                    this.streaming = false;
+                }
+                await this.fire('agent_end', { messages: [] }, ctx);
+                this.emit({ type: 'agent_end', messages: [], willRetry: false });
+                await this.fire('agent_settled', { type: 'agent_settled' }, ctx);
+                this.emit({ type: 'agent_settled' });
+                break;
+            }
             case 'turn':
                 this.streaming = true;
                 await this.fire('agent_start', {}, ctx);

package/dist/core/__tests__/helpers/harness.d.ts

@@ -49,6 +49,7 @@ export interface SpawnOpts {
     mode?: Mode;
     lifecycle?: Lifecycle;
     model?: string;
+    profile?: string | null;
     id?: string;
 }
 /** Fabricate a broker-hosted node row directly — tmux-free, boot-free, NO

package/dist/core/__tests__/helpers/harness.js

@@ -514,6 +514,7 @@ export async function createHarness(opts = {}) {
                 ...(o.mode !== undefined ? { mode: o.mode } : {}),
                 ...(o.lifecycle !== undefined ? { rootLifecycle: o.lifecycle } : {}),
                 ...(o.model !== undefined ? { model: o.model } : {}),
+                ...(o.profile !== undefined ? { profile: o.profile } : {}),
             });
             await harness.awaitBoot(result.node.node_id);
             return result.node.node_id;
@@ -572,6 +573,14 @@ export async function createHarness(opts = {}) {
                     `pi_pid_identity=${n?.pi_pid_identity ?? 'null'} status=${n?.status ?? 'null'} ` +
                     `intent=${n?.intent ?? 'null'} pi_session_id=${n?.pi_session_id ?? 'null'} ` +
                     `bootCount=${bootCount(nodeId)} minCount=${minCount}\n`);
+                // Diagnostic (2026-09-03 CI investigation): confirm or rule out the
+                // backoff-gated respawn path (fleet.ts #respawn's `assess` branch)
+                // stranding this row behind a `respawn_not_before` window that never
+                // gets a further h.tick() to clear it, since awaitBoot itself never
+                // ticks. Remove once the real CI failure is diagnosed.
+                process.stderr.write(`[awaitBoot] respawn state: respawn_failures=${n?.respawn_failures ?? 'null'} ` +
+                    `respawn_not_before=${n?.respawn_not_before ?? 'null'} launched_at=${n?.launched_at ?? 'null'} ` +
+                    `last_settled_at=${n?.last_settled_at ?? 'null'} now=${new Date().toISOString()}\n`);
                 // Identity-aware liveness: what does the current process state say about recorded identity?
                 if (n?.pi_pid !== null && n?.pi_pid !== undefined) {
                     const liveness = recordedPidLiveness(n.pi_pid, n.pi_pid_identity);

package/dist/core/__tests__/integration/profile-pause.test.d.ts

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

package/dist/core/__tests__/integration/profile-pause.test.js

@@ -0,0 +1,115 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { contextDir } from '../../canvas/paths.js';
+import { getRow } from '../../canvas/canvas.js';
+import { bashJobPaths, bashJobsDir } from '../../bash-jobs.js';
+import { readCursor } from '../../feed/inbox.js';
+import { transition } from '../../runtime/lifecycle.js';
+import { ensureRootProfile, pauseProfile } from '../../profiles/manifest.js';
+import { createHeadlessHarness } from '../helpers/harness.js';
+function runningJob(nodeId) {
+    const dir = bashJobsDir(contextDir(nodeId));
+    try {
+        for (const jobId of readdirSync(dir)) {
+            const paths = bashJobPaths(contextDir(nodeId), jobId);
+            if (existsSync(paths.jobRun))
+                return paths;
+        }
+    }
+    catch {
+        // The valve has not created its job directory yet.
+    }
+    return undefined;
+}
+test('profile pause backgrounds real bash, retains its inbox cursor, and recovers after a quick resume without failure', { timeout: 120_000 }, async () => {
+    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-profile-pause' });
+    try {
+        const profile = ensureRootProfile();
+        const parent = h.fabricateBrokerNode({ lifecycle: 'resident' });
+        const child = await h.spawnHeadlessChild(parent, 'stay available while the profile pauses', { profile: profile.profileId });
+        h.fakeCmd(child, { cmd: 'bash', command: "sh -c 'sleep 2; printf preserved'" });
+        const job = await h.waitFor(() => runningJob(child), { label: 'valve job.run' });
+        assert.ok(existsSync(job.jobRun), 'the bash valve owns the foreground command before pause');
+        const paused = h.cli(null, ['profile', 'pause', profile.profileId]);
+        assert.equal(paused.code, 0, paused.stderr);
+        await h.tick();
+        assert.equal(h.bootCount(child), 1, 'the lifecycle pass while paused launches no replacement');
+        const retained = h.cli(null, ['node', 'message', 'send', '--to', child, 'mail retained while profile is paused']);
+        assert.equal(retained.code, 0, retained.stderr);
+        const retainedEntry = h.inbox(child).find((entry) => entry.data?.['body'] === 'mail retained while profile is paused');
+        assert.ok(retainedEntry, 'the message was durably appended');
+        assert.equal(readCursor(child), undefined, 'pause leaves the durable inbox cursor unadvanced');
+        const resumed = h.cli(null, ['profile', 'resume', profile.profileId]);
+        assert.equal(resumed.code, 0, resumed.stderr);
+        await h.awaitFleetExit(child);
+        assert.ok(existsSync(job.jobBg), 'SIGTERM atomically handed job.run to job.bg');
+        assert.equal(existsSync(job.jobRun), false, 'the foreground valve ownership is gone');
+        await h.waitFor(() => existsSync(job.jobExit), { label: 'background bash completion' });
+        assert.equal(readFileSync(job.jobExit, 'utf8').trim(), '0', 'the handoff command completed after its broker exited');
+        assert.equal(readCursor(child), undefined, 'neither retained message nor background completion advanced the stopped broker cursor');
+        await h.tick();
+        assert.equal(h.bootCount(child), 1, 'the first resumed policy pass only consumes the pause interruption');
+        assert.equal(getRow(child)?.respawn_failures, 0, 'the intentional SIGTERM never counts as a crash');
+        await h.tick();
+        // `#respawn`'s backoff-assessment defers this exact relaunch on its first
+        // assessment: this node's original spawn (`spawnChild`'s direct
+        // `headlessBrokerHost.launch`) never records `launched_at`, so
+        // `decideRespawnAttempt` can never see `last_settled_at > launched_at` on
+        // this first-ever `#respawn` call for the row and always takes the
+        // `respawn_not_before` backoff branch (fleet.ts's RESPAWN_BACKOFF_BASE_MS,
+        // currently 5s) instead of launching. A THIRD tick, issued once real time
+        // has passed that window, finds `respawn_not_before` already set (so
+        // `#respawn` skips reassessment this time) and actually calls `reviveNode`.
+        // Real-time sleep, not a fake clock: `now()` here is the daemon's real
+        // `Date.now`, so only the wall clock — not another tick — advances it.
+        await new Promise((r) => setTimeout(r, 5_500));
+        await h.tick();
+        await h.awaitBoot(child, { minCount: 2, timeoutMs: 30_000 });
+        const deliveries = await h.awaitWake(child, { match: /mail retained while profile is paused/ });
+        assert.ok(deliveries.some((content) => /mail retained while profile is paused/.test(content)), 'the resumed watcher delivers the retained backlog');
+    }
+    finally {
+        await h.dispose();
+    }
+});
+test('profile pause preserves an idle-release row so mail queued during pause wakes it', { timeout: 120_000 }, async () => {
+    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-profile-pause-idle' });
+    try {
+        const profile = ensureRootProfile();
+        const parent = h.fabricateBrokerNode({ lifecycle: 'resident' });
+        const child = await h.spawnHeadlessChild(parent, 'await ordinary mail', { profile: profile.profileId, lifecycle: 'resident' });
+        transition(child, 'release');
+        const paused = h.cli(null, ['profile', 'pause', profile.profileId]);
+        assert.equal(paused.code, 0, paused.stderr);
+        const queued = h.cli(null, ['node', 'message', 'send', '--to', child, 'ordinary mail queued during pause']);
+        assert.equal(queued.code, 0, queued.stderr);
+        await h.awaitFleetExit(child);
+        const resumed = h.cli(null, ['profile', 'resume', profile.profileId]);
+        assert.equal(resumed.code, 0, resumed.stderr);
+        await h.tick();
+        await h.tick();
+        await h.awaitBoot(child, { minCount: 2, timeoutMs: 60_000 });
+        const deliveries = await h.awaitWake(child, { match: /ordinary mail queued during pause/ });
+        assert.ok(deliveries.some((content) => /ordinary mail queued during pause/.test(content)), 'the idle-release wake is not stranded behind the pause marker');
+    }
+    finally {
+        await h.dispose();
+    }
+});
+test('lifecycle catches a broker that became live after the pause command fast scan', { timeout: 60_000 }, async () => {
+    const h = await createHeadlessHarness({ sessionPrefix: 'crtr-profile-pause-race' });
+    try {
+        const profile = ensureRootProfile();
+        const parent = h.fabricateBrokerNode({ lifecycle: 'resident' });
+        const child = await h.spawnHeadlessChild(parent, 'broker launched after pause scan', { profile: profile.profileId });
+        pauseProfile(profile.profileId);
+        await h.tick();
+        await h.awaitFleetExit(child);
+        assert.equal(h.bootCount(child), 1, 'the paused lifecycle tick terminates the late live broker instead of leaving it running');
+        assert.equal(getRow(child)?.respawn_failures, 0, 'the late broker interruption has no failure cost');
+    }
+    finally {
+        await h.dispose();
+    }
+});

package/dist/core/__tests__/node-outcome.test.d.ts

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

package/dist/core/__tests__/node-outcome.test.js

@@ -0,0 +1,184 @@
+import { after, afterEach, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { DatabaseSync } from 'node:sqlite';
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { closeDb, MIGRATIONS } from '../canvas/db.js';
+import { createNode, getRow } from '../canvas/canvas.js';
+import { armOutcomeDelivery, claimOutcomeDelivery, outcomeDeliveryBackoffMs, readOutcomeDelivery, recoverRunningOutcomeDeliveries, settleOutcomeDelivery, } from '../canvas/node-outcome-deliveries.js';
+import { transition } from '../runtime/lifecycle.js';
+import { composeNodeOutcomeDocument } from '../runtime/outcome-document.js';
+import { pushFinal } from '../feed/feed.js';
+import { OUTCOME_PAYLOAD_MAX_BYTES } from '../canvas/types.js';
+let home;
+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',
+    };
+}
+beforeEach(() => {
+    closeDb();
+    home = mkdtempSync(join(tmpdir(), 'crtr-node-outcome-'));
+    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('the terminal outcome latch survives competing terminal transitions and revive', () => {
+    createNode(node('latched'));
+    transition('latched', 'finish');
+    transition('latched', 'cancel');
+    let row = getRow('latched');
+    assert.deepEqual({ kind: row.outcome_kind, reason: row.outcome_reason, revision: row.outcome_revision }, {
+        kind: 'failure', reason: 'finished', revision: 1,
+    });
+    transition('latched', 'revive');
+    row = getRow('latched');
+    assert.equal(row.outcome_at === null, false, 'revive must not clear a latched outcome');
+    assert.equal(row.outcome_revision, 1);
+});
+test('outcome detail keeps only a 500-byte first line', () => {
+    createNode(node('detail'));
+    transition('detail', 'crash', {
+        outcome: { detail: { schema: 'crtr.node-outcome-detail/v1', message: `${'x'.repeat(1_000)}\nignored` } },
+    });
+    const detail = JSON.parse(getRow('detail').outcome_detail_json);
+    assert.equal(Buffer.byteLength(detail.message, 'utf8'), 500);
+    assert.equal(detail.message.includes('\n'), false);
+});
+test('the outcome composer is total and omits an oversized structured result', () => {
+    const meta = node('document');
+    meta.description = 'x'.repeat(2 * 1024);
+    createNode(meta);
+    const document = composeNodeOutcomeDocument({
+        node: meta,
+        outcome: { kind: 'result', reason: 'finalized', at: new Date().toISOString(), revision: 1, detailJson: null },
+        action: { name: 'test-action', payload: { callback: 'one' } },
+        finalReport: 'final.md',
+        structuredResult: { value: 'y'.repeat(300 * 1024) },
+    });
+    assert.ok(Buffer.byteLength(JSON.stringify(document), 'utf8') <= 256 * 1024);
+    assert.equal(Buffer.byteLength(document.node.description, 'utf8') <= 1024, true);
+    assert.equal(document.result?.structuredResult, undefined);
+    assert.equal(document.result?.structuredResultOmitted, true);
+});
+test('the outcome composer caps a failure document with an oversized node name', () => {
+    const meta = node('failure-document');
+    meta.name = 'x'.repeat(300 * 1024);
+    const document = composeNodeOutcomeDocument({
+        node: meta,
+        outcome: { kind: 'failure', reason: 'crashed', at: new Date().toISOString(), revision: 1, detailJson: null },
+        action: { name: 'test-action', payload: { callback: 'one' } },
+    });
+    assert.ok(Buffer.byteLength(JSON.stringify(document), 'utf8') <= 256 * 1024);
+    assert.ok(Buffer.byteLength(document.node.name, 'utf8') <= 1024);
+    assert.equal(document.result, undefined);
+    assert.ok(document.failure);
+});
+test('a canonical final supersedes a prior failure outcome and increments revision', async () => {
+    createNode(node('supersede'));
+    transition('supersede', 'crash');
+    transition('supersede', 'revive');
+    await pushFinal('supersede', 'recovered and finished');
+    const row = getRow('supersede');
+    assert.deepEqual({ kind: row.outcome_kind, reason: row.outcome_reason, revision: row.outcome_revision }, {
+        kind: 'result', reason: 'finalized', revision: 2,
+    });
+    assert.equal(row.outcome_detail_json, null);
+});
+test('outcome delivery rejects an oversized payload before a node is armed', () => {
+    createNode(node('oversized-payload'));
+    assert.throws(() => armOutcomeDelivery({
+        nodeId: 'oversized-payload', actionName: 'test-action', argv: ['/bin/true'], cwd: home, configOrigin: 'test', payload: { value: 'x'.repeat(OUTCOME_PAYLOAD_MAX_BYTES) },
+    }), /exceeds/);
+    assert.equal(readOutcomeDelivery('oversized-payload'), null);
+});
+test('outcome delivery armed after settlement is born pending with its document', () => {
+    createNode(node('settled-delivery'));
+    transition('settled-delivery', 'crash');
+    const delivery = armOutcomeDelivery({
+        nodeId: 'settled-delivery', actionName: 'test-action', argv: ['/bin/true'], cwd: home, configOrigin: 'test', payload: { callback: 'one' }, now: 123,
+    });
+    assert.equal(delivery?.state, 'pending');
+    assert.equal(delivery?.nextAttemptAt, 123);
+    assert.deepEqual(delivery?.document && {
+        schema: delivery.document.schema,
+        outcomeId: delivery.document.outcomeId,
+        action: delivery.document.action,
+    }, {
+        schema: 'crtr.node-outcome/v1',
+        outcomeId: 'settled-delivery:1',
+        action: { name: 'test-action', payload: { callback: 'one' } },
+    });
+});
+test('outcome delivery state is fenced, recoverable, and follows the durable backoff', () => {
+    createNode(node('delivery'));
+    assert.ok(armOutcomeDelivery({
+        nodeId: 'delivery', actionName: 'test-action', argv: ['/bin/true'], cwd: home, configOrigin: 'test', payload: { callback: 'one' }, now: 100,
+    }));
+    transition('delivery', 'crash');
+    assert.equal(readOutcomeDelivery('delivery')?.state, 'pending');
+    assert.ok(readOutcomeDelivery('delivery')?.document, 'the armed row is stamped with its outcome document');
+    const first = claimOutcomeDelivery('delivery', Date.now(), 'daemon-a');
+    assert.equal(first.state, 'running');
+    assert.equal(settleOutcomeDelivery('delivery', first.attempt, 'daemon-b', { state: 'accepted' }, Date.now()), false, 'a stale claimant cannot settle');
+    assert.equal(settleOutcomeDelivery('delivery', first.attempt, 'daemon-a', { state: 'accepted' }, Date.now()), true);
+    assert.equal(readOutcomeDelivery('delivery')?.state, 'accepted');
+    createNode(node('recover'));
+    armOutcomeDelivery({ nodeId: 'recover', actionName: 'test-action', argv: ['/bin/true'], cwd: home, configOrigin: 'test', now: 100 });
+    transition('recover', 'crash');
+    const running = claimOutcomeDelivery('recover', Date.now(), 'daemon-a');
+    assert.equal(running.state, 'running');
+    const recoveredAt = Date.now();
+    assert.equal(recoverRunningOutcomeDeliveries(recoveredAt), 1);
+    assert.deepEqual(readOutcomeDelivery('recover') && {
+        state: readOutcomeDelivery('recover').state,
+        nextAttemptAt: readOutcomeDelivery('recover').nextAttemptAt,
+        claimOwner: readOutcomeDelivery('recover').claimOwner,
+    }, { state: 'pending', nextAttemptAt: recoveredAt, claimOwner: null });
+    assert.equal(outcomeDeliveryBackoffMs(1), 5_000);
+    assert.equal(outcomeDeliveryBackoffMs(2), 10_000);
+    assert.equal(outcomeDeliveryBackoffMs(3), 20_000);
+    assert.equal(outcomeDeliveryBackoffMs(11), 3_600_000);
+    assert.equal(outcomeDeliveryBackoffMs(100), 3_600_000);
+});
+test('v39 migrates a v38 database and backfills finalized and terminal rows', () => {
+    const dbPath = join(home, 'v38.db');
+    mkdirSync(join(home, 'nodes'), { recursive: true });
+    const db = new DatabaseSync(dbPath);
+    db.exec('PRAGMA foreign_keys = ON;');
+    for (const migration of MIGRATIONS.slice(0, 38))
+        migration(db);
+    db.prepare(`INSERT INTO nodes (node_id, name, kind, mode, lifecycle, status, cwd, created, final_report, finalized_at, terminal_reason)
+    VALUES (?, ?, 'general', 'base', 'terminal', ?, ?, ?, ?, ?, ?)`)
+        .run('finalized', 'finalized', 'done', home, '2026-01-01T00:00:00.000Z', 'report.md', '2026-01-01T01:00:00.000Z', 'finalized');
+    db.prepare(`INSERT INTO nodes (node_id, name, kind, mode, lifecycle, status, cwd, created, terminal_reason)
+    VALUES (?, ?, 'general', 'base', 'terminal', ?, ?, ?, ?)`)
+        .run('dead', 'dead', 'dead', home, '2026-01-02T00:00:00.000Z', 'crashed');
+    MIGRATIONS[38](db);
+    const rows = db.prepare('SELECT node_id, outcome_kind, outcome_reason, outcome_at, outcome_revision FROM nodes ORDER BY node_id').all().map((row) => ({ ...row }));
+    assert.deepEqual(rows, [
+        { node_id: 'dead', outcome_kind: 'failure', outcome_reason: 'crashed', outcome_at: '2026-01-02T00:00:00.000Z', outcome_revision: 1 },
+        { node_id: 'finalized', outcome_kind: 'result', outcome_reason: 'finalized', outcome_at: '2026-01-01T01:00:00.000Z', outcome_revision: 1 },
+    ]);
+    assert.ok(db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'node_outcome_deliveries'").get());
+    assert.ok(db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = 'idx_nodes_deadline'").get());
+    db.close();
+});

package/dist/core/__tests__/revive-parked-fresh.test.js

@@ -1,17 +1,10 @@
 // Run with: node --conditions=crtr-src --import tsx/esm --test src/core/__tests__/revive-parked-fresh.test.ts
 //
-// Re-entering a parked node starts a FRESH cycle grounded in goal + roadmap
-// rather than replaying the transcript its parking turn already concluded —
-// but only when the revival CARRIES NEW INPUT. Wake-worthy mail that the node
-// has not seen is that input: every doorway that wakes a parked node because
-// something arrived appends its durable inbox entry before calling in. An
-// input-less revival (a bare lifecycle revive, a viewer attach, a focus) has
-// nothing to answer, so it quietly resumes the old transcript and injects no
-// kickoff. The rule is a property of the node, evaluated once inside
-// reviveNode, so every doorway gets it from one strict-resume veto. Its other
-// exception is a park with nothing on disk to stand on (reachable only on the
-// degraded path, which writes no summary): resuming an old transcript beats
-// waking amnesiac.
+// Re-entering a parked node resumes its main transcript: the isolated parking
+// turn never wrote to it. Wake-worthy mail remains durable for the inbox watcher
+// to deliver after boot; it does not create a fresh-cycle kickoff. An input-less
+// revival likewise resumes quietly. The rule is a property of the node,
+// evaluated once inside reviveNode, so every doorway gets it uniformly.
 import { after, afterEach, before, beforeEach, test } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
@@ -103,23 +96,23 @@ after(() => {
     else
         process.env['CRTR_HOME'] = priorHome;
 });
-test('a parked node with mail waiting re-enters fresh even when the caller asked to resume, and the marker clears', async () => {
+test('a parked node with mail waiting resumes its main transcript and clears the marker', async () => {
     parkResident('parked', { roadmap: '# Roadmap\n\n- one open item\n' });
     deliverMail('parked');
     const result = await reviveNode('parked', { resume: true, capacity: 'freeze' });
-    assert.equal(result.resumed, false, 'the concluded transcript is not replayed');
-    assert.deepEqual(placements(), [{ nodeId: 'parked', resuming: false }]);
-    assert.equal(kickedOff(launches[0]), true, 'the fresh window is handed its bearings');
+    assert.equal(result.resumed, true, 'the isolated parking turn never concluded the main transcript');
+    assert.deepEqual(placements(), [{ nodeId: 'parked', resuming: true }]);
+    assert.equal(kickedOff(launches[0]), false, 'the inbox watcher delivers the mail after the resumed boot');
     const reopened = getNode('parked');
     assert.equal(reopened.status, 'active');
     assert.equal(reopened.intent ?? null, null, 'the park marker clears on revival');
-    assert.equal(reopened.cycle_pending, true, 'the fresh cycle is provisional until session_start confirms it');
+    assert.equal(reopened.cycle_pending, false, 'a strict resume does not open a new cycle');
 });
-test('a parked node grounded only by a goal still re-enters fresh when mail rides the revive', async () => {
+test('a parked node grounded only by a goal still resumes when mail rides the revive', async () => {
     parkResident('goal-only', { goal: 'Watch the deploy lane.' });
     deliverMail('goal-only');
-    assert.equal((await reviveNode('goal-only', { resume: true, capacity: 'freeze' })).resumed, false);
-    assert.equal(kickedOff(launches[0]), true);
+    assert.equal((await reviveNode('goal-only', { resume: true, capacity: 'freeze' })).resumed, true);
+    assert.equal(kickedOff(launches[0]), false);
 });
 test('an input-less revival of a parked node quietly resumes and injects no kickoff', async () => {
     parkResident('quiet', { roadmap: '# Roadmap\n\n- one open item\n' });

package/dist/core/__tests__/seam/broker-provider-retry.test.js

@@ -394,7 +394,11 @@ test('reload_auth restores a newly authenticated personal route before the next
     const unauthenticatedProvider = join(h.home, 'fake-pi.unauthenticated-provider');
     mkdirSync(userConfigDir, { recursive: true });
     writeFileSync(userConfigPath, JSON.stringify({
-        kinds: { general: { whenToUse: 'General work.', model: 'anthropic/medium' } },
+        // A fixture-private kind, never `general`: the child launches with the
+        // package root as cwd, so an ambient project-scope config above the repo
+        // (`~/.crouter/config.json`) overrides this user-scope `general` and the
+        // child boots on that machine's default strength instead of medium.
+        kinds: { 'test/logical-anthropic': { whenToUse: 'Logical Anthropic routing test.', model: 'anthropic/medium' } },
         modelRoutes: {
             personal: { family: 'anthropic', credentialSource: 'user', providerId: personal.provider, models: { ultra: personalSpec, strong: personalSpec, medium: personalSpec, light: personalSpec } },
             funded: { family: 'anthropic', credentialSource: 'northlight', providerId: funded.provider, models: { ultra: `${funded.provider}/${funded.id}:medium`, strong: `${funded.provider}/${funded.id}:medium`, medium: `${funded.provider}/${funded.id}:medium`, light: `${funded.provider}/${funded.id}:medium` } },
@@ -404,7 +408,7 @@ test('reload_auth restores a newly authenticated personal route before the next
     writeFileSync(unauthenticatedProvider, personal.provider);
     try {
         const parent = h.spawnRoot('auth route reconciliation parent');
-        const child = await h.spawnHeadlessChild(parent, 'auth route reconciliation child');
+        const child = await h.spawnHeadlessChild(parent, 'auth route reconciliation child', { kind: 'test/logical-anthropic' });
         assert.deepEqual(model(child), funded, 'the logical request starts on the funded route while personal auth is absent');
         const controller = await kit.connectRaw(child, { read: true });
         controller.send({ type: 'hello', role: 'controller', client_id: 'auth-route-reconciliation' });

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

@@ -175,7 +175,7 @@ test('an unattended resident with no live obligation completes on the daemon clo
         await reviveNode(nodeId, { resume: true, capacity: 'freeze' });
         const boot = await h.awaitBoot(nodeId);
         assert.equal(h.fleet.has(nodeId), true, 'the revived broker is fleet-owned');
-        const seenAt = 10_000;
+        const seenAt = Date.now();
         await h.tick(seenAt);
         await h.tick(seenAt + 1499);
         assert.equal(h.fleet.has(nodeId), true, 'the daemon keeps the broker through the full grace');
@@ -228,7 +228,7 @@ test('a non-attending observer does not prevent unattended resident parking', {
     await attach.attach(nodeId, 'observer', 'system-observer-test', { attends: false });
     assert.equal(JSON.parse(readFileSync(join(h.home, 'nodes', nodeId, 'job', 'attach.json'), 'utf8')).viewers, 0, 'a non-attending hello is not persisted as human attendance');
     try {
-        const seenAt = 12_000;
+        const seenAt = Date.now();
         await h.tick(seenAt);
         await h.tick(seenAt + 1500);
         await h.tick(seenAt + 1500 + 1000);
@@ -383,7 +383,7 @@ test('a resident managed child parks without finalizing while a terminal child i
         };
         const residentPid = await boot(resident);
         const terminalPid = await boot(terminal);
-        const seenAt = 50_000;
+        const seenAt = Date.now();
         await h.tick(seenAt);
         // Clock expiry arms the resident's pending park and requests its summary
         // turn; the terminal child is cancelled outright by the same pass.

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

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