@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/integration/spawn-root.test.js

@@ -1,536 +0,0 @@
-// spawnNode: provenance (spawned_by) is decoupled from the spine (parent +
-// subscription). A managed child gets both; an independent root gets provenance
-// only — no subscription wires back to the spawner.
-import { test, before, after, beforeEach } 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 { createServer } from 'node:net';
-import { spawn as spawnProcess } from 'node:child_process';
-import { createNode, getNode, getRow, subscribersOf } from '../../canvas/canvas.js';
-import { coalesce } from '../../feed/inbox.js';
-import { coalesceBrokerInbox } from '../../runtime/broker/inbox.js';
-import { closeDb, migrate, openDb } from '../../canvas/db.js';
-import { resetSession } from '../../canvas/sessions.js';
-import { closeScopedStores } from '../../scoped-state/db.js';
-import { initializeFreshScopedStore } from '../../scoped-state/migrate.js';
-import { userScopeRoot } from '../../scope.js';
-import { nodeDir } from '../../canvas/paths.js';
-import { spawnNode } from '../../runtime/nodes.js';
-import { readGoal } from '../../runtime/kickoff.js';
-import { spawnChild, resolveSpawner } from '../../runtime/spawn.js';
-import { headlessBrokerHost } from '../../runtime/host.js';
-import { resetFleetForTests } from '../../runtime/fleet.js';
-import { bindTestFleet } from '../helpers/fleet.js';
-import { recordFault } from '../../canvas/recovery.js';
-import { piSessionsRoot } from '../../runtime/pi-vendored.js';
-import { emptyContextExposureState, exposureTarget, loadContextExposureState, registerExposure, saveContextExposureState, } from '../../substrate/injected-store.js';
-import { ROOT_PROFILE_ID } from '../../profiles/manifest.js';
-let home;
-let scopedHome;
-let previousHome;
-let previousPidfile;
-function initializeTestUserScope() {
-    initializeFreshScopedStore({ kind: 'user', root: userScopeRoot() });
-}
-function mailFor(nodeId) {
-    return openDb().prepare(`SELECT m.message_id, m.operation_id, m.created_at, m.sender_node_id, m.sender_name, m.kind, m.label, m.body_ref, m.body_json, m.disposition, 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 = ? AND d.canceled_at IS NULL
-      ORDER BY m.seq`).all(nodeId).map((row) => ({
-        entry_id: row['message_id'],
-        operation_id: row['operation_id'],
-        ts: row['created_at'],
-        from: row['sender_node_id'],
-        ...(row['sender_name'] === null ? {} : { from_name: row['sender_name'] }),
-        tier: row['urgency'],
-        kind: row['kind'],
-        ...(row['body_ref'] === null ? {} : { ref: row['body_ref'] }),
-        label: row['label'],
-        ...(row['body_json'] === null ? {} : { data: JSON.parse(row['body_json']) }),
-        ...(row['disposition'] === null ? {} : { disposition: row['disposition'] }),
-    }));
-}
-function spawner(id) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'resident',
-        status: 'active',
-    };
-}
-before(() => {
-    // Unix-domain socket paths are capped at ~104 bytes on macOS; keep the
-    // canvas home short because root readiness now opens a real view.sock.
-    home = mkdtempSync('/tmp/crtr-spawn-root-');
-    scopedHome = mkdtempSync('/tmp/crtr-spawn-root-scope-');
-    previousHome = process.env['HOME'];
-    process.env['HOME'] = scopedHome;
-    process.env['CRTR_HOME'] = home;
-    previousPidfile = process.env['CRTR_PIDFILE'];
-    process.env['CRTR_PIDFILE'] = join(home, 'crtrd.pid');
-    // Every launcher claims a slot from the ledger before it reaches the host, so
-    // a spawn in-process needs a bound fleet (D-2).
-    bindTestFleet();
-});
-beforeEach(() => {
-    closeDb();
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    rmSync(userScopeRoot(), { recursive: true, force: true });
-    mkdirSync(home, { recursive: true });
-    migrate(openDb());
-    initializeTestUserScope();
-    // These tests exercise direct spawn behavior, not daemon autostart. Keep
-    // ensureDaemon() from launching a background daemon whose startup verifier
-    // would outlive the test's next CRTR_HOME reset.
-    writeFileSync(join(home, 'crtrd.pid'), `${process.pid}\n`);
-});
-after(() => {
-    closeDb();
-    closeScopedStores();
-    resetFleetForTests();
-    rmSync(home, { recursive: true, force: true });
-    rmSync(scopedHome, { recursive: true, force: true });
-    if (previousHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = previousHome;
-    if (previousPidfile === undefined)
-        delete process.env['CRTR_PIDFILE'];
-    else
-        process.env['CRTR_PIDFILE'] = previousPidfile;
-});
-test('managed child: parent on the spine + active subscription + provenance', async () => {
-    createNode(spawner('A'));
-    const child = await spawnNode({ kind: 'developer', cwd: '/tmp/work', parent: 'A', creator: 'A' });
-    const meta = getNode(child.node_id);
-    assert.equal(meta.parent, 'A', 'child keeps its spine parent');
-    assert.equal(meta.spawned_by, 'A', 'child provenance defaults to its parent');
-    assert.equal(meta.lifecycle, 'terminal', 'a plain child is terminal');
-    const subs = subscribersOf(child.node_id);
-    assert.equal(subs.length, 1, 'exactly one subscriber (the parent)');
-    assert.equal(subs[0].node_id, 'A');
-    assert.equal(subs[0].active, true, 'parent subscription is active');
-});
-test('external child birth is deferred, persists its creator, and renders its age at delivery in both inbox mirrors', async () => {
-    createNode(spawner('A'));
-    const creator = await spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null, name: 'Core' });
-    const child = await spawnNode({ kind: 'developer', cwd: '/tmp/work', parent: 'A', creator: creator.node_id, name: 'worker' });
-    const saved = getNode(child.node_id);
-    assert.equal(saved.creator, creator.node_id, 'creator persists through meta.json and getNode');
-    const [entry] = mailFor('A');
-    assert.ok(entry, 'the parent receives exactly one birth entry');
-    assert.equal(entry.from, child.node_id, 'birth groups with the child’s future reports');
-    assert.equal(entry.tier, 'deferred', 'birth never starts a parent cycle');
-    assert.equal(entry.data?.['body'], `worker (${child.node_id}, developer) was created under you by Core [[CRTR_BIRTH_ANNOUNCEMENT_AGE]] ago. For your awareness only — no response or action is needed, and no need to mention it unless asked. Treat its future reports as background you already know about; investigate only if something genuinely needs you.`);
-    for (const [elapsed, age] of [
-        [0, 'moments'],
-        [60_000, '1 minute'],
-        [59 * 60_000, '59 minutes'],
-        [60 * 60_000, '1 hour'],
-        [47 * 60 * 60_000, '47 hours'],
-        [48 * 60 * 60_000, '2 days'],
-    ]) {
-        const aged = { ...entry, ts: new Date(Date.now() - elapsed).toISOString() };
-        const daemonCard = coalesce([aged])[0].text;
-        // The two inbox readers deserialize the same JSON shape under distinct entry-id brands.
-        const brokerCard = coalesceBrokerInbox([aged], new Map())[0].text;
-        for (const card of [daemonCard, brokerCard]) {
-            assert.ok(card.includes(`created under you by Core ${age} ago`), 'the renderer, not the stored body, computes age at delivery');
-            assert.doesNotMatch(card, /\[\[CRTR_BIRTH_ANNOUNCEMENT_AGE\]\]/, 'the marker is not visible to the recipient');
-        }
-    }
-    await spawnNode({ kind: 'developer', cwd: '/tmp/work', parent: 'A', creator: 'A' });
-    assert.equal(mailFor('A').length, 1, 'a parent-created child stays silent');
-    await spawnNode({ kind: 'developer', cwd: '/tmp/work', parent: null });
-    assert.equal(mailFor('A').length, 1, 'a root never announces');
-});
-test('independent root: provenance only, no parent, no subscription', async () => {
-    createNode(spawner('A'));
-    const root = await spawnNode({
-        kind: 'developer',
-        cwd: '/tmp/work',
-        parent: null,
-        spawnedBy: 'A',
-        lifecycle: 'resident',
-    });
-    const meta = getNode(root.node_id);
-    assert.equal(meta.parent, null, 'a root has no spine parent (top-level)');
-    assert.equal(meta.spawned_by, 'A', 'a root still records who spawned it');
-    assert.equal(meta.lifecycle, 'resident', 'a root is resident');
-    assert.equal(subscribersOf(root.node_id).length, 0, 'nobody is subscribed to an independent root — the spawner is not woken by it');
-});
-test('resolveSpawner: a --root spawn needs no caller; a managed child does (regression)', () => {
-    // Bug-regression: `crtr node new --root` from a human shell (no CRTR_NODE_ID,
-    // no --parent) threw "spawnChild requires a calling node" even though a root
-    // has no spine parent and the spawner id is provenance only.
-    assert.equal(resolveSpawner(undefined, null, true), null, 'human root spawn: no caller is fine');
-    assert.equal(resolveSpawner(undefined, 'A', true), 'A', 'node root spawn: provenance recorded');
-    assert.equal(resolveSpawner('A', null, false), 'A', 'explicit parent satisfies a child spawn');
-    assert.throws(() => resolveSpawner(undefined, null, false), /requires a calling node/, 'a managed child with no caller still throws');
-});
-test('unknown parent: spawnNode throws and mints NO node dir / row (validate before create)', async () => {
-    // Pre-allocate the would-be id so we can prove nothing was scaffolded for it.
-    const orphanId = 'orphan-under-ghost';
-    await assert.rejects(() => spawnNode({ kind: 'developer', cwd: '/tmp/work', parent: 'ghost', nodeId: orphanId }), /cannot spawn under unknown parent node: ghost/);
-    // No half-born orphan: no meta (getNode null), no db row, no node dir on disk.
-    assert.equal(getNode(orphanId), null, 'no meta.json written for the orphan');
-    assert.equal(getRow(orphanId), null, 'no index row written for the orphan');
-    assert.equal(existsSync(nodeDir(orphanId)), false, 'no node dir scaffolded for the orphan');
-});
-test('spawnChild crashes the node when launch/preflight throws', async () => {
-    const parentId = 'A';
-    createNode(spawner(parentId));
-    const originalLaunch = headlessBrokerHost.launch;
-    let launchedNodeId = null;
-    try {
-        headlessBrokerHost.launch = (nodeId, _inv, _opts) => {
-            launchedNodeId = nodeId;
-            throw new Error('boom');
-        };
-        await assert.rejects(async () => spawnChild({ kind: 'developer', cwd: '/tmp/work', parent: parentId, prompt: 'task' }), /refusing to launch/i);
-        assert.ok(launchedNodeId !== null, 'the launch hook saw the spawned node id');
-        const after = getNode(launchedNodeId);
-        assert.equal(after.status, 'dead', 'failed spawn marks the node dead');
-        assert.equal(after.pi_pid, null, 'failed spawn clears the stale pid');
-    }
-    finally {
-        headlessBrokerHost.launch = originalLaunch;
-        closeDb();
-        rmSync(home, { recursive: true, force: true });
-    }
-});
-test('fork spawn resolves path and UUID provenance to the same transcript-only exposure seed', async () => {
-    const previousHome = process.env['HOME'];
-    const previousPiDir = process.env['PI_CODING_AGENT_DIR'];
-    const previousNodeId = process.env['CRTR_NODE_ID'];
-    const previousTmux = process.env['TMUX'];
-    const previousTmuxPane = process.env['TMUX_PANE'];
-    const localHome = mkdtempSync(join(tmpdir(), 'crtr-fork-seed-home-'));
-    const localCwd = mkdtempSync(join(tmpdir(), 'crtr-fork-seed-cwd-'));
-    const originalLaunch = headlessBrokerHost.launch;
-    const launched = [];
-    try {
-        process.env['HOME'] = localHome;
-        initializeTestUserScope();
-        process.env['PI_CODING_AGENT_DIR'] = join(localHome, 'pi-agent');
-        process.env['CRTR_NODE_ID'] = 'fork-source';
-        delete process.env['TMUX'];
-        delete process.env['TMUX_PANE'];
-        const sessionId = '12345678-1234-4234-8234-123456789abc';
-        const sourceFile = join(piSessionsRoot(), 'source-project', `2026-08-19T00-00-00-000Z_${sessionId}.jsonl`);
-        mkdirSync(join(piSessionsRoot(), 'source-project'), { recursive: true });
-        writeFileSync(sourceFile, `${JSON.stringify({
-            type: 'session',
-            version: 3,
-            id: sessionId,
-            timestamp: new Date().toISOString(),
-            cwd: localCwd,
-        })}\n`);
-        createNode({
-            ...spawner('fork-source'),
-            cwd: localCwd,
-        });
-        resetSession('fork-source', { sessionId, transcriptPath: sourceFile });
-        const canonicalSourceFile = getNode('fork-source').pi_session_file;
-        const sourceExposure = emptyContextExposureState();
-        registerExposure(exposureTarget(sourceExposure, 'system'), 'source-system', 'content');
-        registerExposure(exposureTarget(sourceExposure, 'transcript'), 'source-transcript', 'preview');
-        saveContextExposureState('fork-source', sourceExposure);
-        headlessBrokerHost.launch = (nodeId, inv) => {
-            launched.push({ nodeId, argv: inv.argv });
-            return { pid: process.pid, exited: new Promise(() => { }) };
-        };
-        const byPath = await spawnChild({
-            kind: 'developer',
-            cwd: localCwd,
-            root: true,
-            readiness: 'launch',
-            nodeId: 'fork-by-path',
-            prompt: 'path fork',
-            forkFrom: sourceFile,
-        });
-        const byUuid = await spawnChild({
-            kind: 'developer',
-            cwd: localCwd,
-            root: true,
-            readiness: 'launch',
-            nodeId: 'fork-by-uuid',
-            prompt: 'uuid fork',
-            forkFrom: sessionId,
-        });
-        for (const [result, rawOperand] of [[byPath, sourceFile], [byUuid, sessionId]]) {
-            const meta = getNode(result.node.node_id);
-            assert.equal(meta.fork_from, rawOperand);
-            assert.equal(meta.fork_source_file, canonicalSourceFile);
-            const exposure = loadContextExposureState(meta.node_id);
-            assert.deepEqual(exposure.exposures.get('source-transcript'), { transcript: 2 });
-            assert.equal(exposure.exposures.has('source-system'), false);
-            assert.equal(exposure.preferenceSnapshot, null);
-        }
-        assert.equal(launched.length, 2);
-        for (const launch of launched) {
-            const forkIndex = launch.argv.indexOf('--fork');
-            assert.ok(forkIndex >= 0, `${launch.nodeId} launches through Pi's fork seam`);
-            assert.equal(launch.argv[forkIndex + 1], canonicalSourceFile);
-        }
-    }
-    finally {
-        headlessBrokerHost.launch = originalLaunch;
-        closeScopedStores();
-        if (previousHome === undefined)
-            delete process.env['HOME'];
-        else
-            process.env['HOME'] = previousHome;
-        if (previousPiDir === undefined)
-            delete process.env['PI_CODING_AGENT_DIR'];
-        else
-            process.env['PI_CODING_AGENT_DIR'] = previousPiDir;
-        if (previousNodeId === undefined)
-            delete process.env['CRTR_NODE_ID'];
-        else
-            process.env['CRTR_NODE_ID'] = previousNodeId;
-        if (previousTmux === undefined)
-            delete process.env['TMUX'];
-        else
-            process.env['TMUX'] = previousTmux;
-        if (previousTmuxPane === undefined)
-            delete process.env['TMUX_PANE'];
-        else
-            process.env['TMUX_PANE'] = previousTmuxPane;
-        rmSync(localHome, { recursive: true, force: true });
-        rmSync(localCwd, { recursive: true, force: true });
-    }
-});
-test('spawnChild: a root from a shell gets the stable root profile id', async () => {
-    const previousHome = process.env.HOME;
-    const previousNodeId = process.env.CRTR_NODE_ID;
-    const previousTmux = process.env.TMUX;
-    const previousTmuxPane = process.env.TMUX_PANE;
-    const env = process.env;
-    const localHome = mkdtempSync(join(tmpdir(), 'crtr-spawn-root-home-'));
-    const localCwd = mkdtempSync(join(tmpdir(), 'crtr-spawn-root-cwd-'));
-    const originalLaunch = headlessBrokerHost.launch;
-    let broker;
-    const previousStdinTty = Object.getOwnPropertyDescriptor(process.stdin, 'isTTY');
-    const previousStdoutTty = Object.getOwnPropertyDescriptor(process.stdout, 'isTTY');
-    try {
-        process.env.HOME = localHome;
-        initializeTestUserScope();
-        Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true, writable: true });
-        Object.defineProperty(process.stdout, 'isTTY', { value: false, configurable: true, writable: true });
-        Reflect.deleteProperty(env, 'CRTR_NODE_ID');
-        delete process.env.TMUX;
-        delete process.env.TMUX_PANE;
-        headlessBrokerHost.launch = (nodeId, _inv, _opts) => {
-            broker = createServer();
-            broker.listen(join(nodeDir(nodeId), 'view.sock'));
-            return {
-                pid: process.pid,
-                exited: new Promise(() => { }),
-            };
-        };
-        const result = await spawnChild({ kind: 'developer', cwd: localCwd, root: true, readiness: 'await', prompt: 'task' });
-        const node = getNode(result.node.node_id);
-        assert.equal(node.profile_id, ROOT_PROFILE_ID, 'the root spawn persists the stable root profile id');
-        assert.equal(node.parent, null, 'a shell root has no spine parent');
-        assert.equal(node.lifecycle, 'resident', 'a shell root stays resident');
-        assert.equal(result.node.profile_id, ROOT_PROFILE_ID, 'the returned node view carries the stable root profile id');
-    }
-    finally {
-        headlessBrokerHost.launch = originalLaunch;
-        closeScopedStores();
-        if (previousHome === undefined)
-            delete process.env.HOME;
-        else
-            process.env.HOME = previousHome;
-        if (previousNodeId === undefined)
-            Reflect.deleteProperty(env, 'CRTR_NODE_ID');
-        else
-            env.CRTR_NODE_ID = previousNodeId;
-        if (previousTmux === undefined)
-            delete process.env.TMUX;
-        else
-            process.env.TMUX = previousTmux;
-        if (previousTmuxPane === undefined)
-            delete process.env.TMUX_PANE;
-        else
-            process.env.TMUX_PANE = previousTmuxPane;
-        if (previousStdinTty === undefined)
-            Reflect.deleteProperty(process.stdin, 'isTTY');
-        else
-            Object.defineProperty(process.stdin, 'isTTY', previousStdinTty);
-        if (previousStdoutTty === undefined)
-            Reflect.deleteProperty(process.stdout, 'isTTY');
-        else
-            Object.defineProperty(process.stdout, 'isTTY', previousStdoutTty);
-        await new Promise((resolve) => broker?.close(() => resolve()) ?? resolve());
-        rmSync(localHome, { recursive: true, force: true });
-        rmSync(localCwd, { recursive: true, force: true });
-    }
-});
-test('a no-kickoff root persists no goal and still comes up active', async () => {
-    // The `node new --root --no-kickoff` path: an empty prompt reaches
-    // buildPiArgv as `undefined`-equivalent, so the broker comes up idle and
-    // goal-less, ready for a real first prompt.
-    const originalLaunch = headlessBrokerHost.launch;
-    const localCwd = mkdtempSync(join(tmpdir(), 'crtr-no-kickoff-cwd-'));
-    let broker;
-    try {
-        headlessBrokerHost.launch = (nodeId, _inv, _opts) => {
-            broker = createServer();
-            broker.listen(join(nodeDir(nodeId), 'view.sock'));
-            return { pid: process.pid, exited: new Promise(() => { }) };
-        };
-        const result = await spawnChild({ kind: 'general', cwd: localCwd, root: true, readiness: 'await', prompt: '' });
-        assert.equal(readGoal(result.node.node_id), null, 'no goal file was written for an empty (no-kickoff) prompt');
-        assert.equal(getNode(result.node.node_id)?.status, 'active', 'the node still comes up active, ready for a real first prompt');
-    }
-    finally {
-        headlessBrokerHost.launch = originalLaunch;
-        await new Promise((resolve) => broker?.close(() => resolve()) ?? resolve());
-        rmSync(localCwd, { recursive: true, force: true });
-    }
-});
-test('root readiness is explicit: direct creation awaits its listener; deferred births launch immediately', async () => {
-    const originalLaunch = headlessBrokerHost.launch;
-    const localCwd = mkdtempSync(join(tmpdir(), 'crtr-spawn-ready-cwd-'));
-    const brokers = [];
-    const awaitLaunch = async (count) => {
-        const deadline = Date.now() + 5_000;
-        while (brokers.length < count) {
-            if (Date.now() >= deadline)
-                throw new Error(`broker launch ${count} did not occur`);
-            await new Promise((resolve) => setImmediate(resolve));
-        }
-    };
-    const settlesBeforeListener = async (promise) => {
-        let timeout;
-        try {
-            return await Promise.race([
-                promise.then(() => true),
-                new Promise((resolve) => { timeout = setTimeout(() => resolve(false), 1_000); }),
-            ]);
-        }
-        finally {
-            if (timeout)
-                clearTimeout(timeout);
-        }
-    };
-    try {
-        headlessBrokerHost.launch = (nodeId, _inv, _opts) => {
-            const server = createServer();
-            brokers.push({ nodeId, server });
-            return { pid: process.pid, exited: new Promise(() => { }) };
-        };
-        let directSettled = false;
-        const direct = spawnChild({ kind: 'developer', cwd: localCwd, root: true, readiness: 'await', prompt: 'direct' })
-            .then(() => { directSettled = true; });
-        await awaitLaunch(1);
-        await new Promise((resolve) => setImmediate(resolve));
-        assert.equal(directSettled, false, 'a directly created root remains pending before its listener binds');
-        brokers[0].server.listen(join(nodeDir(brokers[0].nodeId), 'view.sock'));
-        await direct;
-        const deferred = spawnChild({ kind: 'developer', cwd: localCwd, root: true, readiness: 'launch', prompt: 'deferred' });
-        await awaitLaunch(2);
-        assert.equal(await settlesBeforeListener(deferred), true, 'a deferred root birth returns without waiting for its listener');
-        // A managed child NEVER waits, even if a caller forwards readiness: 'await' —
-        // the readiness gate is root-only, so the daemon supervision loop can never
-        // be blocked by a child birth.
-        createNode(spawner('ready-parent'));
-        const child = spawnChild({ kind: 'developer', cwd: localCwd, parent: 'ready-parent', readiness: 'await', prompt: 'child' });
-        await awaitLaunch(3);
-        assert.equal(await settlesBeforeListener(child), true, 'a managed child never waits for its listener even with readiness: await');
-    }
-    finally {
-        headlessBrokerHost.launch = originalLaunch;
-        await Promise.all(brokers.filter(({ server }) => server.listening).map(({ server }) => new Promise((resolve) => server.close(() => resolve()))));
-        rmSync(localCwd, { recursive: true, force: true });
-    }
-});
-test('a live root that misses readiness is crashed and torn down before it can orphan', async () => {
-    const originalLaunch = headlessBrokerHost.launch;
-    const originalNow = Date.now;
-    const localCwd = mkdtempSync(join(tmpdir(), 'crtr-spawn-timeout-cwd-'));
-    const broker = spawnProcess('sleep', ['60'], { stdio: 'ignore' });
-    const exited = new Promise((resolve) => broker.once('exit', () => resolve()));
-    let nowCalls = 0;
-    let readinessStarted = false;
-    let launchedNodeId;
-    try {
-        headlessBrokerHost.launch = (nodeId) => {
-            launchedNodeId = nodeId;
-            readinessStarted = true;
-            return {
-                pid: broker.pid,
-                exited: new Promise(() => { }),
-            };
-        };
-        // Leave daemon/profile setup on the real clock; once the fake launch starts,
-        // let one failed probe occur, then advance past the readiness deadline.
-        Date.now = () => readinessStarted
-            ? [0, 0, 0, 30_001][Math.min(nowCalls++, 3)]
-            : originalNow();
-        await assert.rejects(() => spawnChild({ kind: 'developer', cwd: localCwd, root: true, readiness: 'await', prompt: 'timeout' }), /never bound its view socket/);
-        await exited;
-        assert.ok(launchedNodeId, 'the failed launch has a persisted node identity');
-        assert.equal(getNode(launchedNodeId)?.status, 'dead', 'timeout marks the row dead before teardown');
-        assert.equal(broker.signalCode, 'SIGTERM', 'the still-live broker is terminated after readiness timeout');
-    }
-    finally {
-        Date.now = originalNow;
-        headlessBrokerHost.launch = originalLaunch;
-        try {
-            broker.kill('SIGKILL');
-        }
-        catch { /* already torn down */ }
-        rmSync(localCwd, { recursive: true, force: true });
-    }
-});
-test('a root whose broker fatal-crashes at launch surfaces the recorded fault, not the opaque socket message', { timeout: 15_000 }, async () => {
-    const originalLaunch = headlessBrokerHost.launch;
-    const localCwd = mkdtempSync(join(tmpdir(), 'crtr-spawn-fault-cwd-'));
-    // A real (short-lived) process — a controlled Node sleeper rather than the
-    // platform `sleep` binary — so teardown targets it, not the test runner; its
-    // exit is what fails the readiness wait via the exit path (no view.sock is
-    // ever bound), the same shape as a broker whose launch-time model resolution
-    // fatally rejects before it can bind. Bounded by the test's own timeout, not
-    // this process's lifetime.
-    const broker = spawnProcess(process.execPath, ['-e', 'setInterval(() => {}, 1000)'], { stdio: 'ignore' });
-    const exited = new Promise((resolve) => broker.once('exit', (code, signal) => resolve({ code, signal })));
-    try {
-        headlessBrokerHost.launch = (nodeId) => {
-            // Mirrors resolveLaunchModel's fatal path (an unresolvable `--model` spec)
-            // recording a fault, then the broker dying before it binds view.sock.
-            recordFault(nodeId, {
-                link: 'crtr→pi',
-                op: 'model resolution at launch',
-                kind: 'model-not-found',
-                retry: { disposition: 'fatal' },
-                message: "model 'bogus' has no 'provider/id' form and cannot be resolved",
-            });
-            broker.kill('SIGKILL'); // die immediately → readiness fails via the exit path
-            return { pid: broker.pid, exited };
-        };
-        await assert.rejects(() => spawnChild({ kind: 'developer', cwd: localCwd, root: true, readiness: 'await', prompt: 'fault' }), (err) => {
-            assert.match(err.message, /model resolution at launch/);
-            assert.match(err.message, /provider\/id/);
-            assert.doesNotMatch(err.message, /never bound its view socket/);
-            return true;
-        });
-    }
-    finally {
-        headlessBrokerHost.launch = originalLaunch;
-        try {
-            broker.kill('SIGKILL');
-        }
-        catch { /* already gone */ }
-        rmSync(localCwd, { recursive: true, force: true });
-    }
-});

package/dist/core/__tests__/integration/subscription-delivery.test.d.ts

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