@north-light/crouter 0.3.311 → 0.3.313

package/dist/core/__tests__/boot-fault-attempt.test.js

@@ -6,19 +6,37 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { beginBootFaultAttempt, recordFault } from '../runtime/fault.js';
+import { createNode } from '../canvas/canvas.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { beginBootFaultAttempt, recordFault } from '../canvas/recovery.js';
 let home;
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-boot-fault-attempt-'));
     process.env['CRTR_HOME'] = home;
 });
 beforeEach(() => {
+    closeDb();
     rmSync(home, { recursive: true, force: true });
+    migrate(openDb());
 });
 after(() => {
+    closeDb();
     rmSync(home, { recursive: true, force: true });
 });
+function node(nodeId) {
+    return {
+        node_id: nodeId,
+        name: nodeId,
+        created: new Date().toISOString(),
+        cwd: home,
+        kind: 'general',
+        mode: 'base',
+        lifecycle: 'terminal',
+        status: 'active',
+    };
+}
 test('a fatal crtr→pi fault recorded after the snapshot is surfaced', { timeout: 1_000 }, () => {
+    createNode(node('node-a'));
     const attempt = beginBootFaultAttempt('node-a');
     recordFault('node-a', {
         link: 'crtr→pi',
@@ -30,6 +48,7 @@ test('a fatal crtr→pi fault recorded after the snapshot is surfaced', { timeou
     assert.equal(attempt.explanation(), "model resolution at launch: model 'bogus' has no 'provider/id' form and cannot be resolved");
 });
 test('a stale fault already present at snapshot time is never surfaced, even if a matching-shape fault is written afterward (fail closed)', { timeout: 1_000 }, () => {
+    createNode(node('node-b'));
     // A prior attempt's fault survives clearFault's best-effort removal (its own
     // errors are swallowed and unchecked by callers) — the exact failure mode
     // the diagnostic must not be fooled by.
@@ -56,10 +75,12 @@ test('a stale fault already present at snapshot time is never surfaced, even if
     assert.equal(attempt.explanation(), null, 'a fault present before this attempt began must fail closed, not surface any cause');
 });
 test('no fault recorded at all yields no explanation', { timeout: 1_000 }, () => {
+    createNode(node('node-c'));
     const attempt = beginBootFaultAttempt('node-c');
     assert.equal(attempt.explanation(), null);
 });
 test('an unrelated fault (wrong link, or non-fatal) is never surfaced as a boot cause', { timeout: 1_000 }, () => {
+    createNode(node('node-d'));
     const attempt = beginBootFaultAttempt('node-d');
     recordFault('node-d', {
         link: 'viewer↔broker',
@@ -71,6 +92,7 @@ test('an unrelated fault (wrong link, or non-fatal) is never surfaced as a boot
     assert.equal(attempt.explanation(), null);
 });
 test('a fault with an empty operation or message falls back to null rather than an empty diagnosis', { timeout: 1_000 }, () => {
+    createNode(node('node-e'));
     const attempt = beginBootFaultAttempt('node-e');
     recordFault('node-e', {
         link: 'crtr→pi',

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

@@ -17,8 +17,9 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { createNode, getRow, recordPid, migrateLegacyPidIdentities } from '../canvas/canvas.js';
-import { closeDb, openDb } from '../canvas/db.js';
+import { createNode, getRow } from '../canvas/canvas.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { beginExecution, migrateLegacyExecutionIdentities, recordExecutionPid } from '../canvas/executions.js';
 import { bootChanged, bootProvenSame, reconcileBootLiveness, reconcileAndMigrateBoot, } from '../canvas/boot.js';
 let home;
 /** Build a BootIdentity for injection. `bootId` null models the non-Linux
@@ -27,11 +28,16 @@ function ident(bootId, bootEpochMs) {
     return { bootId, bootEpochMs };
 }
 const BOOT_A = '4b0c1d2e-3f40-4152-8637-a1b2c3d4e5f6';
-/** Force a row's recorded pid + identity baseline directly (recordPid derives
- *  the identity from the real `ps`, which can't produce a controlled legacy
- *  `lstart#ticks` value on a non-Linux test host). */
+/** Create a running execution with a controlled legacy identity. */
 function setPidIdentity(id, pid, identity) {
-    openDb().prepare('UPDATE nodes SET pi_pid = ?, pi_pid_identity = ? WHERE node_id = ?').run(pid, identity, id);
+    const executionId = beginExecution(id, { daemonEpoch: 'test' });
+    recordExecutionPid(executionId, id, pid);
+    openDb().prepare('UPDATE executions SET process_identity = ? WHERE execution_id = ?').run(identity, executionId);
+    return executionId;
+}
+function recordExecution(id, pid) {
+    const executionId = beginExecution(id, { daemonEpoch: 'test' });
+    recordExecutionPid(executionId, id, pid);
 }
 function node(id, over = {}) {
     return {
@@ -53,6 +59,7 @@ before(() => {
 beforeEach(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
+    migrate(openDb());
 });
 after(() => {
     closeDb();
@@ -86,18 +93,18 @@ test('bootChanged: wall-clock fallback (no boot_id) — epochs far apart are a D
 // migrateLegacyPidIdentities — one-time in-place format migration at startup
 test('migrateLegacyPidIdentities: a live legacy lstart#ticks broker is re-recorded to <bootId>#<ticks>', () => {
     createNode(node('n1'));
-    setPidIdentity('n1', 111, 'Sat Jul 11 17:51:45 2026#53459'); // legacy baseline
+    const executionId = setPidIdentity('n1', 111, 'Sat Jul 11 17:51:45 2026#53459'); // legacy baseline
     // The pid still names the same live process; its CURRENT identity on this
     // (now boot_id-capable) platform reads bootId#ticks with the SAME ticks.
-    const result = migrateLegacyPidIdentities((pid) => (pid === 111 ? `${BOOT_A}#53459` : undefined));
-    assert.deepEqual(result.migrated, ['n1']);
+    const result = migrateLegacyExecutionIdentities((pid) => (pid === 111 ? `${BOOT_A}#53459` : undefined));
+    assert.deepEqual(result.migrated, [executionId]);
     assert.equal(getRow('n1')?.pi_pid_identity, `${BOOT_A}#53459`, 'legacy row completed to boot-scoped format');
     assert.equal(getRow('n1')?.pi_pid, 111, 'the pid itself is untouched');
 });
 test('migrateLegacyPidIdentities: a legacy row whose pid is GONE is left to normal liveness handling', () => {
     createNode(node('n1'));
     setPidIdentity('n1', 111, 'Sat Jul 11 17:51:45 2026#53459');
-    const result = migrateLegacyPidIdentities(() => undefined); // pid gone / probe failed
+    const result = migrateLegacyExecutionIdentities(() => undefined); // pid gone / probe failed
     assert.deepEqual(result.migrated, []);
     assert.equal(getRow('n1')?.pi_pid_identity, 'Sat Jul 11 17:51:45 2026#53459', 'untouched — liveness handles it');
 });
@@ -105,7 +112,7 @@ test('migrateLegacyPidIdentities: a REUSED pid (different ticks) is NOT re-recor
     createNode(node('n1'));
     setPidIdentity('n1', 111, 'Sat Jul 11 17:51:45 2026#53459');
     // The pid now names a DIFFERENT process (different jiffies) — no match.
-    const result = migrateLegacyPidIdentities(() => `${BOOT_A}#99999`);
+    const result = migrateLegacyExecutionIdentities(() => `${BOOT_A}#99999`);
     assert.deepEqual(result.migrated, []);
     assert.equal(getRow('n1')?.pi_pid_identity, 'Sat Jul 11 17:51:45 2026#53459', 'reused pid left for liveness to clear');
 });
@@ -113,7 +120,7 @@ test('migrateLegacyPidIdentities: an already boot-scoped row is skipped (not leg
     createNode(node('n1'));
     setPidIdentity('n1', 111, `${BOOT_A}#53459`); // already new-format
     let captured = false;
-    const result = migrateLegacyPidIdentities(() => {
+    const result = migrateLegacyExecutionIdentities(() => {
         captured = true;
         return `${BOOT_A}#53459`;
     });
@@ -125,14 +132,14 @@ test('migrateLegacyPidIdentities: no readable boot_id (current identity still le
     setPidIdentity('n1', 111, 'Sat Jul 11 17:51:45 2026#53459');
     // Platform still composes legacy-shaped identities (no boot_id) — nothing to
     // upgrade to; the legacy compare lane legitimately stays in play.
-    const result = migrateLegacyPidIdentities(() => 'Sun Jul 12 09:00:00 2026#53459');
+    const result = migrateLegacyExecutionIdentities(() => 'Sun Jul 12 09:00:00 2026#53459');
     assert.deepEqual(result.migrated, []);
     assert.equal(getRow('n1')?.pi_pid_identity, 'Sat Jul 11 17:51:45 2026#53459', 'no boot_id → not migrated');
 });
 test('reconcileBootLiveness: first-ever call seeds the marker and clears nothing', () => {
     const m = node('n1');
     createNode(m);
-    recordPid('n1', 12345);
+    recordExecution('n1', 12345);
     const result = reconcileBootLiveness(ident('boot-A', 1_000_000));
     assert.deepEqual(result, { changed: false, cleared: [], sameBootProven: false });
     assert.equal(getRow('n1')?.pi_pid, 12345, 'a first-ever run never clears an existing pid');
@@ -140,7 +147,7 @@ test('reconcileBootLiveness: first-ever call seeds the marker and clears nothing
 test('reconcileBootLiveness: same boot (same boot_id) leaves pids untouched — MUST NOT weaken the normal daemon-restart case', () => {
     const m = node('n1');
     createNode(m);
-    recordPid('n1', 12345);
+    recordExecution('n1', 12345);
     reconcileBootLiveness(ident('boot-A', 1_000_000)); // seed
     const result = reconcileBootLiveness(ident('boot-A', 1_000_000 + 3_000)); // 3s later, same boot
     assert.deepEqual(result, { changed: false, cleared: [], sameBootProven: true });
@@ -153,9 +160,9 @@ test('reconcileBootLiveness: a boot change clears every recorded pid, regardless
     const noPid = node('no-pid-1', { status: 'active' });
     for (const m of [active, idle, dead, noPid])
         createNode(m);
-    recordPid('active-1', 111);
-    recordPid('idle-1', 222);
-    recordPid('dead-1', 333);
+    recordExecution('active-1', 111);
+    recordExecution('idle-1', 222);
+    recordExecution('dead-1', 333);
     // no-pid-1 deliberately left without a recorded pid.
     reconcileBootLiveness(ident('boot-A', 1_000_000)); // seed boot A
     const result = reconcileBootLiveness(ident('boot-B', 1_000_000 + 60 * 60_000)); // boot B
@@ -169,7 +176,7 @@ test('reconcileBootLiveness: a boot change clears every recorded pid, regardless
 test('reconcileBootLiveness: a fast recreate (distinct boot_id, 42s wall) still sweeps (Major-2 regression)', () => {
     const m = node('n1');
     createNode(m);
-    recordPid('n1', 111);
+    recordExecution('n1', 111);
     reconcileBootLiveness(ident('boot-A', 1_000_000)); // seed boot A
     const result = reconcileBootLiveness(ident('boot-B', 1_000_000 + 42_000)); // 42s later — inside the wall window, but new boot_id
     assert.equal(result.changed, true, 'distinct boot_id detected even 42s apart');
@@ -179,10 +186,10 @@ test('reconcileBootLiveness: a fast recreate (distinct boot_id, 42s wall) still
 test('reconcileBootLiveness: after reconciling, the SAME boot no longer re-triggers (idempotent)', () => {
     const m = node('n1');
     createNode(m);
-    recordPid('n1', 111);
+    recordExecution('n1', 111);
     reconcileBootLiveness(ident('boot-A', 1_000_000)); // seed boot A
     reconcileBootLiveness(ident('boot-B', 1_000_000 + 60 * 60_000)); // boot change → clears + persists boot B
-    recordPid('n1', 999); // a fresh broker re-records its pid post-revive
+    recordExecution('n1', 999); // a fresh broker re-records its pid post-revive
     const result = reconcileBootLiveness(ident('boot-B', 1_000_000 + 60 * 60_000 + 2_000)); // still boot B, 2s later
     assert.deepEqual(result, { changed: false, cleared: [], sameBootProven: true });
     assert.equal(getRow('n1')?.pi_pid, 999, 'a pid recorded AFTER reconciliation, within the same boot, is never touched');
@@ -214,7 +221,7 @@ test('bootProvenSame: a different boot_id is not proof (it is a change)', () =>
 // revert that inverts/drops the gate or reorders migration ahead of
 // reconciliation is caught here. `runDaemon` calls this same helper.
 function daemonBootStartup(current, captureIdentity) {
-    return reconcileAndMigrateBoot(migrateLegacyPidIdentities, current, captureIdentity);
+    return reconcileAndMigrateBoot(migrateLegacyExecutionIdentities, current, captureIdentity);
 }
 const LEGACY = 'Sat Jul 11 17:51:45 2026#53459';
 test('migration gate: a cross-boot equal-ticks legacy row is NOT migrated when the marker is ABSENT (first-ever startup)', () => {
@@ -240,12 +247,12 @@ test('migration gate: a cross-boot equal-ticks legacy row is NOT migrated under
 });
 test('migration gate: a legacy row IS migrated when same-boot provenance is PROVEN (exact boot_id match)', () => {
     createNode(node('n1'));
-    setPidIdentity('n1', 111, LEGACY);
+    const executionId = setPidIdentity('n1', 111, LEGACY);
     reconcileBootLiveness(ident(BOOT_A, 1_000_000)); // seed an exact-boot_id marker
     // Same boot proven (boot_id equal on both sides); pid 111 still names the same
     // live process (matching ticks) — the in-place upgrade completes.
     const result = daemonBootStartup(ident(BOOT_A, 1_000_000 + 3_000), (pid) => pid === 111 ? `${BOOT_A}#53459` : undefined);
-    assert.deepEqual(result.migrated, ['n1']);
+    assert.deepEqual(result.migrated, [executionId]);
     assert.equal(getRow('n1')?.pi_pid_identity, `${BOOT_A}#53459`, 'proven same boot → migrated in place');
 });
 test('migrateLegacyPidIdentities CAS: a concurrent re-record between probe and update is not clobbered', () => {
@@ -254,7 +261,7 @@ test('migrateLegacyPidIdentities CAS: a concurrent re-record between probe and u
     // The capture models the old broker still probing as its live legacy self,
     // but a concurrent revive atomically re-records a FRESH (pid, identity) pair
     // before the sweep's compare-and-swap update lands.
-    const result = migrateLegacyPidIdentities((pid) => {
+    const result = migrateLegacyExecutionIdentities((pid) => {
         if (pid === 111) {
             setPidIdentity('n1', 222, `${BOOT_A}#77777`); // concurrent revive wins the row
             return `${BOOT_A}#53459`; // stale probe result for the OLD pid

package/dist/core/__tests__/broker-launch-candidates.test.js

@@ -6,20 +6,43 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createAgentSessionFromServices, createAgentSessionServices, SessionManager, VERSION } from '../runtime/broker-sdk.js';
 import { buildBrokerSession } from '../runtime/broker.js';
+import { createNode } from '../canvas/canvas.js';
+import { beginExecution } from '../canvas/executions.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { ensureScopeInitialized } from '../config.js';
 import { unregisteredConcreteModel } from '../model-routes.js';
+import { closeScopedStores } from '../scoped-state/db.js';
+import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
+import { resetScopeCache } from '../scope.js';
+import { piAgentDir } from '../runtime/package-health.js';
+import { createApiServer } from '../../daemon/api/server.js';
 import { isUnknownModel } from '../runtime/model-selection.js';
 import { resolveProviderCandidates } from '../subscription-state.js';
 const realEngine = { createAgentSessionServices, createAgentSessionFromServices, SessionManager, VERSION };
 const C3_EXT = join(dirname(fileURLToPath(import.meta.url)), 'fixtures', 'c3-custom-provider-ext.ts');
 const previousModelIntent = process.env['CRTR_MODEL_INTENT'];
+const previousHome = process.env['HOME'];
+let home;
 before(() => {
     delete process.env['CRTR_MODEL_INTENT'];
+    home = mkdtempSync(join(tmpdir(), 'crtr-launch-candidate-home-'));
+    process.env['HOME'] = home;
+    resetScopeCache();
+    ensureScopeInitialized('user', join(home, '.crouter'));
+    initializeFreshScopedStore({ kind: 'provider', root: piAgentDir() });
 });
 after(() => {
+    closeScopedStores();
+    rmSync(home, { recursive: true, force: true });
     if (previousModelIntent === undefined)
         delete process.env['CRTR_MODEL_INTENT'];
     else
         process.env['CRTR_MODEL_INTENT'] = previousModelIntent;
+    if (previousHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = previousHome;
+    resetScopeCache();
 });
 const requested = { provider: 'anthropic', id: 'requested' };
 const alternative = { provider: 'openai-codex', id: 'alternative' };
@@ -121,6 +144,18 @@ test('launch candidate resolver selects a non-managed candidate as automatic fal
 });
 test('broker launch rejects an unregistered concrete model even when a non-managed provider is available', async () => {
     const cwd = mkdtempSync(join(tmpdir(), 'crtr-launch-candidate-'));
+    const priorCanvasHome = process.env['CRTR_HOME'];
+    const priorNodeId = process.env['CRTR_NODE_ID'];
+    const priorExecutionId = process.env['CRTR_EXECUTION_ID'];
+    const nodeId = 'launch-candidate';
+    closeDb();
+    process.env['CRTR_HOME'] = home;
+    process.env['CRTR_NODE_ID'] = nodeId;
+    migrate(openDb());
+    createNode({ node_id: nodeId, name: nodeId, created: new Date().toISOString(), cwd, kind: 'developer', mode: 'base', lifecycle: 'resident', status: 'active' });
+    process.env['CRTR_EXECUTION_ID'] = beginExecution(nodeId, { daemonEpoch: 'test' });
+    const server = createApiServer();
+    await server.ready;
     try {
         const engine = {
             ...realEngine,
@@ -139,6 +174,20 @@ test('broker launch rejects an unregistered concrete model even when a non-manag
         await assert.rejects(buildBrokerSession(engine, { cwd, extensionPaths: [C3_EXT], model: 'missing/missing' }), /FATAL: model 'missing\/missing' is not registered/);
     }
     finally {
+        await server.close();
+        closeDb();
+        if (priorCanvasHome === undefined)
+            delete process.env['CRTR_HOME'];
+        else
+            process.env['CRTR_HOME'] = priorCanvasHome;
+        if (priorNodeId === undefined)
+            delete process.env['CRTR_NODE_ID'];
+        else
+            process.env['CRTR_NODE_ID'] = priorNodeId;
+        if (priorExecutionId === undefined)
+            delete process.env['CRTR_EXECUTION_ID'];
+        else
+            process.env['CRTR_EXECUTION_ID'] = priorExecutionId;
         rmSync(cwd, { recursive: true, force: true });
     }
 });