@north-light/crouter 0.3.311 → 0.3.313

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

@@ -3,12 +3,22 @@ import assert from 'node:assert/strict';
 import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { createNode, getNode, subscribe, subscriptionsOf } from '../canvas/canvas.js';
+import { createNode as createRawNode, getNode, subscribe, subscriptionsOf } from '../canvas/canvas.js';
 import { nodeDir } from '../canvas/paths.js';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, openDb, migrate } from '../canvas/db.js';
+import { beginExecution } from '../canvas/executions.js';
+import { bindSession } from '../canvas/sessions.js';
 import { closeNode } from '../runtime/close.js';
 import { reapEmptyNodes } from '../runtime/placement.js';
-import { readInboxSince } from '../feed/inbox.js';
+function nodeMail(nodeId) {
+    return openDb().prepare(`SELECT m.sender_node_id AS "from", m.kind, m.label, m.body_ref AS ref, m.body_json AS data
+    FROM deliveries d JOIN messages m ON m.message_id = d.message_id
+    WHERE d.destination_kind = 'node_inbox' AND d.destination_id = ?
+    ORDER BY m.seq`).all(nodeId).map((row) => ({
+        ...row,
+        data: row.data === null ? null : JSON.parse(row.data),
+    }));
+}
 import { FinalizationError, pushFinal } from '../feed/feed.js';
 let home;
 /** Write a minimal pi session containing one assistant message, so the node
@@ -22,6 +32,14 @@ function withSession(id) {
     writeFileSync(f, JSON.stringify({ type: 'message', message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }] } }) + '\n');
     return f;
 }
+function createNode(meta) {
+    const created = createRawNode(meta);
+    if (meta.pi_session_file !== null && meta.pi_session_file !== undefined) {
+        const executionId = beginExecution(meta.node_id, { daemonEpoch: 'test' });
+        assert.equal(bindSession(meta.node_id, { executionId, sessionId: meta.pi_session_id ?? meta.node_id, transcriptPath: meta.pi_session_file }), 'bound');
+    }
+    return created;
+}
 function node(id, over = {}) {
     return {
         node_id: id,
@@ -48,6 +66,7 @@ before(() => {
 beforeEach(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
+    migrate(openDb());
 });
 after(() => {
     closeDb();
@@ -105,18 +124,18 @@ test('appends a resume notice naming the dead children to each closed node', ()
     spawnEdge('N', 'A');
     spawnEdge('A', 'C');
     closeNode('N');
-    const nNotice = readInboxSince('N').at(-1);
+    const nNotice = nodeMail('N').at(-1);
     assert.equal(nNotice.from, null);
     assert.equal(nNotice.kind, 'message');
     assert.match(nNotice.label, /CLOSED by the user/);
     assert.match(nNotice.label, /A \(A\)/); // dead child named
     assert.deepEqual(nNotice.data?.['canceled_children'], ['A']);
     assert.equal(nNotice.data?.['cascade_root'], 'N');
-    const aNotice = readInboxSince('A').at(-1);
+    const aNotice = nodeMail('A').at(-1);
     assert.match(aNotice.label, /CANCELED/);
     assert.match(aNotice.label, /C \(C\)/);
     // A leaf has no dead children — gets the short "session preserved" notice.
-    const cNotice = readInboxSince('C').at(-1);
+    const cNotice = nodeMail('C').at(-1);
     assert.match(cNotice.label, /session is preserved/);
     assert.deepEqual(cNotice.data?.['canceled_children'], []);
 });
@@ -169,7 +188,7 @@ test('close first suppresses a later final publication and its subscriber pointe
     await assert.rejects(() => pushFinal('child', 'too late'), (error) => error instanceof FinalizationError && error.code === 'finalization_forbidden');
     assert.equal(getNode('child')?.final_report, null, 'close owns the terminal outcome');
     assert.deepEqual(readdirSync(join(nodeDir('child'), 'reports')).filter((name) => name.endsWith('-final.md')), [], 'a rejected final leaves no canonical report');
-    assert.equal(readInboxSince('manager').filter((entry) => entry.kind === 'final').length, 0, 'a rejected final never wakes a subscriber with a final pointer');
+    assert.equal(nodeMail('manager').filter((entry) => entry.kind === 'final').length, 0, 'a rejected final never wakes a subscriber with a final pointer');
 });
 test('final publication first remains the one canonical final after close', async () => {
     createNode(node('child'));
@@ -184,7 +203,7 @@ test('final publication first remains the one canonical final after close', asyn
     assert.equal(child.intent, 'done');
     assert.equal(child.final_report, canonical, 'close preserves the original canonical marker');
     assert.ok(existsSync(publication.reportPath), 'the canonical report remains on disk');
-    const finalPointers = readInboxSince('manager').filter((entry) => entry.kind === 'final');
+    const finalPointers = nodeMail('manager').filter((entry) => entry.kind === 'final');
     assert.equal(finalPointers.length, 1, 'the manager receives exactly one final pointer');
     assert.equal(finalPointers[0]?.ref, `child:reports/${canonical}`);
 });
@@ -239,7 +258,7 @@ test('closing an EMPTY node with an open managed worktree cancels it without rea
     assert.equal(meta?.managed_worktree?.state, 'open', 'node retains worktree ownership');
     assert.ok(existsSync(dir), 'node dir remains');
     assert.ok(existsSync(worktreePath), 'managed checkout remains reachable through its node');
-    assert.match(readInboxSince(id).at(-1)?.label ?? '', /session is preserved/);
+    assert.match(nodeMail(id).at(-1)?.label ?? '', /session is preserved/);
     assert.deepEqual(reapEmptyNodes(), [], 'bulk empty reap also preserves the open managed worktree node');
     assert.equal(getNode(id)?.managed_worktree?.state, 'open', 'bulk reap retains worktree ownership');
 });
@@ -251,7 +270,7 @@ test('reaping an empty child still notifies a surviving external manager', () =>
     spawnEdge('mgr', 'child');
     closeNode('child');
     assert.equal(getNode('child'), null, 'empty child reaped');
-    const note = readInboxSince('mgr').at(-1);
+    const note = nodeMail('mgr').at(-1);
     assert.match(note.label, /Child closed/);
     assert.equal(note.data?.['child'], 'child');
 });

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

@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, getRow, isCollectible, setFrozen, transitionStatusIntent, } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
 let home;
 function node(id, over = {}) {
     return {
@@ -31,6 +31,7 @@ before(() => {
 beforeEach(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
+    migrate(openDb());
 });
 after(() => {
     closeDb();

package/dist/core/__tests__/config-change-delta.test.js

@@ -11,6 +11,7 @@ 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 { resetScopeCache } from '../scope.js';
 import { clearSessionCache } from '../substrate/session-cache.js';
 import { renderConfigChangeDelta, renderKnowledgeForSubject, renderPreferencesForSubject, } from '../substrate/render.js';
@@ -60,6 +61,7 @@ before(() => {
     writeFileSync(join(user, 'delta-dev-knowledge.md'), ['---', 'kind: knowledge', `when-and-why-to-read: "${DEV_KNOWLEDGE_WHEN}"`, 'gate: {kind: developer}', 'surfaces:', '  - {on: boot, at: preview}', '---', '', 'ignored body', ''].join('\n'));
     process.chdir(work);
     resetScopeCache();
+    ensureScopeInitialized('user', join(home, '.crouter'));
     clearSessionCache();
 });
 after(() => {

package/dist/core/__tests__/context-intro.test.js

@@ -11,7 +11,9 @@ import assert from 'node:assert/strict';
 import { existsSync, mkdtempSync, mkdirSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { ensureScopeInitialized } from '../config.js';
+import { closeScopedStores } from '../scoped-state/db.js';
 import { apiSocketPath } from '../canvas/paths.js';
 import { spawnNode } from '../runtime/nodes.js';
 import { appendSituationalContext, formatSituationalProse, situationalContextEnvelope, } from '../runtime/situational-context.js';
@@ -19,6 +21,7 @@ import registerCanvasContextIntro, { CONTEXT_INTRO_CUSTOM_TYPE, } from '../../pi
 import { buildContextBearings as buildContextIntro } from '../runtime/bearings.js';
 import { createApiServer } from '../../daemon/api/server.js';
 let home;
+let priorUserHome;
 let server;
 async function waitForSocket(path) {
     for (let i = 0; i < 200; i++) {
@@ -30,26 +33,35 @@ async function waitForSocket(path) {
 }
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-ctxintro-'));
+    priorUserHome = process.env['HOME'];
+    process.env['HOME'] = home;
     process.env['CRTR_HOME'] = home;
 });
 beforeEach(async () => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
     mkdirSync(home, { recursive: true });
+    ensureScopeInitialized('user', join(home, '.crouter'));
+    migrate(openDb());
     server = createApiServer();
     await waitForSocket(apiSocketPath());
 });
 afterEach(async () => {
     await server.close();
+    closeScopedStores();
 });
 after(() => {
     closeDb();
     rmSync(home, { recursive: true, force: true });
     delete process.env['CRTR_HOME'];
     delete process.env['CRTR_NODE_ID'];
+    if (priorUserHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = priorUserHome;
 });
-test('the stored situational card rides the bearings body; absent when unset', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+test('the stored situational card rides the bearings body; absent when unset', async () => {
+    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     assert.equal(situationalContextEnvelope(meta.node_id), null, 'no card until something is set');
     assert.doesNotMatch(buildContextIntro(meta.node_id), /kind="situational"/, 'bearings carry no card when unset');
     appendSituationalContext(meta.node_id, formatSituationalProse('user is looking at the billing applet'));
@@ -73,7 +85,7 @@ function fakeCtx(pi) {
     return { sessionManager: { getBranch: () => pi.entries } };
 }
 test('session_start injects the block as the first message of an empty session', async () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     process.env['CRTR_NODE_ID'] = meta.node_id;
     const pi = makeFakePi();
     registerCanvasContextIntro(pi);
@@ -87,7 +99,7 @@ test('session_start injects the block as the first message of an empty session',
     assert.match(pi.sent[0].content, /<crtr-bearings>/);
 });
 test('session_start is idempotent across resume (skips if already in history)', async () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
+    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
     process.env['CRTR_NODE_ID'] = meta.node_id;
     // Restored session already carries OUR block (which names this node id) → no
     // duplicate injection. The content matters: the guard is fork-aware and only

package/dist/core/__tests__/cron-armed-context-failure.test.js

@@ -12,8 +12,10 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { listNodes } from '../canvas/canvas.js';
 import { armCron, getCron, listCronRuns } from '../canvas/crons.js';
-import { closeDb } from '../canvas/db.js';
-import { createProfile, profileManifestPath, profileRoot } from '../profiles/manifest.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { ensureScopeInitialized } from '../config.js';
+import { closeScopedStores } from '../scoped-state/db.js';
+import { createProfile, deleteProfile, profileManifestPath } from '../profiles/manifest.js';
 import { resetScopeCache } from '../scope.js';
 import { headlessBrokerHost } from '../runtime/host.js';
 import { resetFleetForTests } from '../runtime/fleet.js';
@@ -78,10 +80,13 @@ beforeEach(() => {
         fleet.fleet.register(nodeId, handle);
         return handle;
     });
+    ensureScopeInitialized('user', join(userHome, '.crouter'));
+    migrate(openDb());
 });
 afterEach(() => {
     headlessBrokerHost.launch = originalLaunch;
     closeDb();
+    closeScopedStores();
     resetFleetForTests();
 });
 after(() => {
@@ -126,17 +131,17 @@ test('a corrupt armed env snapshot fails the run instead of silently dropping th
         assertSettledAsArmingFailure(id, record, /run could not be armed: the armed env snapshot/, nodesBefore);
     }
 });
-test('an unreadable profile manifest fails the run, while a deleted profile still runs as root', async () => {
-    const unreadable = createProfile('cron-unreadable').profileId;
+test('a profile artifact is ignored while a deleted SQL profile runs as root', async () => {
+    const existing = createProfile('cron-existing').profileId;
     const deleted = createProfile('cron-deleted').profileId;
-    // Corrupt one manifest in place and delete the other profile outright: the
-    // two states the old resolver could not tell apart.
-    writeFileSync(profileManifestPath(unreadable), '{ not json', 'utf8');
-    rmSync(profileRoot(deleted), { recursive: true, force: true });
-    arm({ cron_id: 'profile-unreadable', profile: unreadable });
-    const nodesBefore = listNodes().length;
-    const failed = await executeCron(getCron('profile-unreadable'), { outOfBand: false });
-    assertSettledAsArmingFailure('profile-unreadable', failed, /run could not be armed: the armed profile .* manifest could not be read/, nodesBefore);
+    // Profile identity is SQL-authoritative. The legacy artifact cannot change
+    // the context an already-armed run uses.
+    writeFileSync(profileManifestPath(existing), '{ not json', 'utf8');
+    arm({ cron_id: 'profile-existing', profile: existing });
+    const ranExisting = await executeCron(getCron('profile-existing'), { outOfBand: false });
+    assert.equal(ranExisting?.exit_code, 0, 'a corrupt profile artifact does not alter the SQL profile context');
+    assert.equal(readFileSync(marker('profile-existing'), 'utf8'), existing, 'the run retains the SQL-backed profile identity');
+    deleteProfile(deleted);
     arm({ cron_id: 'profile-deleted', profile: deleted });
     const ran = await executeCron(getCron('profile-deleted'), { outOfBand: false });
     assert.equal(ran?.exit_code, 0, 'a deleted profile is the spec root fallback — the run proceeds');

package/dist/core/__tests__/cron-held-settlement.test.js

@@ -7,19 +7,22 @@
 // consumption — and a poke (`pokeHeldCrons`) re-dues every held active row
 // now. These pin the branch's truth table: the exact class of scheduling
 // defect that otherwise fails silently weeks later.
-import { after, afterEach, before, test } from 'node:test';
+import { after, afterEach, before, beforeEach, test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
-import { closeDb, openDb } from '../canvas/db.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { ensureScopeInitialized } from '../config.js';
+import { closeScopedStores } from '../scoped-state/db.js';
 import { armCron, cancelCron, getCron, listCronRuns, pokeHeldCrons, setCronState, } from '../canvas/crons.js';
 import { executeCron, runDueCrons } from '../../daemon/cron-run.js';
 const HELD_DELIVERED = 'deferred (exit 75) — held for poke';
 const HELD_FAR_FUTURE = '9999-12-31T23:59:59.999Z';
 let home;
 let realHome;
+let realUserHome;
 function arm(overrides) {
     armCron({
         name: overrides.cron_id,
@@ -45,10 +48,21 @@ function arm(overrides) {
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-cron-held-'));
     realHome = process.env['CRTR_HOME'];
+    realUserHome = process.env['HOME'];
+    process.env['HOME'] = home;
     process.env['CRTR_HOME'] = home;
 });
+beforeEach(() => {
+    closeDb();
+    closeScopedStores();
+    rmSync(home, { recursive: true, force: true });
+    mkdirSync(home, { recursive: true });
+    ensureScopeInitialized('user', join(home, '.crouter'));
+    migrate(openDb());
+});
 afterEach(() => {
     closeDb();
+    closeScopedStores();
 });
 after(() => {
     closeDb();
@@ -57,6 +71,10 @@ after(() => {
         delete process.env['CRTR_HOME'];
     else
         process.env['CRTR_HOME'] = realHome;
+    if (realUserHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = realUserHome;
 });
 test('a recurring exit-75 run parks: held, backstop untouched, no disposition', async () => {
     // on-change makes the skipped disposition observable: were the branch to

package/dist/core/__tests__/cron-node-sink-parked-root.test.js

@@ -10,9 +10,10 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createNode, getNode, listNodes } from '../canvas/canvas.js';
+import { ensureScopeInitialized } from '../config.js';
+import { closeScopedStores } from '../scoped-state/db.js';
 import { armCron, getCron } from '../canvas/crons.js';
-import { closeDb } from '../canvas/db.js';
-import { readInboxSince } from '../feed/inbox.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
 import { headlessBrokerHost } from '../runtime/host.js';
 import { resetFleetForTests } from '../runtime/fleet.js';
 import { applyParkEvent, parkEvent } from '../../daemon/reconcilers/live-obligation.js';
@@ -20,6 +21,7 @@ import { executeCron } from '../../daemon/cron-run.js';
 import { bindTestFleet } from './helpers/fleet.js';
 let home;
 let priorHome;
+let priorUserHome;
 let fleet;
 let launches;
 let originalLaunch;
@@ -36,6 +38,14 @@ function node(id, over = {}) {
         ...over,
     };
 }
+function nodeMail(nodeId) {
+    return openDb().prepare(`SELECT m.body_json, d.urgency FROM deliveries d JOIN messages m ON m.message_id = d.message_id
+    WHERE d.destination_kind = 'node_inbox' AND d.destination_id = ? ORDER BY m.seq`).all(nodeId).map((row) => {
+        const data = row;
+        const value = data.body_json === null ? null : JSON.parse(data.body_json);
+        return { body: typeof value?.body === 'string' ? value.body : null, urgency: data.urgency };
+    });
+}
 function arm({ cron_id, ...overrides }) {
     armCron({
         cron_id,
@@ -79,12 +89,16 @@ function parkResidentRoot(id) {
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-cron-node-sink-parked-root-'));
     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 = [];
@@ -99,6 +113,7 @@ beforeEach(() => {
 afterEach(() => {
     headlessBrokerHost.launch = originalLaunch;
     closeDb();
+    closeScopedStores();
     resetFleetForTests();
 });
 after(() => {
@@ -107,16 +122,20 @@ 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('cron node sink delivers to a parked resident root and resumes its existing session without escalation', async () => {
+test('cron node sink creates a durable delivery for a parked resident root without escalation', async () => {
     parkResidentRoot('parked-root');
     arm({ cron_id: 'parked-root-cron', sink: JSON.stringify({ node: 'parked-root' }), anchor_node: 'parked-root' });
     const record = await executeCron(getCron('parked-root-cron'), { outOfBand: false });
-    assert.equal(record?.delivered, 'delivered: node parked-root');
+    assert.match(record?.delivered ?? '', /^delivered: /);
     assert.equal(getCron('parked-root-cron').state, 'active', 'delivery does not pause the cron');
-    assert.deepEqual(readInboxSince('parked-root', undefined).map((entry) => entry.data?.['body']), ['cron output']);
-    assert.deepEqual(launches, [{ nodeId: 'parked-root', resuming: true }], 'the parked session is resumed exactly once');
-    assert.equal(getNode('parked-root').status, 'active', 'revive restores the parked root to its active cycle');
+    assert.deepEqual(nodeMail('parked-root').map((entry) => entry.body), ['cron output']);
+    assert.deepEqual(launches, [], 'the delivery lane wakes the destination after it claims mail');
+    assert.equal(getNode('parked-root').status, 'done', 'the parked root remains parked until delivery claims the row');
     assert.deepEqual(listNodes().map((entry) => entry.node_id), ['parked-root'], 'no escalation node was created');
 });
 test('finalized and canceled node-sink targets still pause and escalate without delivery', async () => {
@@ -131,7 +150,7 @@ test('finalized and canceled node-sink targets still pause and escalate without
         const record = await executeCron(getCron(`${id}-cron`), { outOfBand: false });
         assert.match(record?.delivered ?? '', /^failure: cron paused, escalation node /, `${id}: failure is escalated`);
         assert.equal(getCron(`${id}-cron`).state, 'paused', `${id}: cron is paused`);
-        assert.equal(readInboxSince(id, undefined).length, 0, `${id}: no message was appended`);
+        assert.equal(nodeMail(id).length, 0, `${id}: no message was appended`);
         assert.equal(listNodes().length, before + 1, `${id}: exactly one escalation node was created`);
     }
 });
@@ -139,9 +158,9 @@ test('a deferred node-sink entry reaches the parked root durably but never reviv
     parkResidentRoot('deferred-root');
     arm({ cron_id: 'deferred-root-cron', sink: JSON.stringify({ node: 'deferred-root' }), tier: 'deferred' });
     const record = await executeCron(getCron('deferred-root-cron'), { outOfBand: false });
-    assert.equal(record?.delivered, 'delivered: node deferred-root');
+    assert.match(record?.delivered ?? '', /^delivered: /);
     assert.equal(getCron('deferred-root-cron').state, 'active');
-    assert.deepEqual(readInboxSince('deferred-root', undefined).map((entry) => entry.tier), ['deferred']);
+    assert.deepEqual(nodeMail('deferred-root').map((entry) => entry.urgency), ['deferred']);
     assert.deepEqual(launches, [], 'deferred delivery never launches a dormant target');
     assert.equal(getNode('deferred-root').status, 'done', 'the parked target remains parked');
 });

package/dist/core/__tests__/cron-self-cancel-delivery.test.js

@@ -9,11 +9,14 @@ import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { ensureScopeInitialized } from '../config.js';
+import { closeScopedStores } from '../scoped-state/db.js';
 import { armCron, cancelCron, getCron } from '../canvas/crons.js';
 import { executeCron, markSelfCanceledCronRun } from '../../daemon/cron-run.js';
 let home;
 let realHome;
+let realUserHome;
 function arm(overrides) {
     armCron({
         name: overrides.cron_id,
@@ -39,10 +42,15 @@ function arm(overrides) {
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-cron-broker-capacity-'));
     realHome = process.env['CRTR_HOME'];
+    realUserHome = process.env['HOME'];
+    process.env['HOME'] = home;
     process.env['CRTR_HOME'] = home;
+    ensureScopeInitialized('user', join(home, '.crouter'));
+    migrate(openDb());
 });
 afterEach(() => {
     closeDb();
+    closeScopedStores();
 });
 after(() => {
     closeDb();
@@ -51,6 +59,10 @@ after(() => {
         delete process.env['CRTR_HOME'];
     else
         process.env['CRTR_HOME'] = realHome;
+    if (realUserHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = realUserHome;
 });
 test('an on-change cron that cancels itself still delivers its final output', async () => {
     const runIdPath = join(home, 'self-cancel-run-id');
@@ -68,5 +80,5 @@ test('an on-change cron that cancels itself still delivers its final output', as
     assert.equal(markSelfCanceledCronRun('self-cancel-delivery', readFileSync(runIdPath, 'utf8')), true);
     assert.equal(cancelCron('self-cancel-delivery', { preserveRunningProcess: true }), true);
     const record = await run;
-    assert.equal(record?.delivered, 'delivered: human send --inbox');
+    assert.match(record?.delivered ?? '', /^delivered: [0-9a-f]{32}$/, 'the durable human delivery was created after self-cancel');
 });

package/dist/core/__tests__/cron-timeout-descendants.test.js

@@ -15,7 +15,9 @@ import assert from 'node:assert/strict';
 import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { closeDb } from '../canvas/db.js';
+import { closeDb, migrate, openDb } from '../canvas/db.js';
+import { ensureScopeInitialized } from '../config.js';
+import { closeScopedStores } from '../scoped-state/db.js';
 import { armCron, getCron } from '../canvas/crons.js';
 import { isPidAlive } from '../canvas/pid.js';
 import { executeCron } from '../../daemon/cron-run.js';
@@ -34,6 +36,7 @@ setInterval(() => {}, 1000);
 `;
 let home;
 let realHome;
+let realUserHome;
 let marker;
 let command;
 function arm(overrides) {
@@ -61,7 +64,11 @@ function arm(overrides) {
 before(() => {
     home = mkdtempSync(join(tmpdir(), 'crtr-cron-timeout-descendants-'));
     realHome = process.env['CRTR_HOME'];
+    realUserHome = process.env['HOME'];
+    process.env['HOME'] = home;
     process.env['CRTR_HOME'] = home;
+    ensureScopeInitialized('user', join(home, '.crouter'));
+    migrate(openDb());
     marker = join(home, 'descendant.pid');
     const intermediate = join(home, 'intermediate.cjs');
     const descendant = join(home, 'descendant.cjs');
@@ -84,11 +91,16 @@ after(() => {
         }
     }
     closeDb();
+    closeScopedStores();
     rmSync(home, { recursive: true, force: true });
     if (realHome === undefined)
         delete process.env['CRTR_HOME'];
     else
         process.env['CRTR_HOME'] = realHome;
+    if (realUserHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = realUserHome;
 });
 test('a TERM-ignoring descendant outside the shell process group is reaped before the timeout is recorded', async () => {
     arm({ cron_id: 'timeout-descendants', command });