@north-light/crouter 0.3.312 → 0.3.313

package/dist/core/__tests__/plugin-page-components.test.js

@@ -15,7 +15,8 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import * as tar from 'tar';
 import { resetScopeCache } from '../scope.js';
-import { resolvePageComponents } from '../config.js';
+import { resolvePageComponents, updateRawConfigAtomically, writeRawConfig } from '../config.js';
+import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
 import { validatePluginBundle } from '../command-plugins/bundle.js';
 let isolatedHome;
 let isolatedCwd;
@@ -30,6 +31,7 @@ beforeEach(() => {
     isolatedCwd = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-page-components-cwd-')));
     process.env.HOME = isolatedHome;
     process.chdir(isolatedCwd);
+    initializeFreshScopedStore({ kind: 'user', root: join(isolatedHome, '.crouter') });
     resetScopeCache();
 });
 afterEach(() => {
@@ -60,7 +62,7 @@ test('an enabled user-scope plugin contributes its page components; a disabled o
         { kind: 'applet-card', display: true },
     ]);
     plantPlugin(root, 'zzz-disabled', ['ghost']);
-    writeFileSync(join(root, 'config.json'), JSON.stringify({ plugins: { 'zzz-disabled': { enabled: false } } }));
+    writeRawConfig('user', { plugins: { 'zzz-disabled': { enabled: false } } });
     const components = resolvePageComponents();
     assert.deepEqual(components, [
         { kind: 'connector', description: 'Connector decision', useWhen: 'Use for a connector decision.', doc: 'Product contract.' },
@@ -70,9 +72,9 @@ test('an enabled user-scope plugin contributes its page components; a disabled o
 test('user config entries and plugin contributions resolve together, and a colliding kind is rejected', () => {
     const root = userRoot();
     plantPlugin(root, 'northlight', ['connector']);
-    writeFileSync(join(root, 'config.json'), JSON.stringify({ page_components: ['approval'] }));
+    updateRawConfigAtomically('user', () => ({ page_components: ['approval'] }));
     assert.deepEqual(resolvePageComponents().map((component) => component.kind), ['approval', 'connector']);
-    writeFileSync(join(root, 'config.json'), JSON.stringify({ page_components: ['connector'] }));
+    updateRawConfigAtomically('user', () => ({ page_components: ['connector'] }));
     assert.throws(() => resolvePageComponents(), /page component kind "connector" is registered by both config.json and plugin "northlight"/);
 });
 test('two plugins whose kinds derive one JSX tag are rejected, naming both sources', () => {

package/dist/core/__tests__/preview-registry-sync.test.js

@@ -16,6 +16,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { buildRoot } from '../../build-root.js';
 import { SUPPRESS_OUTPUT_LEAVES, LEAF_ICON_CP, SUMMARIZERS } from '../preview-registry.js';
+import { ensureScopeInitialized } from '../config.js';
 import { resetScopeCache } from '../scope.js';
 // buildRoot() composes external command-plugin branches from the effective
 // enabled plugins (user scope + project ancestors). Pin HOME + profile to an
@@ -31,6 +32,7 @@ before(() => {
     process.env['HOME'] = home;
     delete process.env['CRTR_PROFILE_ID'];
     resetScopeCache();
+    ensureScopeInitialized('user', join(home, '.crouter'));
 });
 after(() => {
     if (realHome !== undefined)

package/dist/core/__tests__/profile-project-memory-delivery.test.js

@@ -18,9 +18,10 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
 import { resetScopeCache } from '../scope.js';
 import { createProfile } from '../profiles/manifest.js';
+import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
 import { spawnNode } from '../runtime/nodes.js';
 import { memoryDir } from '../runtime/memory.js';
 import { clearSessionCache } from '../substrate/session-cache.js';
@@ -115,6 +116,8 @@ before(() => {
     canvasHome = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-ppm-canvas-')));
     process.env['HOME'] = home;
     process.env['CRTR_HOME'] = canvasHome;
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
+    migrate(openDb());
     // A project store answers only under the namespace its root INDEX.md
     // declares; without that declaration the store does not mount at all.
     const store = (slug, namespace) => {

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

@@ -3,8 +3,9 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, existsSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { createNode, getRow, subscribe, recordPid, recordSpawn, subscribersOf, subscriptionsOf, pruneNodes, pruneToLimit, transitionStatusIntent, } from '../canvas/canvas.js';
-import { closeDb, openDb } from '../canvas/db.js';
+import { createNode, getRow, subscribe, recordSpawn, subscribersOf, subscriptionsOf, pruneNodes, pruneToLimit, transitionStatusIntent, } from '../canvas/canvas.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { beginExecution, recordExecutionPid } from '../canvas/executions.js';
 import { nodeDir } from '../canvas/paths.js';
 let home;
 const DAY = 86_400_000;
@@ -33,6 +34,10 @@ function totalEdges() {
 function markCollectibleTerminal(nodeId) {
     transitionStatusIntent(nodeId, { terminal_reason: 'closed' });
 }
+function recordExecution(nodeId, pid) {
+    const executionId = beginExecution(nodeId, { daemonEpoch: 'test' });
+    recordExecutionPid(executionId, nodeId, pid);
+}
 /** The standard fixture: three prunable terminal nodes (old), three survivors
  *  (two old-but-live, one recent-but-dead), and edges that touch a pruned node
  *  so cascade is observable. */
@@ -55,6 +60,7 @@ before(() => {
 beforeEach(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
+    migrate(openDb());
 });
 after(() => {
     closeDb();
@@ -146,7 +152,7 @@ test('count pruning keeps all live nodes even when liveCount exceeds the cap', (
     // fall beyond rank 5 and are pruned.
     for (let i = 0; i < 5; i++) {
         createNode(node(`live-${i}`, { status: 'active', created: at(i) }));
-        recordPid(`live-${i}`, process.pid); // process.pid is alive → isPidAlive true
+        recordExecution(`live-${i}`, process.pid); // process.pid is alive → isPidAlive true
     }
     createNode(node('old-a', { status: 'dead', created: at(100) }));
     createNode(node('old-b', { status: 'done', created: at(101) }));
@@ -164,7 +170,7 @@ test('count pruning deletes the oldest terminal nodes beyond max(cap, liveCount)
     // Ranked by recency DESC: live-0, term-0, term-1 (top 3, kept), then
     // term-2, term-3, term-4 (rank >= 3, pruned).
     createNode(node('live-0', { status: 'idle', created: at(0) }));
-    recordPid('live-0', process.pid);
+    recordExecution('live-0', process.pid);
     for (let i = 0; i < 5; i++) {
         const id = `term-${i}`;
         createNode(node(id, { status: 'dead', created: at(10 + i) }));
@@ -185,7 +191,7 @@ test('count pruning deletes the oldest terminal nodes beyond max(cap, liveCount)
 });
 test('count pruning dry-run reports candidates without deleting rows or dirs', () => {
     createNode(node('live-0', { status: 'idle', created: at(0) }));
-    recordPid('live-0', process.pid);
+    recordExecution('live-0', process.pid);
     for (let i = 0; i < 5; i++) {
         const id = `term-${i}`;
         createNode(node(id, { status: 'dead', created: at(10 + i) }));

package/dist/core/__tests__/push-final-guard.test.js

@@ -4,21 +4,28 @@ import { mkdtempSync, rmSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, getNode, setStatus } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, openDb, migrate } from '../canvas/db.js';
 import { InputError } from '../io.js';
 import { messageRoutes } from '../../daemon/api/handlers/messages.js';
 import { pushFinal, FinalizationError } from '../feed/feed.js';
 import { assertNotFinalized, assertFinalizedForReopen, commitReopen } from '../runtime/reopen.js';
 import { reviveNode } from '../runtime/revive.js';
 import { headlessBrokerHost } from '../runtime/host.js';
-import { readInboxSince } from '../feed/inbox.js';
+function nodeMailCount(nodeId) {
+    return Number(openDb().prepare(`SELECT COUNT(*) AS count FROM deliveries
+    WHERE destination_kind = 'node_inbox' AND destination_id = ?`).get(nodeId).count);
+}
 import { writeGoal } from '../runtime/kickoff.js';
 import { situationalContextPath } from '../canvas/paths.js';
 let home;
 const prevNodeId = process.env['CRTR_NODE_ID'];
 function node(id) { return { node_id: id, name: id, created: new Date().toISOString(), cwd: '/tmp/work', kind: 'general', mode: 'base', lifecycle: 'terminal', status: 'active' }; }
 before(() => { home = mkdtempSync(join(tmpdir(), 'crtr-pushfinal-')); process.env['CRTR_HOME'] = home; });
-beforeEach(() => { closeDb(); rmSync(home, { recursive: true, force: true }); });
+beforeEach(() => {
+    closeDb();
+    rmSync(home, { recursive: true, force: true });
+    migrate(openDb());
+});
 after(() => { closeDb(); rmSync(home, { recursive: true, force: true }); delete process.env['CRTR_HOME']; if (prevNodeId === undefined)
     delete process.env['CRTR_NODE_ID'];
 else
@@ -66,13 +73,13 @@ test('a finalized node re-tasked via node message send without --reopen is rejec
     const firstFinal = getNode(id)?.final_report;
     assert.ok(firstFinal);
     // A message to the now-finalized node, no --reopen: rejected before the
-    // handler ever reaches appendInbox/reviveNode. Prove BOTH: the latch is
+    // handler ever creates a delivery or reaches reviveNode. Prove BOTH: the latch is
     // untouched, AND (per #340's Minor finding) no side effect landed first —
     // spy on the exact revive seam reviveNode calls (headlessBrokerHost.launch,
     // the same seam revive.test.ts already uses to instrument reviveNode without
     // a real engine) and assert it was never invoked, plus the inbox is
     // unchanged.
-    const inboxBefore = readInboxSince(id, undefined).length;
+    const inboxBefore = nodeMailCount(id);
     const originalLaunch = headlessBrokerHost.launch;
     let launchCalls = 0;
     headlessBrokerHost.launch = ((...args) => { launchCalls++; return originalLaunch(...args); });
@@ -84,7 +91,7 @@ test('a finalized node re-tasked via node message send without --reopen is rejec
     }
     assert.equal(launchCalls, 0, 'a rejected retask must never attempt a revive');
     assert.equal(getNode(id)?.final_report, firstFinal, 'a rejected retask must not touch the latch');
-    assert.equal(readInboxSince(id, undefined).length, inboxBefore, 'a rejected retask must not append an inbox entry');
+    assert.equal(nodeMailCount(id), inboxBefore, 'a rejected retask must not create a delivery');
     // The successful path, driven through the ACTUAL daemon message handler (the
     // real seam --reopen now lives behind, not a direct call into the gate
     // internals) — stub the revive seam so no real engine process is spawned,
@@ -105,7 +112,7 @@ test('a finalized node re-tasked via node message send without --reopen is rejec
         headlessBrokerHost.launch = originalLaunch;
     }
     assert.equal(getNode(id)?.final_report, null, '--reopen cleared the latch through the real handler seam');
-    assert.equal(readInboxSince(id, undefined).length, inboxBefore + 1, 'the re-task message was actually appended to the inbox');
+    assert.equal(nodeMailCount(id), inboxBefore + 1, 'the re-task message created one durable delivery');
     // The re-tasked node can now finish its new mandate and re-latch cleanly.
     process.env['CRTR_NODE_ID'] = id;
     await pushFinal(id, 'round 2 verdict');

package/dist/core/__tests__/relaunch-root.test.js

@@ -15,13 +15,19 @@ import { CrtrClient } from '../../api/client.js';
 import { createApiServer } from '../../daemon/api/server.js';
 import registerCanvasStophook from '../../pi-extensions/canvas-stophook.js';
 import { createNode, getNode, subscribe } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
+import { beginExecution, recordExecutionPid } from '../canvas/executions.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { resetScopeCache } from '../scope.js';
+import { closeScopedStores } from '../scoped-state/db.js';
+import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
 import { apiSocketPath } from '../canvas/paths.js';
 import { brokerCapReached, resetFleetForTests } from '../runtime/fleet.js';
 import { buildPiArgv } from '../runtime/launch.js';
 import { relaunchRoot } from '../runtime/reset.js';
 import { bindTestFleet } from './helpers/fleet.js';
 let home;
+let tf;
+const previousHome = process.env['HOME'];
 function node(id, over = {}) {
     return {
         node_id: id,
@@ -67,16 +73,30 @@ function makeDeps(pid) {
 }
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-relaunch-'));
-    process.env['CRTR_HOME'] = home;
+    process.env['HOME'] = home;
+    process.env['CRTR_HOME'] = join(home, 'canvas');
 });
 beforeEach(() => {
     closeDb();
+    closeScopedStores();
     rmSync(home, { recursive: true, force: true });
+    resetScopeCache();
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
+    migrate(openDb());
+    tf = bindTestFleet();
 });
 after(() => {
     closeDb();
+    closeScopedStores();
+    tf.fleet.dispose();
+    resetFleetForTests();
     rmSync(home, { recursive: true, force: true });
     delete process.env['CRTR_HOME'];
+    if (previousHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = previousHome;
+    resetScopeCache();
 });
 test('relaunchRoot parks the old root done and mints a fresh active root, reaping descendants', async () => {
     // root → child → grandchild (a parent that subscribes to its workers).
@@ -169,6 +189,10 @@ test('root /new capacity refusal reaches the attached human through broker UI no
     process.env['CRTR_NODE_ID'] = 'root';
     createNode(node('root', { parent: null, lifecycle: 'resident' }));
     const tf = bindTestFleet();
+    const executionId = beginExecution('root', { daemonEpoch: tf.fleet.epoch() });
+    assert.equal(recordExecutionPid(executionId, 'root', process.pid), 'recorded');
+    const previousExecutionId = process.env['CRTR_EXECUTION_ID'];
+    process.env['CRTR_EXECUTION_ID'] = executionId;
     const never = new Promise(() => { });
     tf.fleet.register('filler-a', { pid: 700_001, exited: never });
     tf.fleet.register('filler-b', { pid: 700_002, exited: never });
@@ -207,6 +231,10 @@ test('root /new capacity refusal reaches the attached human through broker UI no
         resetFleetForTests();
         delete process.env['CRTR_MAX_LIVE_BROKERS'];
         delete process.env['CRTR_NODE_ID'];
+        if (previousExecutionId === undefined)
+            delete process.env['CRTR_EXECUTION_ID'];
+        else
+            process.env['CRTR_EXECUTION_ID'] = previousExecutionId;
     }
 });
 test('relaunchRoot is a no-op for a non-root child and an already-parked root', async () => {

package/dist/core/__tests__/remote-canvas-target.test.js

@@ -11,7 +11,9 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { readConfig, updateConfig } from '../config.js';
+import { ensureScopeInitialized, readConfig, updateConfig } from '../config.js';
+import { closeScopedStores } from '../scoped-state/db.js';
+import { resetScopeCache } from '../scope.js';
 import { setRelayToken } from '../secrets.js';
 import { getRemoteCanvasTarget, resolveRemoteCanvasTarget } from '../remote-canvas-target.js';
 let home;
@@ -22,9 +24,13 @@ before(() => {
     process.env['HOME'] = home;
 });
 beforeEach(() => {
+    closeScopedStores();
     rmSync(home, { recursive: true, force: true });
+    resetScopeCache();
+    ensureScopeInitialized('user', join(home, '.crouter'));
 });
 after(() => {
+    closeScopedStores();
     rmSync(home, { recursive: true, force: true });
     if (realHome !== undefined)
         process.env['HOME'] = realHome;

package/dist/core/__tests__/repository-root-identity.test.js

@@ -8,9 +8,11 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { ensureScopeInitialized } from '../config.js';
 import { gitSync } from '../git.js';
 import { createProfile } from '../profiles/manifest.js';
 import { loadMemoryStoreView, memoryStoresInPrecedence, openProjectMemoryStore, resolveMemoryDocForTarget, } from '../memory-resolver.js';
+import { closeScopedStores } from '../scoped-state/db.js';
 import { resetScopeCache } from '../scope.js';
 const cleanups = [];
 let previousHome;
@@ -20,8 +22,10 @@ before(() => {
 beforeEach(() => {
     process.env.HOME = fixtureDir('crtr-repository-root-identity-home-');
     resetScopeCache();
+    ensureScopeInitialized('user', join(process.env.HOME, '.crouter'));
 });
 after(() => {
+    closeScopedStores();
     resetScopeCache();
     for (const path of cleanups)
         rmSync(path, { recursive: true, force: true });

package/dist/core/__tests__/review-model-floor.test.js

@@ -5,11 +5,13 @@
 // persona keeps the stronger default needed to synthesise a broad review.
 import { after, before, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { defaultKindsConfig, defaultModelLaddersConfig } from '../../types.js';
 import { buildLaunchSpec, normalizeModel } from '../runtime/launch.js';
+import { writeRawConfig } from '../config.js';
+import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
 const priorHome = process.env['HOME'];
 const ladders = defaultModelLaddersConfig();
 // Review's own kind default IS its floor — an explicit override weaker than
@@ -20,14 +22,15 @@ before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-review-model-floor-'));
     process.env['HOME'] = home;
     mkdirSync(join(home, '.crouter'), { recursive: true });
-    writeFileSync(join(home, '.crouter', 'config.json'), JSON.stringify({
+    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
+    writeRawConfig('user', {
         kinds: {
             'audit/reviewers/security': {
                 whenToUse: 'Review one security surface.',
                 model: 'medium',
             },
         },
-    }));
+    });
 });
 after(() => {
     if (priorHome === undefined)

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();