@north-light/crouter 0.3.317 → 0.3.319

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

@@ -1,498 +0,0 @@
-import assert from 'node:assert/strict';
-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;
-    const root = join(harness.agentHome, '.crouter', 'plugins', name);
-    mkdirSync(join(root, '.crouter-plugin'), { recursive: true });
-    writeFileSync(join(root, '.crouter-plugin', 'plugin.json'), JSON.stringify({
-        name,
-        version: '0.1.0',
-        description: 'lifecycle hook fixture',
-        hooks: 'hooks.json',
-        hookExecutable: 'bin/hook.js',
-    }));
-    writeFileSync(join(root, 'hooks.json'), JSON.stringify({
-        schemaVersion: 2,
-        lifecycle: ops.map((entry) => ({ event: 'node:start', phase: 'on', op: entry, description: `${entry} 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 { existsSync, writeFileSync } = require('node:fs');
-const { join } = require('node:path');
-let input = '';
-process.stdin.on('data', (chunk) => { input += chunk; });
-process.stdin.on('end', () => {
-  const request = JSON.parse(input);
-  writeFileSync(join(request.node.contextDir, 'lifecycle-order'), request.op + '\\n', { flag: 'a' });
-  if (request.op === 'record') writeFileSync(join(request.node.contextDir, 'lifecycle-request.json'), JSON.stringify(request));
-  if (request.op === 'hang') {
-    writeFileSync(join(request.node.contextDir, 'lifecycle-hang-started'), 'started');
-    setInterval(() => {}, 1000);
-    return;
-  }
-  if (request.op === 'bad') {
-    process.stdout.write('not a JSON envelope');
-    return;
-  }
-  if (request.op === 'nonzero') {
-    writeFileSync(join(request.node.contextDir, 'lifecycle-nonzero-started'), 'started');
-    process.stdout.write(JSON.stringify({ protocolVersion: 1, ok: true }));
-    process.exitCode = 1;
-    return;
-  }
-  process.stdout.write(JSON.stringify({ protocolVersion: 1, ok: true }));
-});
-`);
-    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 });
-    writeFileSync(join(root, '.crouter-plugin', 'plugin.json'), JSON.stringify({
-        name: 'z-v1-command', version: '0.1.0', description: 'v1 command hook fixture', hooks: 'hooks.json', hookExecutable: 'bin/hook.js',
-    }));
-    writeFileSync(join(root, 'hooks.json'), JSON.stringify({
-        schemaVersion: 1,
-        hooks: [{ target: 'sys version', phase: 'before', op: 'v1_check', description: 'v1 command hook', effects: ['writes fixture state'] }],
-    }));
-    const executable = join(root, 'bin', 'hook.js');
-    mkdirSync(join(root, 'bin'), { recursive: true });
-    writeFileSync(executable, `#!/usr/bin/env node
-const { writeFileSync } = require('node:fs');
-const { join } = require('node:path');
-let input = '';
-process.stdin.on('data', (chunk) => { input += chunk; });
-process.stdin.on('end', () => {
-  JSON.parse(input);
-  writeFileSync(join(__dirname, '..', 'v1-ran'), 'ran');
-  process.stdout.write(JSON.stringify({ protocolVersion: 1, ok: true }));
-});
-`);
-    chmodSync(executable, 0o755);
-    return join(root, 'v1-ran');
-}
-test('node:start hooks receive resolved paths before broker launch; invalid and hanging hooks do not block launch', async () => {
-    const harness = await createHarness({ headless: true, sessionPrefix: 'crtr-lifecycle-hooks' });
-    const originalLaunch = headlessBrokerHost.launch;
-    try {
-        installLifecyclePlugin(harness, 'aa-lifecycle-order', ['first', 'second']);
-        installLifecyclePlugin(harness, 'a-lifecycle-record', 'record');
-        installLifecyclePlugin(harness, 'b-lifecycle-bad', 'bad');
-        installLifecyclePlugin(harness, 'c-lifecycle-nonzero', 'nonzero');
-        installLifecyclePlugin(harness, 'd-lifecycle-hang', 'hang');
-        const v1Marker = installV1CommandHook(harness);
-        const show = harness.cli(null, ['--json', 'pkg', 'plugin', 'show', 'a-lifecycle-record', '--scope', 'user']);
-        assert.equal(show.code, 0, show.stderr);
-        assert.deepEqual(show.json.hooks.lifecycle, [{
-                event: 'node:start', phase: 'on', op: 'record', description: 'record fixture', effects: ['writes fixture state'],
-            }]);
-        const doctor = harness.cli(null, ['--json', 'sys', 'doctor', '--scope', 'user']);
-        assert.equal(doctor.code, 0, doctor.stderr);
-        const hookCheck = doctor.json.checks.find((check) => check.name === 'plugin:a-lifecycle-record:hooks');
-        assert.match(hookCheck?.message ?? '', /node:start \[on record; effects: writes fixture state\]/);
-        const nodeId = harness.fabricateBrokerNode({ id: 'lifecycle-hook-node', pi_pid: null, pi_session_id: null, pi_session_file: null });
-        const requestPath = join(contextDir(nodeId), 'lifecycle-request.json');
-        let requestExistedBeforeLaunch = false;
-        headlessBrokerHost.launch = ((id, ...args) => {
-            if (id === nodeId)
-                requestExistedBeforeLaunch = existsSync(requestPath);
-            return originalLaunch.call(headlessBrokerHost, id, ...args);
-        });
-        const startedAt = Date.now();
-        const starting = reviveNode(nodeId, { resume: false, capacity: 'freeze' });
-        const contender = await reviveNode(nodeId, { resume: false, capacity: 'freeze' });
-        const result = await starting;
-        const elapsedMs = Date.now() - startedAt;
-        await harness.awaitBoot(nodeId);
-        assert.equal(result.outcome, 'launched');
-        assert.equal(contender.outcome, 'already-live', 'a concurrent revive cannot cross the awaited hook gap');
-        assert.equal(requestExistedBeforeLaunch, true, 'the lifecycle hook finishes before broker launch');
-        assert.equal(existsSync(join(contextDir(nodeId), 'lifecycle-nonzero-started')), true, 'a non-zero executable ran without blocking launch');
-        assert.equal(existsSync(join(contextDir(nodeId), 'lifecycle-hang-started')), true, 'the hanging executable started and was subject to the lifecycle timeout');
-        assert.ok(elapsedMs >= 4_500 && elapsedMs < 8_000, `the 5s hanging hook was bounded before launch (${elapsedMs}ms)`);
-        assert.deepEqual(readFileSync(join(contextDir(nodeId), 'lifecycle-order'), 'utf8').trim().split('\n'), ['record', 'first', 'second', 'bad', 'nonzero', 'hang'], 'lifecycle hooks preserve plugin-name then declaration-index discovery order');
-        assert.equal(existsSync(v1Marker), false, 'a command-only v1 manifest adds no node-start subprocess');
-        const request = JSON.parse(readFileSync(requestPath, 'utf8'));
-        assert.equal(request.protocolVersion, 1);
-        assert.equal(request.op, 'record');
-        assert.equal(request.event, 'node:start');
-        assert.equal(request.phase, 'on');
-        assert.match(request.operationId, /^[0-9a-f]{32}$/);
-        assert.deepEqual(request.context, { cwd: harness.node(nodeId).cwd });
-        assert.deepEqual(request.node, {
-            id: nodeId,
-            name: nodeId,
-            kind: 'developer',
-            mode: 'base',
-            lifecycle: 'terminal',
-            cwd: harness.node(nodeId).cwd,
-            nodeDir: nodeDir(nodeId),
-            contextDir: contextDir(nodeId),
-            jobDir: jobDir(nodeId),
-            reportsDir: reportsDir(nodeId),
-        });
-        assert.deepEqual(request.runtime, { isBirth: true, canvasHome: harness.home, profile: null });
-        const v1Command = harness.cli(null, ['--json', 'sys', 'version']);
-        assert.equal(v1Command.code, 0, v1Command.stderr);
-        assert.equal(existsSync(v1Marker), true, 'a v1 command hook still executes around its declared command');
-    }
-    finally {
-        headlessBrokerHost.launch = originalLaunch;
-        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,
-        hooks: [{ target: 'canvas list', phase: 'before', op: 'check', description: 'check', effects: ['writes a log'] }],
-    });
-    assert.deepEqual(v1, {
-        manifest: {
-            schemaVersion: 1,
-            hooks: [{ target: 'canvas list', phase: 'before', op: 'check', description: 'check', effects: ['writes a log'] }],
-        },
-        issues: [],
-    });
-    const v2 = validateHookManifest({
-        schemaVersion: 2,
-        lifecycle: [{ event: 'node:start', phase: 'on', op: 'prepare', description: 'prepare', effects: ['creates a directory'] }],
-    });
-    assert.deepEqual(v2.issues, []);
-    assert.deepEqual(v2.manifest, {
-        schemaVersion: 2,
-        hooks: [],
-        lifecycle: [{ event: 'node:start', phase: 'on', op: 'prepare', description: 'prepare', effects: ['creates a directory'] }],
-    });
-    const close = validateHookManifest({
-        schemaVersion: 2,
-        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/live-mutation-verbs.test.d.ts

@@ -1 +0,0 @@
-export {};