@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/__tests__/prospective-inventory-capability-parity.test.js

@@ -1,91 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { DefaultResourceLoader, ExtensionRunner, } from '@earendil-works/pi-coding-agent';
-import { captureChatCapabilities, registrationChatSurface } from '../runtime/command-surface.js';
-test('startup capability capture preserves same-name lifecycle replacements and excludes new lifecycle registrations', async () => {
-    const root = mkdtempSync(join(tmpdir(), 'crtr-prospective-capability-'));
-    const agentDir = join(root, '.pi');
-    const invoked = join(root, 'late-invoked');
-    mkdirSync(agentDir);
-    const first = join(root, 'first.js');
-    const second = join(root, 'second.js');
-    writeFileSync(first, `
-import { writeFileSync } from 'node:fs';
-export default function (pi) {
-  pi.registerCommand('collision', {
-    description: 'first factory command',
-    gateway: true,
-    argumentHint: '<first>',
-    handler: async () => {},
-  });
-  pi.on('session_start', () => {
-    pi.registerCommand('collision', {
-      description: 'lifecycle replacement',
-      argumentHint: '<replacement>',
-      handler: async () => {},
-    });
-    pi.registerCommand('late', {
-      description: 'lifecycle command',
-      gateway: true,
-      handler: async () => writeFileSync(${JSON.stringify(invoked)}, 'yes'),
-    });
-  });
-}
-`);
-    writeFileSync(second, `
-export default function (pi) {
-  pi.registerCommand('collision', {
-    description: 'second factory command',
-    gateway: true,
-    argumentHint: '<second>',
-    handler: async () => {},
-  });
-}
-`);
-    try {
-        const loader = new DefaultResourceLoader({
-            cwd: root,
-            agentDir,
-            additionalExtensionPaths: [first, second],
-            noContextFiles: true,
-        });
-        await loader.reload();
-        const loaded = loader.getExtensions();
-        assert.deepEqual(loaded.errors, []);
-        const runner = new ExtensionRunner(loaded.extensions, loaded.runtime, root, undefined, undefined);
-        const startupCommands = runner.getRegisteredCommands();
-        captureChatCapabilities({ commands: startupCommands, templates: [] });
-        const startupRows = startupCommands.map((command) => ({
-            name: command.invocationName,
-            ...registrationChatSurface(command),
-        }));
-        assert.deepEqual(startupRows, [
-            { name: 'collision:1', gatewayCapable: true, argumentHint: '<first>' },
-            { name: 'collision:2', gatewayCapable: true, argumentHint: '<second>' },
-        ]);
-        for (const extension of loaded.extensions) {
-            for (const handler of extension.handlers.get('session_start') ?? []) {
-                await handler({ type: 'session_start' }, {});
-            }
-        }
-        const reloadedRows = runner.getRegisteredCommands().map((command) => ({
-            name: command.invocationName,
-            ...registrationChatSurface(command),
-        }));
-        assert.deepEqual(reloadedRows, [
-            { name: 'collision:1', gatewayCapable: true, argumentHint: '<replacement>' },
-            { name: 'late', gatewayCapable: false },
-            { name: 'collision:2', gatewayCapable: true, argumentHint: '<second>' },
-        ]);
-        const late = runner.getCommand('late');
-        assert.ok(late, 'the lifecycle command remains registered and addressable');
-        await late.handler('', {});
-        assert.equal(existsSync(invoked), true, 'the lifecycle command remains invokable');
-    }
-    finally {
-        rmSync(root, { recursive: true, force: true });
-    }
-});

package/dist/core/__tests__/prune.test.d.ts

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

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

@@ -1,243 +0,0 @@
-import { test, before, after, beforeEach } from 'node:test';
-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, 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;
-const old = () => new Date(Date.now() - 30 * DAY).toISOString();
-const now = () => new Date().toISOString();
-// A timestamp `secondsAgo` before now — for the count-based pruner, created
-// order doubles as recency order (no telemetry.json is written, so recencyMs
-// falls back to the created epoch).
-const at = (secondsAgo) => new Date(Date.now() - secondsAgo * 1000).toISOString();
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: now(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-function totalEdges() {
-    return openDb().prepare('SELECT COUNT(*) AS n FROM edges').get().n;
-}
-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. */
-function seedFixture() {
-    createNode(node('old-dead', { status: 'dead', created: old() }));
-    createNode(node('old-done', { status: 'done', created: old() }));
-    createNode(node('old-canceled', { status: 'canceled', created: old() }));
-    createNode(node('old-active', { status: 'active', created: old() }));
-    createNode(node('old-idle', { status: 'idle', created: old() }));
-    createNode(node('recent-dead', { status: 'dead', created: now() }));
-    // A survivor subscribes to a pruned node (cascade on to_id) …
-    subscribe('old-active', 'old-dead', true);
-    // … and a pruned node's audit edge to another pruned node (cascade on both).
-    recordSpawn('old-done', 'old-dead');
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-prune-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-test('prune removes terminal nodes past the TTL and keeps live + recent ones', () => {
-    seedFixture();
-    assert.equal(totalEdges(), 2);
-    const result = pruneNodes({ ttlDays: 14 });
-    // The three old terminal nodes are pruned; nothing else.
-    assert.equal(result.dryRun, false);
-    assert.deepEqual(result.pruned.map((p) => p.node_id).sort(), ['old-canceled', 'old-dead', 'old-done']);
-    // Pruned rows are gone …
-    for (const id of ['old-dead', 'old-done', 'old-canceled']) {
-        assert.equal(getRow(id), null, `${id} row should be pruned`);
-    }
-    // … and the survivors remain (live-but-old + recent-but-dead).
-    for (const id of ['old-active', 'old-idle', 'recent-dead']) {
-        assert.ok(getRow(id) !== null, `${id} should survive`);
-    }
-});
-test('pruning cascade-deletes the pruned nodes\u2019 edges', () => {
-    seedFixture();
-    assert.equal(totalEdges(), 2);
-    pruneNodes({ ttlDays: 14 });
-    // Both edges touched a pruned node (old-dead) → both cascade away.
-    assert.equal(totalEdges(), 0);
-    // The surviving subscriber's edge to the pruned publisher is gone.
-    assert.deepEqual(subscriptionsOf('old-active'), []);
-    assert.deepEqual(subscribersOf('old-dead'), []);
-});
-test('pruning removes each pruned node\u2019s on-disk dir, leaves survivors\u2019 dirs', () => {
-    seedFixture();
-    assert.ok(existsSync(nodeDir('old-dead')));
-    assert.ok(existsSync(nodeDir('old-active')));
-    pruneNodes({ ttlDays: 14 });
-    assert.ok(!existsSync(nodeDir('old-dead')), 'pruned dir should be removed');
-    assert.ok(!existsSync(nodeDir('old-done')));
-    assert.ok(!existsSync(nodeDir('old-canceled')));
-    assert.ok(existsSync(nodeDir('old-active')), 'survivor dir should remain');
-    assert.ok(existsSync(nodeDir('recent-dead')));
-});
-test('--dry-run reports candidates but deletes nothing', () => {
-    seedFixture();
-    const before = totalEdges();
-    const result = pruneNodes({ ttlDays: 14, dryRun: true });
-    // Candidates are reported …
-    assert.equal(result.dryRun, true);
-    assert.deepEqual(result.pruned.map((p) => p.node_id).sort(), ['old-canceled', 'old-dead', 'old-done']);
-    // … but NOTHING is deleted: rows, edges, and dirs all intact.
-    for (const id of ['old-dead', 'old-done', 'old-canceled']) {
-        assert.ok(getRow(id) !== null, `${id} must survive a dry run`);
-        assert.ok(existsSync(nodeDir(id)), `${id} dir must survive a dry run`);
-    }
-    assert.equal(totalEdges(), before);
-});
-test('prune and the daemon operate on disjoint status sets', () => {
-    // active|idle (the daemon's domain) are NEVER pruned, even when ancient.
-    createNode(node('ancient-active', { status: 'active', created: old() }));
-    createNode(node('ancient-idle', { status: 'idle', created: old() }));
-    const result = pruneNodes({ ttlDays: 14 });
-    assert.equal(result.pruned.length, 0);
-    assert.ok(getRow('ancient-active') !== null);
-    assert.ok(getRow('ancient-idle') !== null);
-});
-test('prune retains an old terminal node with an open managed worktree', () => {
-    createNode(node('old-worktree', {
-        status: 'canceled',
-        created: old(),
-        managed_worktree: {
-            state: 'open',
-            path: join(home, 'worktrees', 'old-worktree'),
-            branch: 'crtr/old-worktree',
-            repo_root: '/tmp/repo',
-            base_ref: 'main',
-            base_sha: 'base',
-            created: old(),
-        },
-    }));
-    const result = pruneNodes({ ttlDays: 14 });
-    assert.deepEqual(result.pruned, []);
-    assert.ok(getRow('old-worktree') !== null, 'node remains to own its managed worktree');
-    assert.ok(existsSync(nodeDir('old-worktree')), 'node dir remains');
-});
-test('count pruning keeps all live nodes even when liveCount exceeds the cap', () => {
-    // 5 live (active/idle with a running pi) + 2 old terminal; cap of 3.
-    // target = max(3, 5) = 5, so NO live node is ever deleted; the 2 terminal
-    // fall beyond rank 5 and are pruned.
-    for (let i = 0; i < 5; i++) {
-        createNode(node(`live-${i}`, { status: 'active', created: at(i) }));
-        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) }));
-    markCollectibleTerminal('old-a');
-    markCollectibleTerminal('old-b');
-    const result = pruneToLimit({ maxNodes: 3 });
-    assert.equal(result.dryRun, false);
-    assert.deepEqual(result.pruned.map((p) => p.node_id).sort(), ['old-a', 'old-b']);
-    for (let i = 0; i < 5; i++) {
-        assert.ok(getRow(`live-${i}`) !== null, `live-${i} must survive past the cap`);
-    }
-});
-test('count pruning deletes the oldest terminal nodes beyond max(cap, liveCount)', () => {
-    // 1 live + 5 terminal of descending recency; cap of 3 → target = max(3,1) = 3.
-    // 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) }));
-    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) }));
-        markCollectibleTerminal(id);
-    }
-    const result = pruneToLimit({ maxNodes: 3 });
-    assert.deepEqual(result.pruned.map((p) => p.node_id).sort(), ['term-2', 'term-3', 'term-4']);
-    // The kept set: the live node + the two newest terminal.
-    for (const id of ['live-0', 'term-0', 'term-1']) {
-        assert.ok(getRow(id) !== null, `${id} must survive`);
-        assert.ok(existsSync(nodeDir(id)), `${id} dir must survive`);
-    }
-    // The pruned set: rows AND dirs gone.
-    for (const id of ['term-2', 'term-3', 'term-4']) {
-        assert.equal(getRow(id), null, `${id} row should be pruned`);
-        assert.ok(!existsSync(nodeDir(id)), `${id} dir should be removed`);
-    }
-});
-test('count pruning dry-run reports candidates without deleting rows or dirs', () => {
-    createNode(node('live-0', { status: 'idle', created: at(0) }));
-    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) }));
-        markCollectibleTerminal(id);
-    }
-    const result = pruneToLimit({ maxNodes: 3, dryRun: true });
-    assert.equal(result.dryRun, true);
-    assert.deepEqual(result.pruned.map((p) => p.node_id).sort(), ['term-2', 'term-3', 'term-4']);
-    for (const id of ['term-2', 'term-3', 'term-4']) {
-        assert.ok(getRow(id) !== null, `${id} row must survive a dry run`);
-        assert.ok(existsSync(nodeDir(id)), `${id} dir must survive a dry run`);
-    }
-});
-test('a non-terminal node with a dead pid is never a count-prune candidate (issue #114)', () => {
-    // An active row whose broker crashed: status stays 'active' but pi_pid is
-    // NULL (never recorded), so isPidAlive would be false. It must still be
-    // protected — crash-recovery, not the count-based pruner, owns this row —
-    // even though it's the oldest node and cap is exceeded by newer terminal rows.
-    createNode(node('crashed-active', { status: 'active', created: at(100) }));
-    for (let i = 0; i < 5; i++) {
-        createNode(node(`term-${i}`, { status: 'dead', created: at(i) }));
-    }
-    const result = pruneToLimit({ maxNodes: 3 });
-    assert.ok(!result.pruned.some((p) => p.node_id === 'crashed-active'), 'a crashed-but-active node must not be selected for pruning');
-    assert.ok(getRow('crashed-active') !== null, 'crashed-active row must survive');
-    assert.ok(existsSync(nodeDir('crashed-active')), 'crashed-active dir must survive');
-});
-test('count pruning retains an open managed worktree node beyond the cap', () => {
-    createNode(node('open-worktree', {
-        status: 'dead',
-        created: at(100),
-        managed_worktree: {
-            state: 'open',
-            path: join(home, 'worktrees', 'open-worktree'),
-            branch: 'crtr/open-worktree',
-            repo_root: '/tmp/repo',
-            base_ref: 'main',
-            base_sha: 'base',
-            created: at(100),
-        },
-    }));
-    for (let i = 0; i < 3; i++) {
-        createNode(node(`term-${i}`, { status: 'dead', created: at(i) }));
-    }
-    const result = pruneToLimit({ maxNodes: 1 });
-    assert.ok(!result.pruned.some((p) => p.node_id === 'open-worktree'));
-    assert.ok(getRow('open-worktree') !== null, 'node remains to own its managed worktree');
-    assert.ok(existsSync(nodeDir('open-worktree')), 'node dir remains');
-});

package/dist/core/__tests__/push-final-guard.test.d.ts

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

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

@@ -1,191 +0,0 @@
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-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, 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';
-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 });
-    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
-    process.env['CRTR_NODE_ID'] = prevNodeId; });
-test('done without a canonical marker accepts exactly one repair final', async () => {
-    const id = 'doneNode';
-    createNode(node(id));
-    setStatus(id, 'done');
-    process.env['CRTR_NODE_ID'] = id;
-    await pushFinal(id, 'repair final');
-    assert.ok(getNode(id)?.final_report);
-    await assert.rejects(() => pushFinal(id, 'second final'), (e) => e instanceof FinalizationError && e.code === 'already_finalized');
-});
-test('dead nodes reject finalization before publication', async () => {
-    const id = 'deadNode';
-    createNode(node(id));
-    setStatus(id, 'dead');
-    process.env['CRTR_NODE_ID'] = id;
-    await assert.rejects(() => pushFinal(id, 'x'), (e) => e instanceof FinalizationError && e.code === 'finalization_forbidden');
-    assert.equal(getNode(id)?.final_report, null);
-});
-// A finalized target accepts `node message send` only with `--reopen`, which
-// clears its live final-report pointer before delivery so its next `push final`
-// records the new mandate's canonical report. The handler rejects an ordinary
-// delivery before appending inbox content or reviving the target.
-// These subtests drive the daemon message handler (`POST /v1/nodes/:id/messages`)
-// directly against the real canvas DB. That is the production seam used by
-// `node message send`; only `headlessBrokerHost.launch` is stubbed to avoid a
-// real pi engine while preserving the reopen CAS and revival behavior.
-async function sendMessage(id, body) {
-    const ctx = { method: 'POST', path: `/v1/nodes/${id}/messages`, params: { id }, query: new URLSearchParams(), body };
-    return messageRoutes[0].handler(ctx);
-}
-/** The 422 the fresh-revive recoverable-state guard throws (a plain
- *  `{ status, code, message }`, the handler's fail-loud shape). */
-function isUnprocessable(e) {
-    const err = e;
-    return err?.status === 422 && err.code === 'unprocessable';
-}
-test('a finalized node re-tasked via node message send without --reopen is rejected BEFORE any side effect (no inbox append, no revive attempt); --reopen clears the latch, delivers, and the node re-latches on its next push final', async () => {
-    const id = 'retaskNode';
-    createNode(node(id));
-    process.env['CRTR_NODE_ID'] = id;
-    await pushFinal(id, 'round 1 verdict');
-    const firstFinal = getNode(id)?.final_report;
-    assert.ok(firstFinal);
-    // A message to the now-finalized node, no --reopen: rejected before the
-    // 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 = nodeMailCount(id);
-    const originalLaunch = headlessBrokerHost.launch;
-    let launchCalls = 0;
-    headlessBrokerHost.launch = ((...args) => { launchCalls++; return originalLaunch(...args); });
-    try {
-        await assert.rejects(() => sendMessage(id, { body: 'round 2: re-review the delta' }), (e) => e instanceof InputError && e.payload.error === 'node_finalized');
-    }
-    finally {
-        headlessBrokerHost.launch = originalLaunch;
-    }
-    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(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,
-    // but let everything else (the gate check, the CAS clear, the inbox append,
-    // the revive attempt itself) run for real. A NO-OP success with a non-null inert sentinel pid (the
-    // same pattern used elsewhere for a stubbed no-op engine): reviveNode
-    // treats a null pid as a launch failure and takes its real crash path
-    // (status -> 'dead'), which would then make the node's own later `push
-    // final` fail on an unrelated guard (finalization_forbidden) — an artifact
-    // of stubbing, not what this test is proving.
-    headlessBrokerHost.launch = (() => ({ pid: 0x7ffffffe, exited: Promise.resolve({ code: 0, signal: null }) }));
-    try {
-        const res = await sendMessage(id, { body: 'round 2: re-review the delta', reopen: true });
-        assert.equal(res.status, 201, 'the reopen delivery succeeded through the real handler');
-        assert.equal(res.body['delivered'], true, 'the message was delivered through the real handler seam');
-    }
-    finally {
-        headlessBrokerHost.launch = originalLaunch;
-    }
-    assert.equal(getNode(id)?.final_report, null, '--reopen cleared the latch through the real handler seam');
-    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');
-    const secondFinal = getNode(id)?.final_report;
-    assert.ok(secondFinal);
-    assert.notEqual(secondFinal, firstFinal, 'the new final is the canonical one, not the retracted round-1 file');
-});
-test('a rejected reopen-and-fresh delivery without recoverable state does NOT retract the canonical final', async () => {
-    const id = 'retaskFreshNoStateNode';
-    createNode(node(id));
-    process.env['CRTR_NODE_ID'] = id;
-    await pushFinal(id, 'round 1 verdict');
-    const firstFinal = getNode(id)?.final_report;
-    assert.ok(firstFinal);
-    // This node has no goal/roadmap on disk, so hasRecoverableState is false —
-    // the --fresh revive must be rejected. It must be rejected BEFORE the reopen
-    // clear runs, not after.
-    await assert.rejects(() => sendMessage(id, { fresh: true, reopen: true }), isUnprocessable);
-    assert.equal(getNode(id)?.final_report, firstFinal, 'a rejected --reopen --fresh must not retract the canonical final');
-});
-test('a sidecar-write failure during an reopen-and-fresh delivery does not retract the canonical final', async () => {
-    const id = 'sidecarFailNode';
-    createNode(node(id));
-    process.env['CRTR_NODE_ID'] = id;
-    await pushFinal(id, 'round 1 verdict');
-    const firstFinal = getNode(id)?.final_report;
-    assert.ok(firstFinal);
-    // Seed recoverable state so --fresh's own precondition passes and execution
-    // reaches the situational-context sidecar write.
-    writeGoal(id, 'the original mandate');
-    // Force a REAL fs failure in appendSituationalContext's writeFileSync — no
-    // mock, no injected seam: a DIRECTORY sits at the exact path the sidecar
-    // write targets, so the real write throws (EISDIR).
-    mkdirSync(situationalContextPath(id), { recursive: true });
-    await assert.rejects(() => sendMessage(id, { fresh: true, reopen: true, situational_context: 'now attached to /billing' }));
-    assert.equal(getNode(id)?.final_report, firstFinal, 'a sidecar-write failure BEFORE the clear must not retract the canonical final');
-});
-test('two concurrent --reopen calls cannot erase a newer final — the clear is CAS\'d against the exact latch each caller observed (#340 Major 1)', async () => {
-    const id = 'raceNode';
-    createNode(node(id));
-    process.env['CRTR_NODE_ID'] = id;
-    await pushFinal(id, 'final A');
-    const finalA = getNode(id).final_report;
-    // Both concurrent callers observe final A at their own gate check.
-    const observedByCallerOne = assertFinalizedForReopen(id);
-    const observedByCallerTwo = assertFinalizedForReopen(id);
-    assert.equal(observedByCallerOne, finalA);
-    assert.equal(observedByCallerTwo, finalA);
-    // Caller one commits first: clears the latch, the node revives and produces
-    // a NEW final B before caller two's delayed commit ever runs.
-    commitReopen(id, observedByCallerOne);
-    assert.equal(getNode(id)?.final_report, null);
-    process.env['CRTR_NODE_ID'] = id;
-    await pushFinal(id, 'final B');
-    const finalB = getNode(id).final_report;
-    assert.notEqual(finalB, finalA);
-    // Caller two's delayed commit, still holding its STALE observation (final A),
-    // must fail the compare instead of erasing final B.
-    assert.throws(() => commitReopen(id, observedByCallerTwo), (e) => e instanceof InputError && e.payload.error === 'reopen_latch_changed');
-    assert.equal(getNode(id)?.final_report, finalB, 'the newer canonical final must survive a stale concurrent reopen');
-});
-test('reviveNode refuses to revive a node that became finalized after the caller\'s no-reopen gate check (#340 Major 1, the other race direction)', async () => {
-    const id = 'lateFinalizeNode';
-    createNode(node(id));
-    // The caller's ordinary (non-reopen) gate check observes NOT latched — the
-    // common case, so it proceeds toward delivery/revive.
-    assertNotFinalized(id);
-    // But the target finalizes in the gap before the caller's revive actually
-    // runs (e.g. a resident orchestrator's own push final landing concurrently
-    // with an unrelated no-`--reopen` retask attempt).
-    process.env['CRTR_NODE_ID'] = id;
-    await pushFinal(id, 'concurrent final');
-    assert.equal(getNode(id)?.status, 'done');
-    await assert.rejects(reviveNode(id, { resume: true, capacity: 'freeze' }), /finaliz/i, 'reviveNode\'s own belt-and-suspenders check refuses a now-latched target');
-    assert.equal(getNode(id)?.status, 'done', 'the node stays done, never silently revived into an unsatisfiable mandate');
-});

package/dist/core/__tests__/relaunch-root.test.d.ts

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