@north-light/crouter 0.3.311 → 0.3.313

package/dist/core/__tests__/integration/lifecycle-hooks.test.js

@@ -1,11 +1,19 @@
 import assert from 'node:assert/strict';
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import test from 'node:test';
 import { contextDir, jobDir, nodeDir, reportsDir } from '../../canvas/paths.js';
+import { listNodes, listWarmSpares } from '../../canvas/canvas.js';
+import { readExternalActionDelivery } from '../../canvas/deliveries.js';
 import { validateHookManifest } from '../../command-hooks/schema.js';
 import { headlessBrokerHost } from '../../runtime/host.js';
 import { reviveNode } from '../../runtime/revive.js';
+import { handleCreate, handleFork } from '../../../daemon/api/handlers/nodes.js';
+import { armCron, getCron } from '../../canvas/crons.js';
+import { settleRun } from '../../../daemon/cron/settle.js';
+import { DeliveryLaneReconciler } from '../../../daemon/reconcilers/delivery-lane.js';
+import { relaunchRoot } from '../../runtime/reset.js';
+import { recycleNode } from '../../runtime/recycle.js';
 import { createHarness } from '../helpers/harness.js';
 function installLifecyclePlugin(harness, name, op) {
     const ops = typeof op === 'string' ? [op] : op;
@@ -53,6 +61,64 @@ process.stdin.on('end', () => {
 `);
     chmodSync(executable, 0o755);
 }
+function installCreateLifecyclePlugin(harness, name, declarations, behavior) {
+    const root = join(harness.agentHome, '.crouter', 'plugins', name);
+    const records = join(root, 'records.jsonl');
+    mkdirSync(join(root, '.crouter-plugin'), { recursive: true });
+    writeFileSync(join(root, '.crouter-plugin', 'plugin.json'), JSON.stringify({
+        name,
+        version: '0.1.0',
+        description: 'node create lifecycle fixture',
+        hooks: 'hooks.json',
+        hookExecutable: 'bin/hook.js',
+    }));
+    writeFileSync(join(root, 'hooks.json'), JSON.stringify({
+        schemaVersion: 2,
+        lifecycle: declarations.map((declaration) => ({ ...declaration, description: `${declaration.op} fixture`, effects: ['writes fixture state'] })),
+    }));
+    const executable = join(root, 'bin', 'hook.js');
+    mkdirSync(join(root, 'bin'), { recursive: true });
+    writeFileSync(executable, `#!/usr/bin/env node
+const { appendFileSync, existsSync, readdirSync } = require('node:fs');
+const { join } = require('node:path');
+const behavior = ${JSON.stringify(behavior)};
+let input = '';
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+  const request = JSON.parse(input);
+  appendFileSync(${JSON.stringify(records)}, JSON.stringify(request) + '\\n');
+  if (request.event === 'node:create' && behavior === 'refuse') {
+    process.stdout.write(JSON.stringify({ protocolVersion: 1, ok: false, error: { code: 'refused', message: 'fixture refusal' } }));
+    return;
+  }
+  if (request.event === 'node:create' && behavior === 'crash') process.exit(1);
+  if (request.event === 'node:create' && behavior === 'hang') return setInterval(() => {}, 1000);
+  if (request.event === 'node:create' && behavior === 'bad-output') return process.stdout.write('not an envelope');
+  if (request.event === 'node:create' && behavior === 'second-refuses') {
+    const nodes = join(request.runtime.canvasHome, 'nodes');
+    if (existsSync(nodes) && readdirSync(nodes).some((entry) => entry !== 'index.json')) {
+      process.stdout.write(JSON.stringify({ protocolVersion: 1, ok: false, error: { code: 'occupied', message: 'second create refused' } }));
+      return;
+    }
+  }
+  if (request.event === 'node:start' && behavior === 'start-refuses') {
+    process.stdout.write(JSON.stringify({ protocolVersion: 1, ok: false, error: { code: 'ignored', message: 'start refusal' } }));
+    return;
+  }
+  process.stdout.write(JSON.stringify({ protocolVersion: 1, ok: true }));
+});
+`);
+    chmodSync(executable, 0o755);
+    return { root, records };
+}
+function createContext(body, params = {}) {
+    return { method: 'POST', path: '/v1/nodes', params, query: new URLSearchParams(), body };
+}
+function lifecycleRecords(path) {
+    return existsSync(path)
+        ? readFileSync(path, 'utf8').trim().split('\n').filter(Boolean).map((line) => JSON.parse(line))
+        : [];
+}
 function installV1CommandHook(harness) {
     const root = join(harness.agentHome, '.crouter', 'plugins', 'z-v1-command');
     mkdirSync(join(root, '.crouter-plugin'), { recursive: true });
@@ -149,6 +215,244 @@ test('node:start hooks receive resolved paths before broker launch; invalid and
         await harness.dispose();
     }
 });
+test('node:create fails closed before a row exists and node:start fires on cold birth', async () => {
+    const harness = await createHarness({ headless: true, sessionPrefix: 'crtr-node-create-hooks' });
+    try {
+        const birth = installCreateLifecyclePlugin(harness, 'birth-fixture', [
+            { event: 'node:create', phase: 'before', op: 'record-create' },
+            { event: 'node:start', phase: 'on', op: 'record-start' },
+        ], 'start-refuses');
+        const created = await handleCreate(createContext({ kind: 'developer', root: true, profile: null, cwd: harness.agentHome, prompt: '' }));
+        const nodeId = created.body.node_id;
+        await harness.awaitBoot(nodeId);
+        const records = lifecycleRecords(birth.records);
+        const create = records.find((record) => record.event === 'node:create');
+        assert.deepEqual(create.create, {
+            kind: 'developer', mode: 'base', cwd: harness.agentHome, profile: null, root: true, parentId: null, requestingNodeId: null, lifecycle: 'resident', replaces: null,
+        });
+        assert.deepEqual(create.runtime, { canvasHome: harness.home, profile: null });
+        assert.deepEqual(create.context, { cwd: harness.agentHome });
+        assert.equal(Object.hasOwn(create, 'node'), false);
+        const start = records.find((record) => record.event === 'node:start');
+        assert.equal(start.runtime.isBirth, true);
+        assert.ok(harness.node(nodeId), 'a refusing node:start hook leaves the cold birth launched');
+        rmSync(birth.root, { recursive: true, force: true });
+        for (const behavior of ['refuse', 'crash', 'bad-output', 'hang']) {
+            const plugin = installCreateLifecyclePlugin(harness, `create-${behavior}`, [{ event: 'node:create', phase: 'before', op: behavior }], behavior);
+            const count = listNodes().length;
+            await assert.rejects(() => handleCreate(createContext({ kind: 'developer', root: true, profile: null, cwd: harness.agentHome, prompt: '' })), (error) => {
+                assert.equal(error.code, 'node_create_refused');
+                assert.match(error.message, new RegExp(`${behavior === 'refuse' ? 'fixture refusal' : `plugin "create-${behavior}" lifecycle hook "${behavior}"`}`));
+                return true;
+            });
+            assert.equal(listNodes().length, count, `${behavior} leaves no node row`);
+            rmSync(plugin.root, { recursive: true, force: true });
+        }
+        const missing = installCreateLifecyclePlugin(harness, 'create-missing', [{ event: 'node:create', phase: 'before', op: 'missing-op' }], 'allow');
+        rmSync(join(missing.root, 'bin', 'hook.js'));
+        await assert.rejects(() => handleCreate(createContext({ kind: 'developer', root: true, profile: null, cwd: harness.agentHome, prompt: '' })), (error) => {
+            assert.equal(error.code, 'node_create_refused');
+            assert.match(error.message, /plugin "create-missing" lifecycle hook "missing-op"/);
+            return true;
+        });
+        rmSync(missing.root, { recursive: true, force: true });
+        const malformed = installCreateLifecyclePlugin(harness, 'create-malformed', [
+            { event: 'node:create', phase: 'before', op: 'valid-create' },
+            { event: 'node:create', phase: 'on', op: 'invalid-create' },
+        ], 'allow');
+        const count = listNodes().length;
+        await assert.rejects(() => handleCreate(createContext({ kind: 'developer', root: true, profile: null, cwd: harness.agentHome, prompt: '' })), (error) => {
+            assert.equal(error.code, 'node_create_refused');
+            assert.match(error.message, /plugin "create-malformed" lifecycle hook "valid-create"/);
+            return true;
+        });
+        assert.equal(listNodes().length, count, 'a later malformed node:create declaration leaves no node row');
+        rmSync(malformed.root, { recursive: true, force: true });
+        const malformedOtherLifecycle = installCreateLifecyclePlugin(harness, 'create-malformed-other-lifecycle', [
+            { event: 'node:start', phase: 'before', op: 'invalid-start' },
+            { event: 'node:create', phase: 'before', op: 'valid-create' },
+        ], 'allow');
+        await assert.rejects(() => handleCreate(createContext({ kind: 'developer', root: true, profile: null, cwd: harness.agentHome, prompt: '' })), (error) => {
+            assert.equal(error.code, 'node_create_refused');
+            assert.match(error.message, /plugin "create-malformed-other-lifecycle" lifecycle hook "valid-create"/);
+            return true;
+        });
+        rmSync(malformedOtherLifecycle.root, { recursive: true, force: true });
+    }
+    finally {
+        await harness.dispose();
+    }
+});
+test('node:fork runs the node:create gate for its new resident root', async () => {
+    const harness = await createHarness({ headless: true, sessionPrefix: 'crtr-node-fork-create' });
+    try {
+        const plugin = installCreateLifecyclePlugin(harness, 'fork-create', [{ event: 'node:create', phase: 'before', op: 'record-fork' }], 'allow');
+        const source = await handleCreate(createContext({ kind: 'developer', root: true, profile: null, cwd: harness.agentHome, prompt: '' }));
+        const sourceId = source.body.node_id;
+        await harness.awaitBoot(sourceId);
+        const fork = await handleFork(createContext({}, { id: sourceId }));
+        const forkId = fork.body.node_id;
+        await harness.awaitBoot(forkId);
+        const creates = lifecycleRecords(plugin.records).filter((record) => record.event === 'node:create');
+        assert.equal(creates.length, 2);
+        assert.deepEqual(creates[1].create, {
+            kind: 'developer', mode: 'base', cwd: harness.agentHome, profile: null, root: true, parentId: null, requestingNodeId: null, lifecycle: 'resident', replaces: null,
+        });
+    }
+    finally {
+        await harness.dispose();
+    }
+});
+test('node:create gates warm mint and warm claim with the birth payload', async () => {
+    const harness = await createHarness({ headless: true, sessionPrefix: 'crtr-node-create-warm' });
+    const priorWarmPool = process.env['CRTR_WARM_POOL'];
+    process.env['CRTR_WARM_POOL'] = '1';
+    try {
+        const plugin = installCreateLifecyclePlugin(harness, 'warm-create', [{ event: 'node:create', phase: 'before', op: 'record-warm' }], 'allow');
+        const first = await handleCreate(createContext({ kind: 'developer', root: true, profile: null, cwd: harness.agentHome, prompt: '', prefer_warm: true }));
+        await harness.awaitBoot(first.body.node_id);
+        let spareId;
+        for (let i = 0; i < 100; i++) {
+            spareId = listWarmSpares()[0]?.node_id;
+            if (spareId !== undefined)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+        assert.ok(spareId, 'the cold create refills one warm spare');
+        await harness.awaitBoot(spareId);
+        const createsBeforeClaim = lifecycleRecords(plugin.records).filter((record) => record.event === 'node:create').length;
+        const second = await handleCreate(createContext({ kind: 'developer', root: true, profile: null, cwd: harness.agentHome, prompt: '', prefer_warm: true }));
+        assert.equal(second.body.node_id, spareId, 'the second request claims the pre-born spare');
+        const creates = lifecycleRecords(plugin.records).filter((record) => record.event === 'node:create');
+        assert.equal(creates.length, createsBeforeClaim + 1, 'claiming the spare runs one additional create gate');
+        for (const record of creates) {
+            assert.deepEqual(record.create, {
+                kind: 'developer', mode: 'base', cwd: harness.agentHome, profile: null, root: true, parentId: null, requestingNodeId: null, lifecycle: 'resident', replaces: null,
+            });
+        }
+        let replacementSpareId;
+        for (let i = 0; i < 100; i++) {
+            replacementSpareId = listWarmSpares()[0]?.node_id;
+            if (replacementSpareId !== undefined)
+                break;
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+        assert.ok(replacementSpareId, 'a claimed spare is refilled before the test tears down its harness');
+        await harness.awaitBoot(replacementSpareId);
+    }
+    finally {
+        if (priorWarmPool === undefined)
+            delete process.env['CRTR_WARM_POOL'];
+        else
+            process.env['CRTR_WARM_POOL'] = priorWarmPool;
+        await harness.dispose();
+    }
+});
+test('a refused recycle leaves the old root active', async () => {
+    const harness = await createHarness({ headless: true, sessionPrefix: 'crtr-node-create-recycle' });
+    const priorWarmPool = process.env['CRTR_WARM_POOL'];
+    process.env['CRTR_WARM_POOL'] = '0';
+    try {
+        const source = await handleCreate(createContext({ kind: 'developer', root: true, profile: null, cwd: harness.agentHome, prompt: '' }));
+        const sourceId = source.body.node_id;
+        await harness.awaitBoot(sourceId);
+        installCreateLifecyclePlugin(harness, 'recycle-refusal', [{ event: 'node:create', phase: 'before', op: 'refuse-recycle' }], 'refuse');
+        await assert.rejects(() => recycleNode(sourceId, '%recycle-refusal'), /fixture refusal/);
+        assert.equal(harness.node(sourceId)?.status, 'active', 'the old root is unchanged when the replacement hook refuses');
+    }
+    finally {
+        if (priorWarmPool === undefined)
+            delete process.env['CRTR_WARM_POOL'];
+        else
+            process.env['CRTR_WARM_POOL'] = priorWarmPool;
+        await harness.dispose();
+    }
+});
+test('node:create reports the root replaced by /new', async () => {
+    const harness = await createHarness({ headless: true, sessionPrefix: 'crtr-node-create-relaunch' });
+    const priorWarmPool = process.env['CRTR_WARM_POOL'];
+    process.env['CRTR_WARM_POOL'] = '0';
+    try {
+        const plugin = installCreateLifecyclePlugin(harness, 'relaunch-create', [{ event: 'node:create', phase: 'before', op: 'record-relaunch' }], 'allow');
+        const source = await handleCreate(createContext({ kind: 'developer', root: true, profile: null, cwd: harness.agentHome, prompt: '' }));
+        const sourceId = source.body.node_id;
+        await harness.awaitBoot(sourceId);
+        const result = await relaunchRoot(sourceId, {
+            launchBroker: () => ({ pid: 999_999, exited: new Promise(() => { }) }),
+            waitForViewSocket: () => true,
+            respawnViewer: () => true,
+            teardownBroker: async () => ({ confirmed: true }),
+        });
+        assert.ok(result);
+        const create = lifecycleRecords(plugin.records).filter((record) => record.event === 'node:create').at(-1);
+        assert.deepEqual(create.create, {
+            kind: 'developer', mode: 'base', cwd: harness.agentHome, profile: null, root: true, parentId: null, requestingNodeId: null, lifecycle: 'resident', replaces: sourceId,
+        });
+    }
+    finally {
+        if (priorWarmPool === undefined)
+            delete process.env['CRTR_WARM_POOL'];
+        else
+            process.env['CRTR_WARM_POOL'] = priorWarmPool;
+        await harness.dispose();
+    }
+});
+test('a refused cron spawn records its failure and does not throw', async () => {
+    const harness = await createHarness({ headless: true, sessionPrefix: 'crtr-node-create-cron' });
+    try {
+        installCreateLifecyclePlugin(harness, 'cron-create', [{ event: 'node:create', phase: 'before', op: 'refuse-cron' }], 'refuse');
+        armCron({
+            cron_id: 'refused-cron-spawn', name: 'refused cron spawn', created_by: null, command: 'echo fixture', fire_at: new Date().toISOString(), recur: null, tz: null, expires_at: null, anchor_node: null, cancel_on_wake: false,
+            cwd: harness.agentHome, env_json: null, profile: null, scope: 'global', run_timeout_s: 30, overlap: 'skip', on_output: 'always', sink: JSON.stringify({ spawn: 'developer' }), tier: 'normal',
+        });
+        const cron = getCron('refused-cron-spawn');
+        const record = await settleRun(cron, {
+            outOfBand: false,
+            outcome: {
+                kind: 'disposed',
+                ctx: {
+                    runId: 'refused-cron-run', startedAtIso: new Date().toISOString(), exitCode: 0, timedOut: false, runTimeoutS: 30, processErrorMessage: null,
+                    stdoutHead: 'fixture output', stdoutSha256: 'fixture-output-hash', stderrHead: '',
+                },
+            },
+            record: { runId: 'refused-cron-run', startedAtIso: new Date().toISOString(), finishedAtMs: Date.now(), durationMs: 1, exitCode: 0, stdoutHead: 'fixture output', stderrHead: null },
+            lease: 'none',
+        });
+        assert.match(record.delivered ?? '', /^delivered: /, 'the cron run records its durable delivery');
+        const pendingDelivery = readExternalActionDelivery('refused-cron-run');
+        assert.equal(pendingDelivery.state, 'pending');
+        assert.equal(pendingDelivery.destinationId, 'cron_spawn');
+        assert.equal(getCron(cron.cron_id), null, 'the one-shot occurrence is spent once its delivery is durable');
+        const pending = [];
+        new DeliveryLaneReconciler().run(Date.now(), {
+            lifecycle: { acceptsDetachedWork: () => true, registerDetached: (work) => { pending.push(work); } },
+        });
+        await Promise.all(pending);
+        const settledDelivery = readExternalActionDelivery('refused-cron-run');
+        assert.equal(settledDelivery.state, 'permanent_failed');
+        assert.match(settledDelivery.lastFailure?.message ?? '', /fixture refusal/);
+        assert.equal(listNodes().length, 0, 'the refused delivery neither creates a node nor escalates');
+    }
+    finally {
+        await harness.dispose();
+    }
+});
+test('node:create serializes concurrent creates through the persisted row', async () => {
+    const harness = await createHarness({ headless: true, sessionPrefix: 'crtr-node-create-lock' });
+    try {
+        installCreateLifecyclePlugin(harness, 'create-lock', [{ event: 'node:create', phase: 'before', op: 'only-one' }], 'second-refuses');
+        const request = () => handleCreate(createContext({ kind: 'developer', root: true, profile: null, cwd: harness.agentHome, prompt: '' }));
+        const results = await Promise.allSettled([request(), request()]);
+        assert.equal(results.filter((result) => result.status === 'fulfilled').length, 1);
+        const refusal = results.find((result) => result.status === 'rejected');
+        assert.equal(refusal.reason.code, 'node_create_refused');
+        assert.match(refusal.reason.message, /second create refused/);
+        assert.equal(listNodes().length, 1);
+    }
+    finally {
+        await harness.dispose();
+    }
+});
 test('hooks.json v1 remains command-only while v2 accepts a lifecycle-only declaration', () => {
     const v1 = validateHookManifest({
         schemaVersion: 1,
@@ -176,10 +480,17 @@ test('hooks.json v1 remains command-only while v2 accepts a lifecycle-only decla
         lifecycle: [{ event: 'node:close', phase: 'on', op: 'cleanup', description: 'cleanup', effects: ['removes a directory'] }],
     });
     assert.deepEqual(close.issues, []);
+    const create = validateHookManifest({
+        schemaVersion: 2,
+        lifecycle: [{ event: 'node:create', phase: 'before', op: 'guard', description: 'guard', effects: ['refuses a create'] }],
+    });
+    assert.deepEqual(create.issues, []);
     for (const manifest of [
         { schemaVersion: 2, hooks: [], lifecycle: [] },
         { schemaVersion: 2, lifecycle: [{ event: 'node:stop', phase: 'on', op: 'prepare', description: 'prepare', effects: ['creates a directory'] }] },
         { schemaVersion: 2, lifecycle: [{ event: 'node:start', phase: 'before', op: 'prepare', description: 'prepare', effects: ['creates a directory'] }] },
+        { schemaVersion: 2, lifecycle: [{ event: 'node:create', phase: 'on', op: 'prepare', description: 'prepare', effects: ['creates a directory'] }] },
+        { schemaVersion: 2, lifecycle: [{ event: 'node:close', phase: 'before', op: 'prepare', description: 'prepare', effects: ['creates a directory'] }] },
         { schemaVersion: 2, lifecycle: [{ event: 'node:start', phase: 'on', op: 'prepare', description: 'prepare', effects: ['creates a directory'], unexpected: true }] },
     ]) {
         assert.equal(validateHookManifest(manifest).manifest, undefined, 'invalid v2 lifecycle declarations are rejected');

package/dist/core/__tests__/integration/plugin-revalidate.test.js

@@ -31,6 +31,8 @@ import { join } from 'node:path';
 import * as tar from 'tar';
 import { resetScopeCache, userScopeRoot } from '../../scope.js';
 import { readState, readConfig } from '../../config.js';
+import { closeScopedStores } from '../../scoped-state/db.js';
+import { initializeFreshScopedStore } from '../../scoped-state/migrate.js';
 import { revalidateBundlePlugins, forceRevalidateBundlePlugin } from '../../command-plugins/revalidate.js';
 import { pluginInstall } from '../../../commands/pkg/plugin-manage.js';
 import { runCli } from '../../command.js';
@@ -68,6 +70,7 @@ beforeEach(async () => {
     isolatedCwd = realpathSync(mkdtempSync(join(tmpdir(), 'crtr-revalidate-cwd-')));
     process.env.HOME = isolatedHome;
     process.chdir(isolatedCwd);
+    initializeFreshScopedStore({ kind: 'user', root: join(isolatedHome, '.crouter') });
     resetScopeCache();
     served = { archive: makeArchive('v1'), etag: '"sha256-v1"' };
     requests = [];
@@ -105,6 +108,7 @@ beforeEach(async () => {
 afterEach(async () => {
     await new Promise((resolve) => server.close(() => resolve()));
     process.chdir(prevCwd);
+    closeScopedStores();
     rmSync(isolatedHome, { recursive: true, force: true });
     rmSync(isolatedCwd, { recursive: true, force: true });
 });

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

@@ -4,7 +4,7 @@ import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { contextDir } from '../../canvas/paths.js';
 import { getRow } from '../../canvas/canvas.js';
 import { bashJobPaths, bashJobsDir } from '../../bash-jobs.js';
-import { readCursor } from '../../feed/inbox.js';
+import { acknowledgedNodeMailCount } from '../../canvas/deliveries.js';
 import { transition } from '../../runtime/lifecycle.js';
 import { ensureRootProfile, pauseProfile } from '../../profiles/manifest.js';
 import { createHeadlessHarness } from '../helpers/harness.js';
@@ -22,7 +22,7 @@ function runningJob(nodeId) {
     }
     return undefined;
 }
-test('profile pause backgrounds real bash, retains its inbox cursor, and recovers after a quick resume without failure', { timeout: 120_000 }, async () => {
+test('profile pause backgrounds real bash, retains its queued SQL delivery, and recovers after a quick resume without failure', { timeout: 120_000 }, async () => {
     const h = await createHeadlessHarness({ sessionPrefix: 'crtr-profile-pause' });
     try {
         const profile = ensureRootProfile();
@@ -39,7 +39,7 @@ test('profile pause backgrounds real bash, retains its inbox cursor, and recover
         assert.equal(retained.code, 0, retained.stderr);
         const retainedEntry = h.inbox(child).find((entry) => entry.data?.['body'] === 'mail retained while profile is paused');
         assert.ok(retainedEntry, 'the message was durably appended');
-        assert.equal(readCursor(child), undefined, 'pause leaves the durable inbox cursor unadvanced');
+        assert.equal(acknowledgedNodeMailCount(child), 0, 'pause leaves the queued SQL delivery unacknowledged');
         const resumed = h.cli(null, ['profile', 'resume', profile.profileId]);
         assert.equal(resumed.code, 0, resumed.stderr);
         await h.awaitFleetExit(child);
@@ -47,7 +47,7 @@ test('profile pause backgrounds real bash, retains its inbox cursor, and recover
         assert.equal(existsSync(job.jobRun), false, 'the foreground valve ownership is gone');
         await h.waitFor(() => existsSync(job.jobExit), { label: 'background bash completion' });
         assert.equal(readFileSync(job.jobExit, 'utf8').trim(), '0', 'the handoff command completed after its broker exited');
-        assert.equal(readCursor(child), undefined, 'neither retained message nor background completion advanced the stopped broker cursor');
+        assert.equal(acknowledgedNodeMailCount(child), 0, 'neither retained message nor background completion acknowledges the stopped broker delivery');
         await h.tick();
         assert.equal(h.bootCount(child), 1, 'the first resumed policy pass only consumes the pause interruption');
         assert.equal(getRow(child)?.respawn_failures, 0, 'the intentional SIGTERM never counts as a crash');

package/dist/core/__tests__/integration/refresh-stall-recycle.test.js

@@ -21,13 +21,10 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
 import { spawn } from 'node:child_process';
-import { utimesSync } from 'node:fs';
-import { join } from 'node:path';
 import { createHeadlessHarness } from '../helpers/harness.js';
-import { getRow, recordLaunch, recordPid } from '../../canvas/canvas.js';
-import { jobDir } from '../../canvas/paths.js';
+import { getRow } from '../../canvas/canvas.js';
+import { abortExecution, beginExecution, recordExecutionPid } from '../../canvas/executions.js';
 import { isPidAlive } from '../../canvas/pid.js';
-import { markBusy } from '../../runtime/busy.js';
 import { BrokerSupervisionReconciler, yieldStallVerdict, YIELD_STALL_GRACE_MS } from '../../../daemon/reconcilers/broker-supervision.js';
 // D4a — the pure refresh-stall truth table.
 test('D4a yieldStallVerdict: kill ONLY a live, not-busy, refresh engine past the grace', () => {
@@ -61,7 +58,8 @@ test('D4b daemon force-recycles a stuck refresh: a live, not-busy refresh engine
         // A live broker records its launch-time identity with its pid. The force
         // signal re-verifies that identity, so this fixture must model the
         // production record rather than a legacy identity-less row.
-        recordPid(id, enginePid);
+        const executionId = beginExecution(id, { daemonEpoch: h.fleet.epoch() });
+        recordExecutionPid(executionId, id, enginePid);
         // Post-cutover the live-fleet pass iterates fleet ENTRIES, not rows: a
         // live broker IS a fleet entry (design D-1). Model the launch-time
         // registration the production host performs, with a never-resolving
@@ -103,8 +101,8 @@ test('D4c yield escalation is scoped to the broker that received SIGTERM', { tim
             pi_pid: original.pid,
             pi_session_id: 'sess-d4c',
         });
-        recordLaunch(id, new Date(T0).toISOString());
-        recordPid(id, original.pid);
+        const originalExecution = beginExecution(id, { daemonEpoch: h.fleet.epoch() });
+        recordExecutionPid(originalExecution, id, original.pid);
         h.fleet.register(id, { pid: original.pid, exited: new Promise(() => { }) });
         const supervisor = new BrokerSupervisionReconciler();
         const context = () => ({
@@ -119,15 +117,14 @@ test('D4c yield escalation is scoped to the broker that received SIGTERM', { tim
             timeoutMs: 10_000,
         });
         h.fleet.forget(id);
-        markBusy(id); // interrupted predecessor witness must not block the replacement's refresh timer
-        utimesSync(join(jobDir(id), 'busy'), T_KILL / 1_000, T_KILL / 1_000);
+        abortExecution(originalExecution, { reason: 'test replacement' });
         replacement = spawn(process.execPath, ['-e', 'process.on("SIGTERM", () => {}); console.log("ready"); setInterval(() => {}, 1000)'], { stdio: ['ignore', 'pipe', 'ignore'] });
         await new Promise((resolve, reject) => {
             replacement.stdout.once('data', () => resolve());
             replacement.once('error', reject);
         });
-        recordLaunch(id, new Date(T_KILL + 1).toISOString());
-        recordPid(id, replacement.pid);
+        const replacementExecution = beginExecution(id, { daemonEpoch: h.fleet.epoch() });
+        recordExecutionPid(replacementExecution, id, replacement.pid);
         h.fleet.register(id, { pid: replacement.pid, exited: new Promise(() => { }) });
         const replacementStarted = T_KILL + KILL_ESCALATE_MS + 1;
         await supervisor.run(replacementStarted, context());