@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/child-death-wake.test.js

@@ -1,153 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/child-death-wake.test.ts
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { createNode, getNode, subscribe } from '../canvas/canvas.js';
-import { closeDb, openDb, migrate } from '../canvas/db.js';
-import { beginExecution, recordExecutionPid } from '../canvas/executions.js';
-import { bindSession } from '../canvas/sessions.js';
-import { ensureScopeInitialized } from '../config.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { closeNode } from '../runtime/close.js';
-import { superviseTick } from '../../daemon/crtrd.js';
-import { bindTestFleet } from './helpers/fleet.js';
-import { resetFleetForTests } from '../runtime/fleet.js';
-import { headlessBrokerHost } from '../runtime/host.js';
-let home;
-let priorUserHome;
-let tf;
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-/** Write a minimal pi session with one assistant message so the node reads as
- *  NON-empty (produced AI output) — otherwise closeNode reaps it outright. */
-function withSession(id) {
-    const dir = join(home, 'sessions');
-    mkdirSync(dir, { recursive: true });
-    const f = join(dir, `${id}.jsonl`);
-    writeFileSync(f, JSON.stringify({ type: 'message', message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }] } }) + '\n');
-    return f;
-}
-/** A pid that is guaranteed dead. */
-function deadPid() {
-    const r = spawnSync('true', [], { stdio: 'ignore' });
-    return r.pid ?? 0x7ffffffe;
-}
-// A pane id no tmux server knows. In the broker cut the daemon IGNORES pane state
-// entirely (liveness is pid-only) — this just stands in for "the node once had a
-// viewer pane that is now gone," which must NOT count as a death.
-const GONE_PANE = '%999999';
-/** A booted child whose engine pid is DEAD and whose viewer pane is gone — the
- *  shape a crashed/finished child leaves behind. `pi_session_id` set so it is
- *  "booted"; `intent:null` selects policy row 6 (strict resume) when the
- *  authoritative tick observes the missing engine. */
-function deadEngineChild(id, over = {}) {
-    createNode(node(id, {
-        pane: GONE_PANE,
-        tmux_session: 'crtr-cdw',
-        window: '@1',
-        intent: null,
-        status: 'active',
-        ...over,
-    }));
-    const executionId = beginExecution(id, { daemonEpoch: 'test' });
-    assert.equal(bindSession(id, { executionId, sessionId: 'booted', transcriptPath: withSession(id) }), 'bound');
-    assert.equal(recordExecutionPid(executionId, id, deadPid()), 'recorded');
-}
-/** A dormant inbox-waiting PARENT — only ever the wake TARGET, asserted via its
- *  inbox. */
-function inboxWaitingParent(id) {
-    createNode(node(id, { status: 'active' }));
-}
-function nodeMail(nodeId) {
-    return openDb().prepare(`SELECT m.sender_node_id AS "from", 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);
-}
-const wakeFromChild = (parent, child) => nodeMail(parent).find((entry) => entry.from === child);
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-child-death-wake-'));
-    priorUserHome = process.env['HOME'];
-    process.env['HOME'] = home;
-    process.env['CRTR_HOME'] = home;
-    // superviseTick requires a bound fleet (D-2). It starts empty: none of these
-    // fabricated rows has a live broker.
-    tf = bindTestFleet();
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    ensureScopeInitialized('user', join(home, '.crouter'));
-    migrate(openDb());
-});
-after(() => {
-    closeDb();
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-    if (priorUserHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = priorUserHome;
-    resetFleetForTests();
-});
-test('a dead-engine booted child enters durable backoff before recovery, is NOT reaped, and fans NO wake to its dormant parent', async () => {
-    const originalLaunch = headlessBrokerHost.launch;
-    const launches = [];
-    headlessBrokerHost.launch = (nodeId) => {
-        launches.push(nodeId);
-        const handle = { pid: 424_242, exited: new Promise(() => { }) };
-        tf.fleet.register(nodeId, handle); // the real host contract: registration at the launch seam
-        return handle;
-    };
-    try {
-        inboxWaitingParent('PARENT');
-        deadEngineChild('CHILD', { cwd: home }); // a cwd that exists — reviveNode's preflight refuses a missing one
-        subscribe('PARENT', 'CHILD', true); // the spawn-time spine edge
-        await superviseTick();
-        const afterFirstTick = getNode('CHILD');
-        assert.deepEqual(launches, [], 'the first tick records the failed launch without relaunching');
-        assert.equal(afterFirstTick.respawn_failures, 1, 'the first tick records failure one durably');
-        assert.ok(afterFirstTick.respawn_not_before, 'the first tick records durable backoff');
-        await superviseTick(Date.parse(afterFirstTick.respawn_not_before));
-        // A stale recorded pid is metadata, not a verdict: once backoff matures,
-        // the row is relaunched on its saved session, never reaped to dead/done/idle.
-        assert.deepEqual(launches, ['CHILD'], 'the matured tick recovers the dead engine through the policy table');
-        assert.equal(getNode('CHILD').status, 'active', 'CHILD is recovered, NOT reaped');
-        assert.equal(nodeMail('PARENT').length, 0, 'PARENT has no delivery from daemon liveness');
-    }
-    finally {
-        headlessBrokerHost.launch = originalLaunch;
-        tf.fleet.forget('CHILD');
-    }
-});
-test('node close of a child wakes its SURVIVING manager (the parent outside the closing set)', async () => {
-    inboxWaitingParent('PARENT');
-    // A booted child; closeNode tears its (paneless-for-the-test) engine down.
-    createNode(node('CHILD', { pane: GONE_PANE, tmux_session: 'crtr-cdw', window: '@1', status: 'active' }));
-    const executionId = beginExecution('CHILD', { daemonEpoch: 'test' });
-    assert.equal(bindSession('CHILD', { executionId, sessionId: 'booted', transcriptPath: withSession('CHILD') }), 'bound');
-    subscribe('PARENT', 'CHILD', true); // PARENT is a manager OUTSIDE the close set
-    // Closing CHILD: closingSet({CHILD}) cannot pull in PARENT (PARENT is a
-    // SUBSCRIBER of CHILD, never a descendant), so PARENT survives + must wake.
-    const res = closeNode('CHILD');
-    assert.deepEqual(res.closed, ['CHILD'], 'only CHILD is closed; PARENT spared');
-    assert.equal(getNode('CHILD').status, 'canceled', 'CHILD canceled by close');
-    const wake = wakeFromChild('PARENT', 'CHILD');
-    assert.ok(wake, 'node close fanned a child-closed entry to the surviving manager (D-1: previously none)');
-    assert.match(wake.label, /closed/i, 'the entry names the closed child');
-});

package/dist/core/__tests__/cli-help-contract.test.d.ts

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

package/dist/core/__tests__/cli-help-contract.test.js

@@ -1,152 +0,0 @@
-// Help-contract gate for the whole command tree.
-// Run with: node --import tsx/esm --test src/core/__tests__/cli-help-contract.test.ts
-//
-// The cli-design rules that hold for every node are enforced here rather than
-// per command, because help text is written one command at a time and drifts
-// the same way every time: a branch ships its selection prose in the
-// description attribute, a rubric restates the description it sits beside, or
-// a constraint copied from a sibling leaf keeps naming a value this leaf's
-// enum rejects. Each rule below is mechanical — a judgment call about whether
-// a rubric actually helps an agent choose belongs to review, not to this file.
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { buildRoot } from '../../build-root.js';
-import { ensureScopeInitialized } from '../config.js';
-import { resetScopeCache } from '../scope.js';
-// buildRoot() composes external command-plugin branches from the effective
-// enabled plugins. Pin HOME to an isolated no-plugin home: a third party's
-// help text is not this repo's contract to enforce.
-let home;
-let realHome;
-let realProfile;
-before(() => {
-    realHome = process.env['HOME'];
-    realProfile = process.env['CRTR_PROFILE_ID'];
-    home = mkdtempSync(join(tmpdir(), 'crtr-help-contract-'));
-    delete process.env['CRTR_PROFILE_ID'];
-    process.env['HOME'] = home;
-    resetScopeCache();
-    ensureScopeInitialized('user', join(home, '.crouter'));
-});
-after(() => {
-    if (realHome !== undefined)
-        process.env['HOME'] = realHome;
-    else
-        delete process.env['HOME'];
-    if (realProfile !== undefined)
-        process.env['CRTR_PROFILE_ID'] = realProfile;
-    rmSync(home, { recursive: true, force: true });
-    resetScopeCache();
-});
-async function everyNode() {
-    const root = await buildRoot();
-    const out = [];
-    const visit = (node, path) => {
-        out.push({ node, path });
-        if (node.kind === 'branch')
-            for (const child of node.children)
-                visit(child, `${path} ${child.name}`);
-    };
-    for (const subtree of root.subtrees)
-        visit(subtree, subtree.name);
-    return out;
-}
-function normalize(text) {
-    if (text === undefined)
-        return '';
-    return text.toLowerCase().replace(/\s+/g, ' ').replace(/[.\s]+$/, '').trim();
-}
-function enumFlags(leaf) {
-    return (leaf.help.params ?? []).filter((param) => param.kind === 'flag' && param.type === 'enum' && param.choices !== undefined);
-}
-test('every branch offering a choice carries the model prose that frames it', async () => {
-    const offenders = [];
-    for (const { node, path } of await everyNode()) {
-        if (node.kind !== 'branch')
-            continue;
-        const choices = node.children.filter((child) => child.tier !== 'hidden');
-        if (choices.length < 2)
-            continue;
-        const model = node.help.model;
-        if (model === undefined || model.trim() === '')
-            offenders.push(`${path} (${choices.length} children)`);
-    }
-    assert.deepEqual(offenders, [], `branches with 2+ visible children and no help.model:\n  ${offenders.join('\n  ')}`);
-});
-test('no rubric restates the description it is read beside', async () => {
-    const offenders = [];
-    for (const { node, path } of await everyNode()) {
-        const description = normalize(node.description ?? '');
-        const rubric = normalize(node.whenToUse ?? '');
-        if (description === '' || rubric === '')
-            continue;
-        if (rubric === description || rubric.includes(description))
-            offenders.push(`${path}: whenToUse repeats "${node.description}"`);
-    }
-    assert.deepEqual(offenders, [], `rubrics restating their own description:\n  ${offenders.join('\n  ')}`);
-});
-// A constraint may name a value its own enum rejects only while saying so —
-// the copy-paste failure this catches states the foreign value as if it were
-// selectable. Vocabulary is per flag NAME, so it only fires where one flag
-// genuinely carries different choices on different leaves.
-const NEGATION = /\b(?:reject\w*|refus\w*|invalid|unsupported|forbid\w*|not\s+accepted)\b/i;
-test('no enum constraint names a value that enum does not accept', async () => {
-    const offenders = [];
-    for (const { node, path } of await everyNode()) {
-        if (node.kind !== 'branch')
-            continue;
-        const leaves = node.children.filter((child) => child.kind === 'leaf');
-        // Vocabulary is pooled across ONE branch's leaves, because that is where a
-        // constraint gets copied: two sibling verbs carrying the same flag with
-        // different choices. Pooling tree-wide would compare unrelated commands
-        // that merely share a flag name and flag ordinary English words that
-        // happen to be some distant enum's value.
-        const vocabulary = new Map();
-        for (const leaf of leaves) {
-            for (const flag of enumFlags(leaf)) {
-                const known = vocabulary.get(flag.name) ?? new Set();
-                for (const choice of flag.choices)
-                    known.add(choice.toLowerCase());
-                vocabulary.set(flag.name, known);
-            }
-        }
-        for (const leaf of leaves) {
-            for (const flag of enumFlags(leaf)) {
-                const own = new Set(flag.choices.map((choice) => choice.toLowerCase()));
-                const foreign = [...(vocabulary.get(flag.name) ?? [])].filter((value) => !own.has(value));
-                if (foreign.length === 0)
-                    continue;
-                for (const sentence of flag.constraint.split(/(?<=[.;:])\s+/)) {
-                    if (NEGATION.test(sentence))
-                        continue;
-                    const named = foreign.filter((value) => new RegExp(`\\b${value}\\b`, 'i').test(sentence));
-                    if (named.length > 0)
-                        offenders.push(`${path} ${leaf.name} --${flag.name}: names ${named.join(', ')} — accepts only ${flag.choices.join(', ')}`);
-                }
-            }
-        }
-    }
-    assert.deepEqual(offenders, [], `enum constraints naming values they reject:\n  ${offenders.join('\n  ')}`);
-});
-test('every leaf declares its effects, and none contradicts a claim of none', async () => {
-    const offenders = [];
-    for (const { node, path } of await everyNode()) {
-        if (node.kind !== 'leaf')
-            continue;
-        const effects = node.help.effects;
-        if (effects.length === 0 || effects.some((effect) => effect.trim() === '')) {
-            offenders.push(`${path}: declares no effects`);
-            continue;
-        }
-        // A leaf may describe what read-only means for it — several usefully do.
-        // What it may not do is open with "None" and then list effects underneath:
-        // an agent reading the first entry stops there.
-        if (effects.length > 1 && /^none\b/i.test(effects[0].trim())) {
-            offenders.push(`${path}: claims "${effects[0]}" and then lists ${effects.length - 1} more effect(s)`);
-        }
-    }
-    assert.deepEqual(offenders, [], `leaves with a broken effects declaration:\n  ${offenders.join('\n  ')}`);
-});

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

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

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

@@ -1,284 +0,0 @@
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync, readdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode as createRawNode, getNode, subscribe, subscriptionsOf } from '../canvas/canvas.js';
-import { nodeDir } from '../canvas/paths.js';
-import { closeDb, openDb, migrate } from '../canvas/db.js';
-import { beginExecution } from '../canvas/executions.js';
-import { bindSession } from '../canvas/sessions.js';
-import { closeNode } from '../runtime/close.js';
-import { reapEmptyNodes } from '../runtime/placement.js';
-function nodeMail(nodeId) {
-    return openDb().prepare(`SELECT m.sender_node_id AS "from", m.kind, m.label, m.body_ref AS ref, m.body_json AS data
-    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) => ({
-        ...row,
-        data: row.data === null ? null : JSON.parse(row.data),
-    }));
-}
-import { FinalizationError, pushFinal } from '../feed/feed.js';
-let home;
-/** Write a minimal pi session containing one assistant message, so the node
- *  reads as NON-empty (it produced AI output). Without this a node has no
- *  session and closeNode reaps it outright instead of cancel+notice — see the
- *  dedicated empty-reap test below. */
-function withSession(id) {
-    const dir = join(home, 'sessions');
-    mkdirSync(dir, { recursive: true });
-    const f = join(dir, `${id}.jsonl`);
-    writeFileSync(f, JSON.stringify({ type: 'message', message: { role: 'assistant', content: [{ type: 'text', text: 'hi' }] } }) + '\n');
-    return f;
-}
-function createNode(meta) {
-    const created = createRawNode(meta);
-    if (meta.pi_session_file !== null && meta.pi_session_file !== undefined) {
-        const executionId = beginExecution(meta.node_id, { daemonEpoch: 'test' });
-        assert.equal(bindSession(meta.node_id, { executionId, sessionId: meta.pi_session_id ?? meta.node_id, transcriptPath: meta.pi_session_file }), 'bound');
-    }
-    return created;
-}
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        pi_session_file: withSession(id),
-        ...over,
-    };
-}
-/** Wire `parent subscribes_to child` — the spawn-time edge (parent wakes on the
- *  child's pushes). The child is the publisher/down, the parent the manager/up. */
-function spawnEdge(parent, child) {
-    subscribe(parent, child, true);
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-close-'));
-    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('closes the root and its exclusive descendants; spares a shared node', () => {
-    // N ─▶ A ─▶ C        (A, C exclusive to the N subtree)
-    // N ─▶ B ◀─ M        (B also subscribed to by external manager M)
-    for (const id of ['N', 'A', 'B', 'C', 'M'])
-        createNode(node(id));
-    spawnEdge('N', 'A');
-    spawnEdge('N', 'B');
-    spawnEdge('A', 'C');
-    spawnEdge('M', 'B'); // external manager keeps B alive
-    const res = closeNode('N');
-    assert.deepEqual([...res.closed].sort(), ['A', 'C', 'N']);
-    assert.deepEqual(res.spared, ['B']);
-    // Closed nodes → canceled + intent cleared. (Broker-host cut: nodes carry NO
-    // engine pane/window/session — the viewer lives in the focuses table and is
-    // torn down asynchronously when the broker socket drops, so close no longer
-    // nulls a meta `pane`; viewer teardown is covered in the compiled-seam broker
-    // lifecycle suite.)
-    for (const id of ['N', 'A', 'C']) {
-        const m = getNode(id);
-        assert.equal(m.status, 'canceled', `${id} canceled`);
-        assert.equal(m.intent, null, `${id} intent cleared`);
-    }
-    // Spared node and the unrelated manager are untouched.
-    assert.equal(getNode('B').status, 'active');
-    assert.equal(getNode('M').status, 'active');
-});
-test('closing a middle node preserves its subscription edge and child provenance', () => {
-    createNode(node('A'));
-    createNode(node('B', { parent: 'A' }));
-    createNode(node('C', { parent: 'B' }));
-    spawnEdge('A', 'B');
-    spawnEdge('B', 'C');
-    closeNode('B');
-    assert.deepEqual(subscriptionsOf('B').map(({ node_id, active }) => ({ node_id, active })), [{ node_id: 'C', active: true }]);
-    assert.equal(getNode('B')?.parent, 'A');
-    assert.equal(getNode('C')?.parent, 'B');
-});
-test('kill order is leaves-first, root-last ("cascades up")', () => {
-    for (const id of ['N', 'A', 'C'])
-        createNode(node(id));
-    spawnEdge('N', 'A');
-    spawnEdge('A', 'C');
-    const res = closeNode('N');
-    assert.deepEqual(res.closed, ['C', 'A', 'N']);
-});
-test('appends a resume notice naming the dead children to each closed node', () => {
-    for (const id of ['N', 'A', 'C'])
-        createNode(node(id));
-    spawnEdge('N', 'A');
-    spawnEdge('A', 'C');
-    closeNode('N');
-    const nNotice = nodeMail('N').at(-1);
-    assert.equal(nNotice.from, null);
-    assert.equal(nNotice.kind, 'message');
-    assert.match(nNotice.label, /CLOSED by the user/);
-    assert.match(nNotice.label, /A \(A\)/); // dead child named
-    assert.deepEqual(nNotice.data?.['canceled_children'], ['A']);
-    assert.equal(nNotice.data?.['cascade_root'], 'N');
-    const aNotice = nodeMail('A').at(-1);
-    assert.match(aNotice.label, /CANCELED/);
-    assert.match(aNotice.label, /C \(C\)/);
-    // A leaf has no dead children — gets the short "session preserved" notice.
-    const cNotice = nodeMail('C').at(-1);
-    assert.match(cNotice.label, /session is preserved/);
-    assert.deepEqual(cNotice.data?.['canceled_children'], []);
-});
-test('diamond: a node reachable via two closing parents is closed', () => {
-    // N ─▶ A ─▶ D
-    // N ─▶ B ─▶ D   (D managed by A and B, both inside the closing set)
-    for (const id of ['N', 'A', 'B', 'D'])
-        createNode(node(id));
-    spawnEdge('N', 'A');
-    spawnEdge('N', 'B');
-    spawnEdge('A', 'D');
-    spawnEdge('B', 'D');
-    const res = closeNode('N');
-    assert.deepEqual([...res.closed].sort(), ['A', 'B', 'D', 'N']);
-    assert.deepEqual(res.spared, []);
-    assert.equal(getNode('D').status, 'canceled');
-});
-test('diamond with one external parent spares the shared node and its subtree', () => {
-    // N ─▶ A ─▶ D ─▶ E ; D also managed by external M  ⇒ D, E spared
-    for (const id of ['N', 'A', 'D', 'E', 'M'])
-        createNode(node(id));
-    spawnEdge('N', 'A');
-    spawnEdge('A', 'D');
-    spawnEdge('D', 'E');
-    spawnEdge('M', 'D');
-    const res = closeNode('N');
-    assert.deepEqual([...res.closed].sort(), ['A', 'N']);
-    assert.deepEqual(res.spared, ['D']);
-    assert.equal(getNode('D').status, 'active');
-    assert.equal(getNode('E').status, 'active'); // not descended into
-});
-test('closing a leaf node closes only itself', () => {
-    createNode(node('solo'));
-    const res = closeNode('solo');
-    assert.deepEqual(res.closed, ['solo']);
-    assert.deepEqual(res.spared, []);
-    assert.equal(getNode('solo').status, 'canceled');
-});
-test('throws on an unknown node', () => {
-    assert.throws(() => closeNode('ghost'), /unknown node/);
-});
-// #134: close and final publication serialize at the canonical-final boundary.
-// These sequential calls intentionally exercise each possible lock order without
-// timing or process-race support.
-test('close first suppresses a later final publication and its subscriber pointer', async () => {
-    createNode(node('child'));
-    createNode(node('manager'));
-    spawnEdge('manager', 'child');
-    closeNode('child');
-    await assert.rejects(() => pushFinal('child', 'too late'), (error) => error instanceof FinalizationError && error.code === 'finalization_forbidden');
-    assert.equal(getNode('child')?.final_report, null, 'close owns the terminal outcome');
-    assert.deepEqual(readdirSync(join(nodeDir('child'), 'reports')).filter((name) => name.endsWith('-final.md')), [], 'a rejected final leaves no canonical report');
-    assert.equal(nodeMail('manager').filter((entry) => entry.kind === 'final').length, 0, 'a rejected final never wakes a subscriber with a final pointer');
-});
-test('final publication first remains the one canonical final after close', async () => {
-    createNode(node('child'));
-    createNode(node('manager'));
-    spawnEdge('manager', 'child');
-    const publication = await pushFinal('child', 'completed');
-    const canonical = getNode('child')?.final_report;
-    assert.ok(canonical, 'publication commits a canonical final');
-    closeNode('child');
-    const child = getNode('child');
-    assert.equal(child.status, 'done', 'close cannot relabel a published final as canceled');
-    assert.equal(child.intent, 'done');
-    assert.equal(child.final_report, canonical, 'close preserves the original canonical marker');
-    assert.ok(existsSync(publication.reportPath), 'the canonical report remains on disk');
-    const finalPointers = nodeMail('manager').filter((entry) => entry.kind === 'final');
-    assert.equal(finalPointers.length, 1, 'the manager receives exactly one final pointer');
-    assert.equal(finalPointers[0]?.ref, `child:reports/${canonical}`);
-});
-// Regression: repair a pre-existing inconsistent row where final publication
-// completed but the lifecycle remained live. `cancel` is guarded by
-// `final_report IS NULL`, so it would silently no-op and leave this node active
-// for the daemon to revive forever.
-test('closing an active FINALIZED node repairs it to `done`, not a silent no-op', () => {
-    createNode(node('fin', { status: 'active', final_report: 'my final report' }));
-    const res = closeNode('fin');
-    assert.deepEqual(res.closed, ['fin']);
-    const finalized = getNode('fin');
-    assert.equal(finalized.status, 'done', 'finalized node lands `done`, never stays active or becomes canceled');
-    assert.equal(finalized.intent, 'done', 'intent set to done');
-});
-// Regression: empty nodes (engine never produced an assistant message) are
-// USELESS shells, so closing one must DELETE it from the graph + disk, not park
-// a canceled husk. (Reported: "many nodes on the canvas that haven't generated
-// anything yet, just taking up space" — close/detach now reap them.)
-test('closing an EMPTY node (no AI output) deletes it from the graph + disk', () => {
-    createNode(node('shell', { pi_session_file: null }));
-    const dir = nodeDir('shell');
-    assert.ok(existsSync(dir), 'dir exists before close');
-    const res = closeNode('shell');
-    assert.deepEqual(res.closed, ['shell']);
-    assert.equal(getNode('shell'), null, 'row deleted from the graph');
-    assert.equal(existsSync(dir), false, 'on-disk dir removed');
-});
-// An empty managed-worktree child must remain owned by its node after close;
-// otherwise its checkout has no node that can land it with `node worktree close`.
-test('closing an EMPTY node with an open managed worktree cancels it without reaping', () => {
-    const id = 'worktree-shell';
-    const worktreePath = join(home, 'worktrees', id);
-    mkdirSync(worktreePath, { recursive: true });
-    createNode(node(id, {
-        pi_session_file: null,
-        managed_worktree: {
-            state: 'open',
-            path: worktreePath,
-            branch: `crtr/${id}`,
-            repo_root: '/tmp/repo',
-            base_ref: 'main',
-            base_sha: 'base',
-            created: new Date().toISOString(),
-        },
-    }));
-    const dir = nodeDir(id);
-    const res = closeNode(id);
-    assert.deepEqual(res.closed, [id]);
-    const meta = getNode(id);
-    assert.equal(meta?.status, 'canceled', 'node remains revivable');
-    assert.equal(meta?.managed_worktree?.state, 'open', 'node retains worktree ownership');
-    assert.ok(existsSync(dir), 'node dir remains');
-    assert.ok(existsSync(worktreePath), 'managed checkout remains reachable through its node');
-    assert.match(nodeMail(id).at(-1)?.label ?? '', /session is preserved/);
-    assert.deepEqual(reapEmptyNodes(), [], 'bulk empty reap also preserves the open managed worktree node');
-    assert.equal(getNode(id)?.managed_worktree?.state, 'open', 'bulk reap retains worktree ownership');
-});
-// A close that reaps an EMPTY child still wakes a SURVIVING manager — the child
-// is gone either way, so a parent that delegated must learn it vanished.
-test('reaping an empty child still notifies a surviving external manager', () => {
-    createNode(node('child', { pi_session_file: null })); // empty → reaped
-    createNode(node('mgr')); // external manager, NOT closed
-    spawnEdge('mgr', 'child');
-    closeNode('child');
-    assert.equal(getNode('child'), null, 'empty child reaped');
-    const note = nodeMail('mgr').at(-1);
-    assert.match(note.label, /Child closed/);
-    assert.equal(note.data?.['child'], 'child');
-});
-// NOTE (broker-host cut): the former "Step 7: closing a FOCUSED node closes its
-// focus row + nulls its pane (tearDownNode)" test was DELETED. close.ts no longer
-// routes through the synchronous tearDownNode — it sends the broker `shutdown`
-// frame (headlessBrokerHost.teardown) and the viewer pane/focus row close on
-// their own when the broker socket drops (GC'd by the daemon + focusOf prune).
-// That async viewer teardown is covered by the compiled-seam broker-crash-teardown /
-// broker-lifecycle suite, which runs a real broker; it cannot be unit-tested
-// without one.

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

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