@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/__tests__/seam/dormancy-release.test.js

@@ -1,516 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/seam/dormancy-release.test.ts
-//
-// The two real dormancy journeys of a live broker, sharing one harness and one
-// acting root:
-//
-//  (1) Issue #222/#353 — a real idle-release cycle must settle the inbox watcher
-//      before the broker exits, and the daemon may only revive for a later
-//      pending SQL delivery.
-//  (2) The observed 57-broker / ~5.4GB leak — DAEMON SUPERVISION, not an agent
-//      event, owns the unattended clock. A node with no live obligation is
-//      terminalized into prunable history (a resident completed its
-//      conversation; a terminal node parked without a final was torn down
-//      before finishing); one awaiting a child remains wakeable; an unclaimed
-//      warm-pool spare is exempt, because the booted broker it holds is its
-//      entire purpose. All of them release their broker and fleet slot except
-//      the spare, which keeps both.
-//
-// Both drive a real broker process through the real watcher/supervision paths, so
-// they belong to the compiled seam tier; neither needs tmux.
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { enqueueNodeMail } from '../../feed/messages.js';
-import { openDb } from '../../canvas/db.js';
-import { acquireCronRunLease, armCron, setCronState } from '../../canvas/crons.js';
-import { registerWarmSpare, subscribe, subscriptionsOf, updateNode } from '../../canvas/index.js';
-import { isPidAlive } from '../../canvas/pid.js';
-import { reviveNode } from '../../runtime/revive.js';
-import { createHarness } from '../helpers/harness.js';
-import { createAttachKit } from '../helpers/broker-clients.js';
-let h;
-let root;
-const attach = createAttachKit(() => h);
-function deliveryState(deliveryId) {
-    return openDb().prepare('SELECT state FROM deliveries WHERE delivery_id = ?').get(deliveryId)?.state;
-}
-function mailTo(nodeId) {
-    return openDb().prepare(`SELECT m.sender_node_id, m.body_json, m.label FROM deliveries d JOIN messages m ON m.message_id = d.message_id
-      WHERE d.destination_kind = 'node_inbox' AND d.destination_id = ? ORDER BY m.seq`).all(nodeId).map((row) => ({
-        sender: row.sender_node_id,
-        body: row.body_json === null ? null : JSON.parse(row.body_json),
-        label: row.label,
-    }));
-}
-before(async () => {
-    h = await createHarness({ headless: true, sessionPrefix: 'crtr-dormancy' });
-    root = h.spawnRoot('dormancy-release suite root');
-});
-after(async () => {
-    attach.closeAll();
-    if (h !== undefined)
-        await h.dispose();
-});
-async function awaitReleased(nodeId) {
-    await h.waitFor(() => {
-        const node = h.node(nodeId);
-        return node?.status === 'idle' && node.intent === 'idle-release' && typeof node.pi_pid === 'number' && !isPidAlive(node.pi_pid);
-    }, { label: `idle-release broker exit for ${nodeId}` });
-}
-async function assertCronWakeReleases(nodeId, running) {
-    const cronId = `${nodeId}-cron`;
-    const target = h.fabricateBrokerNode({ id: nodeId, parent: root, status: 'active' });
-    const now = new Date();
-    armCron({
-        cron_id: cronId,
-        name: cronId,
-        created_by: null,
-        command: 'printf wake',
-        fire_at: new Date(now.getTime() + 3_600_000).toISOString(),
-        recur: null,
-        tz: null,
-        expires_at: null,
-        anchor_node: nodeId,
-        cancel_on_wake: false,
-        cwd: h.home,
-        env_json: null,
-        profile: null,
-        scope: 'profile',
-        run_timeout_s: 30,
-        overlap: 'skip',
-        on_output: 'always',
-        sink: JSON.stringify({ node: nodeId }),
-        tier: 'normal',
-    });
-    if (running) {
-        assert.equal(acquireCronRunLease(cronId, 'seam-fixture', process.pid, now.toISOString(), false), true);
-        setCronState(cronId, 'paused');
-    }
-    updateNode(target, { launch: { extensions: [], tools: [], systemPrompt: '', env: {} } });
-    await reviveNode(target, { resume: true, capacity: 'freeze' });
-    await h.awaitBoot(target);
-    await h.stop(target);
-    await awaitReleased(target);
-    await h.awaitFleetExit(target);
-    assert.equal(h.node(target)?.status, 'idle', `${running ? 'running' : 'scheduled'} cron did not trigger a stop-guard reprompt`);
-}
-test('an anchored node-sink cron releases a terminal broker when scheduled or in flight', { timeout: 60_000 }, async () => {
-    await assertCronWakeReleases('scheduled-cron-wake', false);
-    await assertCronWakeReleases('running-cron-wake', true);
-});
-test('idle-release settles its real watcher before exit; daemon revives exactly once for a later row', { timeout: 30_000 }, async () => {
-    // Reproduce the observed #353/#362 edge: real pi reported
-    // ctx.hasPendingMessages() === true at the sole agent_settled even though the
-    // run had genuinely finished. Persisted on the manager's own launch.env
-    // (never ambient process.env) so BOTH this broker's launch AND its later
-    // daemon-driven revive for the second row see it: a CLI-spawned child's
-    // ambient env never reaches the broker child process (spawn-env.ts's
-    // default-deny allowlist only admits `inv.env`, which `nodeEnv()` derives
-    // from the node's persisted `meta.launch.env`, not the calling process's
-    // env) — so the manager is built by fabricating the row, persisting
-    // launch.env, and calling reviveNode rather than through `spawnHeadlessChild`.
-    //
-    // The same launch.env carries the REAL canvas-inbox-watcher's injectable
-    // cadence seam (CRTR_WATCHER_TICK_MS / CRTR_WATCHER_DEBOUNCE_MS). The
-    // ordinary source watcher suites drive it through ambient env because they
-    // run in-process. Keeping this compiled seam at production cadence would add
-    // multiple seconds of polling around two real broker boots, so it uses the
-    // same fast cadence without weakening what it proves: the settlement
-    // lifecycle, delivery acknowledgement semantics, and hasPendingMessages veto
-    // are all independent of how fast the watcher polls.
-    const manager = h.fabricateBrokerNode({ id: 'settle-veto-manager', status: 'idle', parent: root });
-    updateNode(manager, {
-        launch: {
-            extensions: [],
-            tools: [],
-            systemPrompt: '',
-            env: {
-                CRTR_RUNTIME_HOME: process.env['CRTR_RUNTIME_HOME'],
-                CRTR_FAKE_ENGINE_PENDING_AT_SETTLE: '1',
-                CRTR_WATCHER_TICK_MS: '20',
-                CRTR_WATCHER_DEBOUNCE_MS: '25',
-            },
-        },
-    });
-    await reviveNode(manager, { resume: true, capacity: 'freeze' });
-    await h.awaitBoot(manager);
-    // A live managed child makes this unfocused terminal manager legitimately
-    // awaiting, so its real stophook takes the idle-release branch.
-    const worker = h.fabricateBrokerNode({ parent: manager, status: 'idle', intent: 'idle-release' });
-    subscribe(manager, worker, true);
-    const first = enqueueNodeMail(manager, {
-        senderNodeId: 'worker-a',
-        kind: 'final',
-        label: 'first completed',
-        bodyJson: { body: 'first completed' },
-        urgency: 'normal',
-        wake: 1,
-    });
-    await h.awaitWake(manager, { match: /first completed/ });
-    // The real watcher injects an idle message, whose fake session now starts and
-    // settles its own prompt lifecycle: watcher → engine → stophook → settle →
-    // broker exit. No test-driven turn or settlement dispatch is involved.
-    await awaitReleased(manager);
-    await h.awaitFleetExit(manager);
-    assert.equal(deliveryState(first.deliveryId), 'acknowledged', 'the exact handed-off SQL delivery is acknowledged before clean shutdown');
-    const cyclesAfterRelease = h.node(manager).cycles ?? 0;
-    await h.tick();
-    assert.equal(h.node(manager).cycles ?? 0, cyclesAfterRelease, 'a second supervision tick does not revive a settled row');
-    const injectedBeforeSecond = h.injected(manager).length;
-    const second = enqueueNodeMail(manager, {
-        senderNodeId: 'worker-b',
-        kind: 'final',
-        label: 'second completed',
-        bodyJson: { body: 'second completed' },
-        urgency: 'normal',
-        wake: 1,
-    });
-    assert.equal(deliveryState(first.deliveryId), 'acknowledged', 'the first receipt remains terminal');
-    assert.equal(deliveryState(second.deliveryId), 'pending', 'the later delivery is independently pending');
-    await h.tick();
-    assert.equal(h.node(manager).cycles ?? 0, cyclesAfterRelease + 1, 'one later row revives once');
-    await h.awaitBoot(manager, { minCount: 2 });
-    await h.awaitWake(manager, { sinceCount: injectedBeforeSecond, match: /second completed/ });
-    await awaitReleased(manager);
-    await h.awaitFleetExit(manager);
-    assert.equal(deliveryState(second.deliveryId), 'acknowledged', 'the later delivery is acknowledged at its own natural idle release');
-    await h.tick();
-    assert.equal(h.node(manager).cycles ?? 0, cyclesAfterRelease + 1, 'the settled later row does not cause a duplicate revival');
-});
-test('an already idle resident with no live obligation reconciles into completed history', async () => {
-    const nodeId = h.fabricateBrokerNode({
-        id: 'idle-resident-without-obligation',
-        parent: root,
-        lifecycle: 'resident',
-        status: 'idle',
-        intent: 'idle-release',
-        pi_session_id: 'parked-session',
-    });
-    subscribe(root, nodeId, true);
-    await h.tick();
-    assert.equal(h.node(nodeId)?.status, 'done', 'an older idle row becomes pruning-eligible without needing a broker revive');
-    assert.equal(h.node(nodeId)?.intent, 'parked', 'the reconciled row carries the durable park marker (isParked)');
-    const wake = mailTo(root).find((entry) => entry.sender === nodeId && entry.body?.['reason'] === 'child-auto-done');
-    assert.ok(wake, 'the subscribing root learns that the parked resident completed without a final report');
-});
-test('an unattended resident with no live obligation completes on the daemon clock', { timeout: 30_000 }, async () => {
-    // The park clock is read per supervision pass (unattendedParkMsForDaemon), so
-    // it is armed for THIS test only — a file-global 1500ms park clock would also
-    // apply to the idle-release manager above and race its own release path.
-    //
-    // The clock no longer terminalizes directly: it arms a pending park and asks
-    // the live engine for one summary turn, and broker SETTLEMENT enacts the park
-    // on the good path. That settlement runs in the harness's separate api-server
-    // process, where the (deliberately process-local) pending park does not
-    // exist — so this seam pins the DEGRADED path: the summary grace expires on
-    // the supervision clock and the daemon parks without a report, fanning the
-    // doctrine wake. The settlement good path is covered by the in-process
-    // broker-settle tests.
-    const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-    const priorGraceMs = process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'];
-    process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';
-    process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'] = '1000';
-    try {
-        const nodeId = h.fabricateBrokerNode({
-            id: 'settled-no-work',
-            parent: root,
-            lifecycle: 'resident',
-            status: 'idle',
-            intent: 'idle-release',
-        });
-        updateNode(nodeId, {
-            launch: {
-                extensions: [],
-                tools: [],
-                systemPrompt: '',
-                env: {},
-            },
-        });
-        subscribe(root, nodeId, true);
-        await reviveNode(nodeId, { resume: true, capacity: 'freeze' });
-        const boot = await h.awaitBoot(nodeId);
-        assert.equal(h.fleet.has(nodeId), true, 'the revived broker is fleet-owned');
-        const seenAt = Date.now();
-        await h.tick(seenAt);
-        await h.tick(seenAt + 1499);
-        assert.equal(h.fleet.has(nodeId), true, 'the daemon keeps the broker through the full grace');
-        // Clock expiry: arms the pending park and requests the summary turn.
-        await h.tick(seenAt + 1500);
-        // Summary grace expiry: the degraded enactment parks without a report.
-        // The lifecycle tick applies the same park after a settled release.
-        await h.tick(seenAt + 1500 + 1000);
-        await h.waitFor(() => {
-            const node = h.node(nodeId);
-            return node?.status === 'done' && node.intent === 'parked' && !isPidAlive(boot.pid);
-        }, { timeoutMs: 10_000, intervalMs: 20, label: 'unattended park and broker exit' });
-        // The pid vanishing is not the fleet learning about it: wait for the child
-        // 'exit' delivery + its policy job, which is what actually frees the slot.
-        await h.awaitFleetExit(nodeId);
-        assert.equal(h.fleet.has(nodeId), false, 'exit policy forgets the parked broker');
-        assert.equal(h.node(nodeId)?.status, 'done', 'the row is terminal and eligible for history pruning');
-        const wake = mailTo(root).find((entry) => entry.sender === nodeId && entry.body?.['reason'] === 'child-auto-done');
-        assert.ok(wake, 'the subscribing root is woken when the unattended clock completes the resident');
-        assert.match(wake.label, /submitted no final report/, 'the wake distinguishes automatic completion from a final report');
-        await h.tick();
-        assert.equal(h.fleet.has(nodeId), false, 'a supervision tick does not revive completed history');
-    }
-    finally {
-        if (priorParkMs === undefined)
-            delete process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-        else
-            process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
-        if (priorGraceMs === undefined)
-            delete process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'];
-        else
-            process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'] = priorGraceMs;
-    }
-});
-test('a non-attending observer does not prevent unattended resident parking', { timeout: 30_000 }, async () => {
-    const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-    const priorGraceMs = process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'];
-    process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';
-    process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'] = '1000';
-    const nodeId = h.fabricateBrokerNode({
-        id: 'settled-with-system-observer',
-        parent: root,
-        lifecycle: 'resident',
-        status: 'idle',
-        intent: 'idle-release',
-    });
-    updateNode(nodeId, { launch: { extensions: [], tools: [], systemPrompt: '', env: {} } });
-    await reviveNode(nodeId, { resume: true, capacity: 'freeze' });
-    const boot = await h.awaitBoot(nodeId);
-    await attach.attach(nodeId, 'observer', 'system-observer-test', { attends: false });
-    assert.equal(JSON.parse(readFileSync(join(h.home, 'nodes', nodeId, 'job', 'attach.json'), 'utf8')).viewers, 0, 'a non-attending hello is not persisted as human attendance');
-    try {
-        const seenAt = Date.now();
-        await h.tick(seenAt);
-        await h.tick(seenAt + 1500);
-        await h.tick(seenAt + 1500 + 1000);
-        await h.waitFor(() => h.node(nodeId)?.status === 'done' && !isPidAlive(boot.pid), {
-            timeoutMs: 10_000,
-            intervalMs: 20,
-            label: 'system-observed unattended park and broker exit',
-        });
-        await h.awaitFleetExit(nodeId);
-    }
-    finally {
-        if (priorParkMs === undefined)
-            delete process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-        else
-            process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
-        if (priorGraceMs === undefined)
-            delete process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'];
-        else
-            process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'] = priorGraceMs;
-    }
-});
-test('a connected broker viewer keeps an obligation-free resident live', { timeout: 30_000 }, async () => {
-    const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-    process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';
-    const nodeId = h.fabricateBrokerNode({
-        id: 'settled-with-viewer',
-        parent: root,
-        lifecycle: 'resident',
-        status: 'idle',
-        intent: 'idle-release',
-    });
-    updateNode(nodeId, {
-        launch: {
-            extensions: [],
-            tools: [],
-            systemPrompt: '',
-            env: {},
-        },
-    });
-    await reviveNode(nodeId, { resume: true, capacity: 'freeze' });
-    const boot = await h.awaitBoot(nodeId);
-    // awaitBoot returns on the boot proof, which is written BEFORE the broker's
-    // own `persistAttachState()` lays down the truthful zero state. Writing our
-    // presence first lets that boot write clobber it, and the daemon then parks a
-    // node the test believes is attended — wait for the broker's file to exist.
-    const attachPath = join(h.home, 'nodes', nodeId, 'job', 'attach.json');
-    await h.waitFor(() => existsSync(attachPath), { timeoutMs: 20_000, intervalMs: 20, label: 'broker persists its boot attach state' });
-    // This is the presence written by a helloed direct attach, which has no
-    // focuses-table row because it did not pass through the focus opener.
-    writeFileSync(attachPath, JSON.stringify({ viewers: 1 }));
-    try {
-        const seenAt = 15_000;
-        await h.tick(seenAt);
-        await h.tick(seenAt + 1500);
-        assert.equal(h.fleet.has(nodeId), true, 'an attached viewer keeps the broker fleet-owned');
-        assert.equal(isPidAlive(boot.pid), true, 'an attached viewer keeps the broker process alive');
-        assert.ok(['active', 'idle'].includes(h.node(nodeId)?.status ?? ''), 'an attached viewer keeps the node live');
-    }
-    finally {
-        if (priorParkMs === undefined)
-            delete process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-        else
-            process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
-    }
-});
-test('an already idle terminal node with no live obligation reconciles into canceled', async () => {
-    const nodeId = h.fabricateBrokerNode({
-        id: 'idle-terminal-without-obligation',
-        parent: root,
-        status: 'idle',
-        intent: 'idle-release',
-        pi_session_id: 'parked-terminal-session',
-    });
-    await h.tick();
-    assert.equal(h.node(nodeId)?.status, 'canceled', 'a terminal row that never pushed a final settles as torn down, not completed');
-});
-test('the unattended park clock cancels an obligation-free terminal node and spares the warm pool', { timeout: 40_000 }, async () => {
-    const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-    process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';
-    try {
-        const boot = async (id) => {
-            updateNode(id, { launch: { extensions: [], tools: [], systemPrompt: '', env: {} } });
-            await reviveNode(id, { resume: true, capacity: 'freeze' });
-            return (await h.awaitBoot(id)).pid;
-        };
-        const settled = h.fabricateBrokerNode({ id: 'terminal-no-work', parent: root, status: 'idle', intent: 'idle-release' });
-        const awaiting = h.fabricateBrokerNode({ id: 'terminal-awaiting-child', parent: root, status: 'idle', intent: 'idle-release' });
-        const child = h.fabricateBrokerNode({ parent: awaiting, status: 'idle', intent: 'idle-release' });
-        subscribe(awaiting, child, true);
-        // Production spares mint as unparented residents, so this is the row shape
-        // the park clock actually meets in the fleet.
-        const spare = h.fabricateBrokerNode({ id: 'unclaimed-warm-spare', lifecycle: 'resident', status: 'idle', intent: 'idle-release' });
-        registerWarmSpare(spare, 'test-recipe-key');
-        const settledPid = await boot(settled);
-        const awaitingPid = await boot(awaiting);
-        const sparePid = await boot(spare);
-        const seenAt = 30_000;
-        await h.tick(seenAt);
-        await h.tick(seenAt + 1500);
-        await h.waitFor(() => h.node(settled)?.status === 'canceled' && !isPidAlive(settledPid), {
-            timeoutMs: 10_000,
-            intervalMs: 20,
-            label: 'unattended terminal cancellation and broker exit',
-        });
-        await h.awaitFleetExit(settled);
-        assert.equal(h.node(settled)?.status, 'canceled', 'a terminal node torn down without a final is prunable canceled history');
-        await h.waitFor(() => !isPidAlive(awaitingPid), { timeoutMs: 10_000, intervalMs: 20, label: 'awaiting terminal release' });
-        await h.awaitFleetExit(awaiting);
-        assert.equal(h.node(awaiting)?.status, 'idle', 'a live child keeps a terminal node eligible for an automatic wake');
-        assert.equal(h.fleet.has(spare), true, 'the park clock never reaps an unclaimed spare out from under the pool');
-        assert.equal(isPidAlive(sparePid), true, 'the spare keeps the booted broker that is its whole value');
-        assert.ok(['active', 'idle'].includes(h.node(spare)?.status ?? ''), 'the spare row stays claimable, left for reapStaleSpares to own');
-    }
-    finally {
-        if (priorParkMs === undefined)
-            delete process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-        else
-            process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
-    }
-});
-test('a resident managed child parks without finalizing while a terminal child is settled by the same grace sweep', { timeout: 40_000 }, async () => {
-    const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-    const priorGraceMs = process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'];
-    process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';
-    process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'] = '1000';
-    try {
-        const resident = h.fabricateBrokerNode({
-            id: 'resident-managed-child',
-            parent: root,
-            lifecycle: 'resident',
-            status: 'idle',
-            intent: 'idle-release',
-            pi_session_id: 'resident-managed-session',
-        });
-        subscribe(root, resident, true);
-        // Keep a managed terminal child in the same sweep, but make its parent
-        // historical so no live subscriber remains to hold an unfinished report.
-        const terminalManager = h.fabricateBrokerNode({ id: 'terminal-manager', status: 'done' });
-        const terminal = h.fabricateBrokerNode({
-            id: 'terminal-managed-child',
-            parent: terminalManager,
-            lifecycle: 'terminal',
-            status: 'idle',
-            intent: 'idle-release',
-            pi_session_id: 'terminal-managed-session',
-        });
-        subscribe(terminalManager, terminal, true);
-        const boot = async (id) => {
-            updateNode(id, { launch: { extensions: [], tools: [], systemPrompt: '', env: {} } });
-            await reviveNode(id, { resume: true, capacity: 'freeze' });
-            return (await h.awaitBoot(id)).pid;
-        };
-        const residentPid = await boot(resident);
-        const terminalPid = await boot(terminal);
-        const seenAt = Date.now();
-        await h.tick(seenAt);
-        // Clock expiry arms the resident's pending park and requests its summary
-        // turn; the terminal child is cancelled outright by the same pass.
-        await h.tick(seenAt + 1500);
-        // Summary grace expiry: the degraded enactment parks without a report.
-        await h.tick(seenAt + 1500 + 1000);
-        await h.waitFor(() => h.node(resident)?.status === 'done' && h.node(resident)?.intent === 'parked' && !isPidAlive(residentPid), {
-            timeoutMs: 10_000,
-            intervalMs: 20,
-            label: 'resident managed child parks and releases its broker',
-        });
-        await h.waitFor(() => h.node(terminal)?.status === 'canceled' && !isPidAlive(terminalPid), {
-            timeoutMs: 10_000,
-            intervalMs: 20,
-            label: 'terminal managed child settles and releases its broker',
-        });
-        await h.awaitFleetExit(resident);
-        await h.awaitFleetExit(terminal);
-        assert.equal(h.node(resident)?.intent, 'parked', 'resident child carries the durable park marker, not a final');
-        assert.equal(h.node(resident)?.final_report ?? null, null, 'resident child has no forced final report');
-        assert.ok(subscriptionsOf(root).some((edge) => edge.node_id === resident && edge.active), 'resident child keeps its active parent subscription');
-        assert.equal(h.node(terminal)?.status, 'canceled', 'terminal child is settled by unattended grace without a final');
-    }
-    finally {
-        if (priorParkMs === undefined)
-            delete process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-        else
-            process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
-        if (priorGraceMs === undefined)
-            delete process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'];
-        else
-            process.env['CRTR_TEST_PARK_SUMMARY_GRACE_MS'] = priorGraceMs;
-    }
-});
-test('an unattended resident awaiting a live child remains wakeable', { timeout: 30_000 }, async () => {
-    const priorParkMs = process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-    process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = '1500';
-    try {
-        const nodeId = h.fabricateBrokerNode({
-            id: 'settled-awaiting-child',
-            parent: root,
-            lifecycle: 'resident',
-            status: 'idle',
-            intent: 'idle-release',
-        });
-        const child = h.fabricateBrokerNode({ parent: nodeId, status: 'idle', intent: 'idle-release' });
-        subscribe(nodeId, child, true);
-        updateNode(nodeId, {
-            launch: {
-                extensions: [],
-                tools: [],
-                systemPrompt: '',
-                env: {},
-            },
-        });
-        await reviveNode(nodeId, { resume: true, capacity: 'freeze' });
-        const boot = await h.awaitBoot(nodeId);
-        const seenAt = 20_000;
-        await h.tick(seenAt);
-        await h.tick(seenAt + 1500);
-        await h.waitFor(() => {
-            const node = h.node(nodeId);
-            return node?.status === 'idle' && node.intent === 'idle-release' && !isPidAlive(boot.pid);
-        }, { timeoutMs: 10_000, intervalMs: 20, label: 'awaiting resident release and broker exit' });
-        await h.awaitFleetExit(nodeId);
-        assert.equal(h.node(nodeId)?.status, 'idle', 'a live child keeps the resident eligible for an automatic wake');
-    }
-    finally {
-        if (priorParkMs === undefined)
-            delete process.env['CRTR_TEST_UNATTENDED_PARK_MS'];
-        else
-            process.env['CRTR_TEST_UNATTENDED_PARK_MS'] = priorParkMs;
-    }
-});

package/dist/core/__tests__/seam/held-deferred-human-prompt.test.d.ts

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

package/dist/core/__tests__/seam/held-deferred-human-prompt.test.js

@@ -1,65 +0,0 @@
-// Run with: npm run build && node --test --test-timeout=180000 dist/core/__tests__/seam/held-deferred-human-prompt.test.js
-//
-// Regression: Pi loads canvas extensions through Jiti with moduleCache:false,
-// while broker frame dispatch is native ESM. Deferred mail held by the Jiti
-// watcher must still join the next human prompt driven by native broker code.
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { enqueueNodeMail } from '../../feed/messages.js';
-import { acknowledgedNodeMailCount } from '../../canvas/deliveries.js';
-import { updateNode } from '../../canvas/index.js';
-import { reviveNode } from '../../runtime/revive.js';
-import { createHeadlessHarness } from '../helpers/harness.js';
-import { createAttachKit, delay, frameHas, tok } from '../helpers/broker-clients.js';
-let h;
-let root;
-const kit = createAttachKit(() => h);
-before(async () => {
-    h = await createHeadlessHarness({ sessionPrefix: 'crtr-held-deferred-prompt' });
-    root = h.spawnRoot('held deferred prompt seam root');
-});
-after(async () => {
-    kit.closeAll();
-    if (h !== undefined)
-        await h.dispose();
-});
-test('a Jiti-loaded watcher prepends its held deferred batch to a native broker human prompt', { timeout: 30_000 }, async () => {
-    const nodeId = h.fabricateBrokerNode({
-        id: 'held-deferred-human-prompt',
-        parent: root,
-        lifecycle: 'resident',
-        status: 'idle',
-    });
-    updateNode(nodeId, {
-        launch: {
-            extensions: [],
-            tools: [],
-            systemPrompt: '',
-            env: {
-                CRTR_WATCHER_TICK_MS: '20',
-                CRTR_WATCHER_DEBOUNCE_MS: '25',
-            },
-        },
-    });
-    await reviveNode(nodeId, { resume: true, capacity: 'freeze' });
-    await h.awaitBoot(nodeId);
-    enqueueNodeMail(nodeId, {
-        senderNodeId: 'child',
-        kind: 'update',
-        label: 'held Jiti deferred update',
-        urgency: 'deferred',
-        wake: 1,
-    });
-    await delay(150);
-    const customPath = join(h.home, 'nodes', nodeId, 'fake-pi.custom-messages.jsonl');
-    assert.equal(existsSync(customPath), false, 'deferred-only mail stays held and does not wake the broker');
-    const controller = await kit.attach(nodeId, 'controller', 'held-deferred-prompt-controller');
-    const prompt = tok('HELD-DEFERRED-HUMAN-PROMPT');
-    controller.send({ type: 'prompt', text: prompt });
-    await controller.waitFrame((frame) => frame.type === 'agent_end' && frameHas(frame, prompt), 'the human prompt turn');
-    const customMessages = readFileSync(customPath, 'utf8');
-    assert.match(customMessages, /held Jiti deferred update/, 'the Jiti extension instance joined its held batch before the native broker prompt');
-    assert.equal(acknowledgedNodeMailCount(nodeId), 1, 'agent_settled acknowledges the joined SQL delivery');
-});

package/dist/core/__tests__/seam/inbox-reference-guidance.test.d.ts

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