@north-light/crouter 0.3.311 → 0.3.313

package/dist/core/__tests__/revive-all.test.js

@@ -32,7 +32,9 @@ import { join } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { isDisconnected, TERMINAL_BY_CHOICE, listDisconnected } from '../runtime/revive-all.js';
 import { createNode } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { beginExecution, recordExecutionPid } from '../canvas/executions.js';
+import { bindSession } from '../canvas/sessions.js';
 const ALIVE = () => true;
 const DEAD = () => false;
 function meta(over = {}) {
@@ -105,6 +107,7 @@ function deadPid() {
     return r.pid ?? 0x7ffffffe;
 }
 function fabricate(id, over) {
+    const { pi_pid, pi_session_id = `uuid-${id}`, pi_session_file = null, ...node } = over;
     createNode({
         node_id: id,
         name: id,
@@ -115,9 +118,15 @@ function fabricate(id, over) {
         mode: 'base',
         lifecycle: 'terminal',
         status: 'active',
-        pi_session_id: 'uuid-' + id,
-        ...over,
+        ...node,
     });
+    const executionId = beginExecution(id, { daemonEpoch: 'test' });
+    if (pi_session_id !== null || pi_session_file !== null) {
+        assert.equal(bindSession(id, { executionId, sessionId: pi_session_id, transcriptPath: pi_session_file }), 'bound');
+    }
+    if (pi_pid !== null && pi_pid !== undefined) {
+        assert.equal(recordExecutionPid(executionId, id, pi_pid), 'recorded');
+    }
     closeDb();
 }
 before(() => {
@@ -127,6 +136,7 @@ before(() => {
 beforeEach(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
+    migrate(openDb());
 });
 after(() => {
     closeDb();

package/dist/core/__tests__/revive-capacity.test.js

@@ -15,7 +15,11 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, getNode } from '../canvas/canvas.js';
 import { jobDir } from '../canvas/paths.js';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { resetSession } from '../canvas/sessions.js';
+import { resetScopeCache } from '../scope.js';
+import { closeScopedStores } from '../scoped-state/db.js';
+import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
 import { bindDaemonEventSource, resetEventSourceForTests } from '../events/source.js';
 import { resetFleetForTests } from '../runtime/fleet.js';
 import { CANVAS_EXTENSIONS } from '../runtime/canvas-extensions.js';
@@ -25,6 +29,7 @@ import { deliverNodeMessage } from '../../daemon/messaging/node-message.js';
 import { bindTestFleet } from './helpers/fleet.js';
 let home;
 let tf;
+const previousHome = process.env['HOME'];
 let seq = 0;
 const originalLaunch = headlessBrokerHost.launch;
 /** The real host contract, minus the process: register at the launch seam, so
@@ -37,7 +42,7 @@ function stubLaunch() {
     };
 }
 function node(id, over = {}) {
-    createNode({
+    const meta = {
         node_id: id,
         name: id,
         created: new Date().toISOString(),
@@ -48,7 +53,11 @@ function node(id, over = {}) {
         status: 'active',
         host_kind: 'broker',
         ...over,
-    });
+    };
+    createNode(meta);
+    if (meta.pi_session_id != null) {
+        resetSession(id, { sessionId: meta.pi_session_id, transcriptPath: meta.pi_session_file ?? null });
+    }
     return id;
 }
 /** Fill the ledger to the cap with live brokers. */
@@ -59,12 +68,19 @@ async function saturate() {
 }
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-revive-capacity-'));
-    process.env['CRTR_HOME'] = home;
+    process.env['HOME'] = home;
+    process.env['CRTR_HOME'] = join(home, 'canvas');
     process.env['CRTR_MAX_LIVE_BROKERS'] = '2';
     resetEventSourceForTests();
     bindDaemonEventSource();
 });
 beforeEach(() => {
+    closeDb();
+    closeScopedStores();
+    rmSync(home, { recursive: true, force: true });
+    resetScopeCache();
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
+    migrate(openDb());
     tf = bindTestFleet();
     stubLaunch();
 });
@@ -74,9 +90,15 @@ after(() => {
     resetFleetForTests();
     resetEventSourceForTests();
     closeDb();
+    closeScopedStores();
     delete process.env['CRTR_MAX_LIVE_BROKERS'];
     delete process.env['CRTR_HOME'];
+    if (previousHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = previousHome;
     rmSync(home, { recursive: true, force: true });
+    resetScopeCache();
 });
 test('a refusing caller gets an error naming the cap and the live count, never a silent no-op', async () => {
     await saturate();

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

@@ -11,9 +11,14 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, getNode } from '../canvas/canvas.js';
+import { ensureScopeInitialized } from '../config.js';
+import { closeScopedStores } from '../scoped-state/db.js';
 import { contextDir } from '../canvas/paths.js';
-import { closeDb } from '../canvas/db.js';
-import { appendInbox, readCursor, writeCursor } from '../feed/inbox.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { enqueueNodeMail } from '../feed/messages.js';
+import { acknowledgeNodeMail, acknowledgedNodeMailCount, claimNodeMail } from '../canvas/deliveries.js';
+import { beginExecution, endExecution } from '../canvas/executions.js';
+import { bindSession } from '../canvas/sessions.js';
 import { transition } from '../runtime/lifecycle.js';
 import { reviveNode } from '../runtime/revive.js';
 import { headlessBrokerHost } from '../runtime/host.js';
@@ -21,6 +26,7 @@ import { resetFleetForTests } from '../runtime/fleet.js';
 import { bindTestFleet } from './helpers/fleet.js';
 let home;
 let priorHome;
+let priorUserHome;
 let fleet;
 let launches;
 let originalLaunch;
@@ -42,6 +48,9 @@ function parkResident(id, ground = {}) {
         pi_session_file: sessionFile,
     };
     createNode(meta);
+    const executionId = beginExecution(id, { daemonEpoch: 'test' });
+    assert.equal(bindSession(id, { executionId, sessionId: meta.pi_session_id, transcriptPath: sessionFile }), 'bound');
+    endExecution(executionId, { reason: 'parked test setup' });
     mkdirSync(contextDir(id), { recursive: true });
     if (ground.roadmap !== undefined)
         writeFileSync(join(contextDir(id), 'roadmap.md'), ground.roadmap);
@@ -52,7 +61,7 @@ function parkResident(id, ground = {}) {
 /** Durable wake-worthy mail, appended exactly as every message doorway appends
  *  it before calling reviveNode. */
 function deliverMail(id, tier = 'normal') {
-    return appendInbox(id, { from: null, tier, kind: 'message', label: 'work', data: { body: 'work' } }).entry_id;
+    return enqueueNodeMail(id, { kind: 'message', label: 'work', bodyJson: { body: 'work' }, urgency: tier, wake: 1 });
 }
 /** Did this launch carry the fresh-revive kickoff? `buildReviveKickoff` always
  *  opens its card body with this sentence (src/core/runtime/kickoff.ts:325). */
@@ -67,12 +76,16 @@ function placements() {
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-revive-parked-'));
     priorHome = process.env['CRTR_HOME'];
+    priorUserHome = process.env['HOME'];
     process.env['CRTR_HOME'] = home;
+    process.env['HOME'] = home;
 });
 beforeEach(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
     mkdirSync(home, { recursive: true });
+    ensureScopeInitialized('user', join(home, '.crouter'));
+    migrate(openDb());
     resetFleetForTests();
     fleet = bindTestFleet();
     launches = [];
@@ -87,6 +100,7 @@ beforeEach(() => {
 afterEach(() => {
     headlessBrokerHost.launch = originalLaunch;
     closeDb();
+    closeScopedStores();
     resetFleetForTests();
 });
 after(() => {
@@ -95,6 +109,10 @@ after(() => {
         delete process.env['CRTR_HOME'];
     else
         process.env['CRTR_HOME'] = priorHome;
+    if (priorUserHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = priorUserHome;
 });
 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' });
@@ -120,7 +138,7 @@ test('an input-less revival of a parked node quietly resumes and injects no kick
     assert.equal(result.resumed, true, 'nothing arrived, so there is nothing a fresh window would answer');
     assert.deepEqual(placements(), [{ nodeId: 'quiet', resuming: true }]);
     assert.equal(kickedOff(launches[0]), false, 'a quiet resume generates nothing');
-    assert.equal(readCursor('quiet'), undefined, 'drainBearings did not run, so nothing was consumed');
+    assert.equal(acknowledgedNodeMailCount('quiet'), 0, 'a quiet resume does not acknowledge mail');
     const reopened = getNode('quiet');
     assert.equal(reopened.status, 'active');
     assert.equal(reopened.intent ?? null, null, 'the park marker clears on a quiet resume too');
@@ -130,12 +148,17 @@ test('deferred mail alone is not input, so the revival still resumes quietly', a
     deliverMail('deferred', 'deferred');
     assert.equal((await reviveNode('deferred', { resume: true, capacity: 'freeze' })).resumed, true);
     assert.equal(kickedOff(launches[0]), false);
-    assert.equal(readCursor('deferred'), undefined, 'the deferred entry rides the next natural cycle, unconsumed');
+    assert.equal(acknowledgedNodeMailCount('deferred'), 0, 'the deferred delivery rides the next natural cycle, unacknowledged');
 });
-test('mail already covered by the cursor is not input, so the revival still resumes quietly', async () => {
+test('mail already acknowledged by an earlier execution is not input, so the revival still resumes quietly', async () => {
     parkResident('stale', { roadmap: '# Roadmap\n\n- one open item\n' });
-    writeCursor('stale', deliverMail('stale'));
-    assert.equal((await reviveNode('stale', { resume: true, capacity: 'freeze' })).resumed, true, 'only the UNSEEN suffix counts as input');
+    const delivery = deliverMail('stale');
+    const executionId = beginExecution('stale', { daemonEpoch: 'test' });
+    const claim = claimNodeMail('stale', executionId, 'wake');
+    assert.equal(claim.deliveries.length, 1, 'the earlier execution claims the delivery');
+    assert.deepEqual(acknowledgeNodeMail('stale', executionId, [{ deliveryId: delivery.deliveryId, attempts: claim.deliveries[0].attempts, disposition: 'acknowledged' }]).results, [{ deliveryId: delivery.deliveryId, outcome: 'acknowledged' }], 'the prior handoff has an explicit SQL acknowledgement');
+    endExecution(executionId, { reason: 'test complete' });
+    assert.equal((await reviveNode('stale', { resume: true, capacity: 'freeze' })).resumed, true, 'only pending wake deliveries count as input');
     assert.equal(kickedOff(launches[0]), false);
 });
 test('a parked node with no goal and no roadmap resumes its transcript rather than waking amnesiac', async () => {

package/dist/core/__tests__/seam/broker-attach-stream.test.js

@@ -65,7 +65,7 @@ const brokerPid = () => h.node(id).pi_pid;
 // engine AND the streaming AgentSessionEvents are fanned out to the client
 // VERBATIM. Failure mode: a broken relay/fan-out (viewer sees nothing).
 test('G1 — controller prompt runs the engine and the streamed AgentSessionEvents relay to the client', async () => {
-    const c = await ctrl('g1-ctrl');
+    const c = await attachUntil(id, 'controller', 'g1-ctrl', (a) => a.welcome.role === 'controller' && a.welcome.snapshot.state.isStreaming === false, 'G1 controller admitted while the engine is idle');
     assert.equal(c.welcome.role, 'controller', 'first controller is admitted as controller');
     const token = tok('G1-PROMPT');
     c.send({ type: 'prompt', text: token });

package/dist/core/__tests__/seam/broker-cap-freeze.test.js

@@ -14,8 +14,9 @@ import { after, before, test } from 'node:test';
 import assert from 'node:assert/strict';
 import { createNode } from '../../canvas/canvas.js';
 import { closeDb } from '../../canvas/db.js';
+import { resetSession } from '../../canvas/sessions.js';
 import { isPidAlive } from '../../canvas/pid.js';
-import { appendInbox } from '../../feed/inbox.js';
+import { enqueueNodeMail } from '../../feed/messages.js';
 import { closeNode } from '../../runtime/close.js';
 import { headlessBrokerHost } from '../../runtime/host.js';
 import { transition } from '../../runtime/lifecycle.js';
@@ -116,7 +117,7 @@ test('a birth at the cap freezes instead of booting, survives saturated ticks, a
     await h.awaitFleetExit(second);
     const filler = await h.spawnHeadlessChild(root, 'terminal thaw filler');
     assert.equal(h.fleet.size(), 2, 'the parked target is non-live while the cap remains full');
-    appendInbox(second, { from: root, tier: 'normal', kind: 'message', label: 'durable wake' });
+    enqueueNodeMail(second, { senderNodeId: root, kind: 'message', label: 'durable wake', urgency: 'normal', wake: 1 });
     assert.equal((await reviveNode(second, { resume: true, capacity: 'freeze' })).outcome, 'frozen');
     closeDb();
     const frozenTerminal = h.node(second);
@@ -142,8 +143,8 @@ test('a birth at the cap freezes instead of booting, survives saturated ticks, a
         host_kind: 'broker',
         parent: root,
         created: new Date().toISOString(),
-        pi_session_id: 'resident-drain-session',
     });
+    resetSession('resident-drain', { sessionId: 'resident-drain-session', transcriptPath: null });
     assert.equal((await reviveNode('resident-drain', { resume: true, capacity: 'freeze' })).outcome, 'frozen');
     await h.tick();
     closeDb();

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

@@ -2,8 +2,8 @@
 //
 // Daemon-epoch broker ownership, real-process crash and teardown. The broker's
 // supervision tick is the death authority after the broker exit is observed: a SIGTERM of a streaming broker
-// aborts cleanly and resumes the saved session with a continuation, and a
-// SIGKILL mid-turn — no certificate, only the durable busy marker — resumes
+// aborts cleanly and resumes the saved session, and a
+// SIGKILL mid-turn — with the durable open-turn record — resumes
 // that same saved session in place and re-drives the stopped turn with the
 // same continuation (both policy row 5). Each replacement starts only after the
 // prior process has exited, preserving one writer per session. A clean `node
@@ -23,9 +23,8 @@ import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { createHarness } from '../helpers/harness.js';
 import { isPidAlive } from '../../canvas/pid.js';
-import { markBusy } from '../../runtime/busy.js';
+import { readLiveTurn } from '../../canvas/recovery.js';
 import { RUNTIME_RESTART_CONTINUATION } from '../../runtime/kickoff.js';
-import { jobDir } from '../../canvas/paths.js';
 let h;
 let root;
 let priorHoldTurn;
@@ -44,24 +43,23 @@ after(async () => {
         process.env['PI_FAKE_ENGINE_HOLD_TURN'] = priorHoldTurn;
 });
 // Items 4 + 5 + 6 — two independent real-process journeys:
-//   graceful busy teardown → strict resume + continuation;
+//   graceful busy teardown → strict resume;
 //   dirty interrupted-turn crash → recovery cycle → close.
-test('SIGTERM of a busy broker aborts cleanly and resumes with a continuation', { timeout: 30_000 }, async () => {
+test('SIGTERM of a busy broker aborts cleanly and resumes the saved session', { timeout: 30_000 }, async () => {
     const id = await h.spawnHeadlessChild(root, 'headless worker — graceful crash recovery');
     const boot1 = await h.awaitBoot(id);
     const oldPid = h.node(id).pi_pid;
     assert.equal(oldPid, boot1.pid, 'canvas pid identifies the broker that booted the session');
     assert.equal(isPidAlive(oldPid), true, 'busy broker alive before graceful teardown');
     await h.waitFor(() => existsSync(h.brokerSock(id)), { label: 'broker socket bound' });
-    await h.waitFor(() => existsSync(join(jobDir(id), 'busy')), { label: 'fixture turn is active before SIGTERM' });
+    await h.waitFor(() => readLiveTurn(id)?.busy === true, { label: 'fixture turn is active before SIGTERM' });
     assert.equal(h.node(id).intent ?? null, null, 'fresh broker has a null intent (not refresh/idle-release)');
     const boots = h.bootCount(id);
     // SIGTERM exercises broker.ts's bounded session.abort() path. Its REAL child
-    // exit leaves the broker-written clean-abort certificate; the supervision tick
+    // exit closes the broker's durable turn as teardown-aborted; the supervision tick
     // classifies it and persists the first-failure backoff.
     process.kill(oldPid, 'SIGTERM');
     await h.waitFor(() => !isPidAlive(oldPid), { label: 'gracefully torn-down broker pid is dead' });
-    assert.equal(existsSync(join(jobDir(id), 'clean-abort')), true, 'settled abort leaves durable clean-abort evidence before supervision classifies it');
     await h.awaitFleetExit(id);
     await h.tick();
     const gracefulBackoff = h.node(id);
@@ -73,7 +71,6 @@ test('SIGTERM of a busy broker aborts cleanly and resumes with a continuation',
     // matures on a supervision tick.
     const boot2 = await h.awaitBoot(id, { minCount: boots + 1, timeoutMs: 25_000 });
     assert.equal(boot2.resuming, true, 'clean-abort tick-driven recovery RESUMES the saved .jsonl');
-    assert.equal(boot2.prompt, RUNTIME_RESTART_CONTINUATION, 'the strict resume injects the runtime-restart continuation');
     assert.ok(!boot2.rawArgv.includes('--crtr-new-cycle'), 'clean abort never starts a recovery cycle');
     const revivedPid = h.node(id).pi_pid;
     assert.ok(revivedPid != null && isPidAlive(revivedPid), 'the revived broker pid is alive');
@@ -87,12 +84,12 @@ test('SIGKILL of a busy broker resumes the interrupted turn in place; close tear
     const busyPid = h.node(id).pi_pid;
     assert.equal(busyPid, boot1.pid, 'canvas pid identifies the broker that owns the dirty-crash session');
     assert.equal(isPidAlive(busyPid), true, 'busy broker is alive before SIGKILL');
-    // This broker has only the durable busy marker — SIGKILL cannot run the abort
-    // handler or write clean-abort evidence. The saved transcript is still
+    // This broker has an open durable turn — SIGKILL cannot run the abort handler
+    // to close it. The saved transcript is still
     // resumable (pi persists whole entries), so policy resumes it strictly and
     // the respawn continuation re-drives the stopped turn, after this journey's
     // first 5s backoff. A dirty death is not a reason to throw the branch away.
-    markBusy(id);
+    await h.waitFor(() => readLiveTurn(id)?.busy === true, { label: 'fixture turn is active before SIGKILL' });
     process.kill(busyPid, 'SIGKILL');
     await h.waitFor(() => !isPidAlive(busyPid), { label: 'mid-turn crashed broker pid is dead' });
     await h.awaitFleetExit(id);
@@ -107,7 +104,7 @@ test('SIGKILL of a busy broker resumes the interrupted turn in place; close tear
     // path, including a cycle; production distinguishes cycling with the argv
     // token and non-null kickoff. Assert those load-bearing inputs directly.
     const recoveryArgv = boot2.rawArgv;
-    assert.ok(!recoveryArgv.includes('--crtr-new-cycle'), 'a surviving busy marker resumes the saved session — it never opens a fresh cycle');
+    assert.ok(!recoveryArgv.includes('--crtr-new-cycle'), 'a surviving open turn resumes the saved session — it never opens a fresh cycle');
     assert.equal(boot2.prompt, RUNTIME_RESTART_CONTINUATION, 'the strict resume injects the runtime-restart continuation that re-drives the interrupted turn');
     const recoveryPid = h.node(id).pi_pid;
     assert.ok(recoveryPid != null && isPidAlive(recoveryPid), 'the recovered broker pid is alive');