@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/repository-root-identity.test.js

@@ -1,223 +0,0 @@
-// Repository-root project-memory identity: real Git and non-Git fixtures prove
-// that declarations live at a repository root while every nested store derives
-// its effective prefix from its physical owner path.
-//
-// Run: node --conditions=crtr-src --import tsx/esm --test src/core/__tests__/repository-root-identity.test.ts
-import { after, before, beforeEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { ensureScopeInitialized } from '../config.js';
-import { gitSync } from '../git.js';
-import { createProfile } from '../profiles/manifest.js';
-import { loadMemoryStoreView, memoryStoresInPrecedence, openProjectMemoryStore, resolveMemoryDocForTarget, } from '../memory-resolver.js';
-import { closeScopedStores } from '../scoped-state/db.js';
-import { resetScopeCache } from '../scope.js';
-const cleanups = [];
-let previousHome;
-before(() => {
-    previousHome = process.env.HOME;
-});
-beforeEach(() => {
-    process.env.HOME = fixtureDir('crtr-repository-root-identity-home-');
-    resetScopeCache();
-    ensureScopeInitialized('user', join(process.env.HOME, '.crouter'));
-});
-after(() => {
-    closeScopedStores();
-    resetScopeCache();
-    for (const path of cleanups)
-        rmSync(path, { recursive: true, force: true });
-    if (previousHome === undefined)
-        delete process.env.HOME;
-    else
-        process.env.HOME = previousHome;
-});
-function fixtureDir(prefix) {
-    const path = realpathSync(mkdtempSync(join(tmpdir(), prefix)));
-    cleanups.push(path);
-    return path;
-}
-function writeDoc(path, body, frontmatter) {
-    mkdirSync(join(path, '..'), { recursive: true });
-    const yaml = frontmatter === undefined ? '' : `---\n${frontmatter}\n---\n`;
-    writeFileSync(path, `${yaml}${body}\n`, 'utf8');
-}
-function writeStore(owner, namespace) {
-    const frontmatter = namespace === undefined ? undefined : `namespace: ${namespace}`;
-    writeDoc(join(owner, '.crouter', 'memory', 'INDEX.md'), 'STORE INDEX', frontmatter);
-}
-function initGit(repository) {
-    mkdirSync(repository, { recursive: true });
-    assert.equal(gitSync(['-C', repository, 'init', '-q'], undefined).status, 0, 'git init succeeds');
-}
-function commitInitial(repository) {
-    writeFileSync(join(repository, 'README.md'), 'fixture\n', 'utf8');
-    assert.equal(gitSync(['-C', repository, 'add', 'README.md'], undefined).status, 0);
-    assert.equal(gitSync(['-C', repository, '-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.com', 'commit', '-qm', 'initial'], undefined).status, 0);
-}
-function target(cwd, profileId = null) {
-    return { cwd, profileId, nodeId: null };
-}
-test('a Git root declaration gives a metadata-free nested store its repository-relative prefix', () => {
-    const repository = join(process.env.HOME, 'repository');
-    const nested = join(repository, 'packages', 'agent');
-    initGit(repository);
-    writeStore(repository, 'acme');
-    mkdirSync(join(nested, '.crouter', 'memory'), { recursive: true });
-    writeDoc(join(nested, '.crouter', 'memory', 'guide.md'), 'NESTED GUIDE');
-    const doc = resolveMemoryDocForTarget('acme/packages/agent/guide', target(nested), { scope: 'project' });
-    assert.equal(doc.path, join(nested, '.crouter', 'memory', 'guide.md'));
-    assert.equal(doc.name, 'acme/packages/agent/guide');
-    const store = openProjectMemoryStore(nested);
-    assert.equal(store.mountStatus, 'ready');
-    assert.equal(store.repositoryRoot, repository);
-    assert.equal(store.ownerRelativePath, 'packages/agent');
-    assert.equal(store.namespacePath, join(repository, '.crouter', 'memory', 'INDEX.md'));
-});
-test('repository-relative ordering prefixes are stripped before nested identity composition', () => {
-    const repository = join(process.env.HOME, 'repository');
-    const nested = join(repository, '01-api');
-    initGit(repository);
-    writeStore(repository, 'acme');
-    writeStore(nested);
-    writeDoc(join(nested, '.crouter', 'memory', 'guide.md'), 'ORDERED GUIDE');
-    const store = openProjectMemoryStore(nested);
-    assert.equal(store.mountStatus, 'ready');
-    assert.equal(store.ownerRelativePath, 'api');
-    assert.equal(store.namespace, 'acme/api');
-    const doc = resolveMemoryDocForTarget('acme/api/guide', target(nested), { scope: 'project' });
-    assert.equal(doc.path, join(nested, '.crouter', 'memory', 'guide.md'));
-    assert.equal(doc.name, 'acme/api/guide');
-});
-test('a metadata-free nested INDEX answers exactly at the nested effective prefix', () => {
-    const repository = join(process.env.HOME, 'repository');
-    const nested = join(repository, 'packages', 'agent');
-    initGit(repository);
-    writeStore(repository, 'acme');
-    writeStore(nested);
-    writeDoc(join(nested, '.crouter', 'memory', 'guide.md'), 'NESTED GUIDE');
-    const store = openProjectMemoryStore(nested);
-    assert.equal(store.mountStatus, 'ready');
-    assert.equal(store.namespace, 'acme/packages/agent');
-    const view = loadMemoryStoreView(store, true);
-    assert.deepEqual(view.docs.map((doc) => doc.name), ['acme/packages/agent', 'acme/packages/agent/guide']);
-    assert.equal(resolveMemoryDocForTarget('acme/packages/agent', target(nested), { scope: 'project' }).path, join(nested, '.crouter', 'memory', 'INDEX.md'));
-});
-test('linked worktree owners have identical canonical names from different physical paths', () => {
-    const main = join(process.env.HOME, 'main');
-    const linked = join(process.env.HOME, 'linked');
-    initGit(main);
-    commitInitial(main);
-    assert.equal(gitSync(['-C', main, 'worktree', 'add', '-q', '-b', 'linked', linked], undefined).status, 0);
-    const mainOwner = join(main, 'packages', 'agent');
-    const linkedOwner = join(linked, 'packages', 'agent');
-    writeStore(main, 'acme');
-    writeStore(linked, 'acme');
-    writeStore(mainOwner);
-    writeStore(linkedOwner);
-    writeDoc(join(mainOwner, '.crouter', 'memory', 'guide.md'), 'MAIN GUIDE');
-    writeDoc(join(linkedOwner, '.crouter', 'memory', 'guide.md'), 'LINKED GUIDE');
-    const mainDoc = resolveMemoryDocForTarget('acme/packages/agent/guide', target(mainOwner), { scope: 'project' });
-    const linkedDoc = resolveMemoryDocForTarget('acme/packages/agent/guide', target(linkedOwner), { scope: 'project' });
-    assert.equal(mainDoc.name, linkedDoc.name);
-    assert.equal(mainDoc.path, join(mainOwner, '.crouter', 'memory', 'guide.md'));
-    assert.equal(linkedDoc.path, join(linkedOwner, '.crouter', 'memory', 'guide.md'));
-    const mainStore = openProjectMemoryStore(mainOwner);
-    const linkedStore = openProjectMemoryStore(linkedOwner);
-    assert.equal(mainStore.repositoryKey, linkedStore.repositoryKey);
-    assert.notEqual(mainStore.repositoryRoot, linkedStore.repositoryRoot);
-});
-test('an embedded Git repository uses its own declaration from cwd and explicit store opening', () => {
-    const outer = join(process.env.HOME, 'outer');
-    const embedded = join(outer, 'vendor');
-    const nested = join(embedded, 'pkg');
-    initGit(outer);
-    writeStore(outer, 'outer');
-    initGit(embedded);
-    writeStore(embedded, 'inner');
-    writeStore(nested);
-    writeDoc(join(nested, '.crouter', 'memory', 'guide.md'), 'EMBEDDED GUIDE');
-    const fromCwd = resolveMemoryDocForTarget('inner/pkg/guide', target(nested), { scope: 'project' });
-    assert.equal(fromCwd.path, join(nested, '.crouter', 'memory', 'guide.md'));
-    const explicit = openProjectMemoryStore(nested);
-    assert.equal(explicit.repositoryRoot, embedded);
-    assert.equal(explicit.namespace, 'inner/pkg');
-    assert.equal(loadMemoryStoreView(explicit, true).resolve('inner/pkg/guide').path, fromCwd.path);
-});
-test('a non-Git nested store derives from the outermost ancestor project store', () => {
-    const root = join(process.env.HOME, 'non-git');
-    const nested = join(root, 'packages', 'agent');
-    writeStore(root, 'workspace');
-    writeStore(nested);
-    writeDoc(join(nested, '.crouter', 'memory', 'guide.md'), 'NON-GIT GUIDE');
-    const store = openProjectMemoryStore(nested);
-    assert.equal(store.mountStatus, 'ready');
-    assert.equal(store.repositoryRoot, root);
-    assert.equal(store.repositoryKey, `path:${root}`);
-    assert.equal(store.ownerRelativePath, 'packages/agent');
-    assert.equal(store.namespace, 'workspace/packages/agent');
-    assert.equal(resolveMemoryDocForTarget('workspace/packages/agent/guide', target(nested), { scope: 'project' }).path, join(nested, '.crouter', 'memory', 'guide.md'));
-});
-test('a Git descendant without a root store is undeclared until the root declaration is created', () => {
-    const repository = join(process.env.HOME, 'repository');
-    const nested = join(repository, 'packages', 'agent');
-    initGit(repository);
-    writeStore(nested);
-    writeDoc(join(nested, '.crouter', 'memory', 'guide.md'), 'NESTED GUIDE');
-    const before = openProjectMemoryStore(nested);
-    assert.equal(before.mountStatus, 'undeclared');
-    assert.equal(before.mountFailure, 'undeclared-root');
-    assert.match(before.diagnostic ?? '', new RegExp(repository.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-    writeStore(repository, 'acme');
-    const after = openProjectMemoryStore(nested);
-    assert.equal(after.mountStatus, 'ready');
-    assert.equal(after.namespace, 'acme/packages/agent');
-});
-test('sibling owner paths that normalize to one prefix, including ordering prefixes, leave both stores invalid', () => {
-    const repository = join(process.env.HOME, 'repository');
-    const first = join(repository, '01-My Notes');
-    const second = join(repository, 'my-notes');
-    initGit(repository);
-    writeStore(repository, 'acme');
-    writeStore(first);
-    writeStore(second);
-    const profileId = createProfile('collision', [{ path: second, memory: 'content' }]).profileId;
-    const stores = memoryStoresInPrecedence(target(first, profileId), 'project');
-    const colliding = stores.filter((store) => store.ownerDir === first || store.ownerDir === second);
-    assert.equal(colliding.length, 2);
-    for (const store of colliding) {
-        assert.equal(store.mountStatus, 'invalid');
-        assert.equal(store.mountFailure, 'collision');
-        assert.equal(store.namespace, 'acme/my-notes');
-        assert.match(store.diagnostic ?? '', /My Notes/);
-        assert.match(store.diagnostic ?? '', /my-notes/);
-    }
-});
-test('profile presence and order do not change a nested store canonical name', () => {
-    const repository = join(process.env.HOME, 'repository');
-    const nested = join(repository, 'packages', 'agent');
-    const unrelated = join(process.env.HOME, 'unrelated');
-    initGit(repository);
-    writeStore(repository, 'acme');
-    writeStore(nested);
-    writeDoc(join(nested, '.crouter', 'memory', 'guide.md'), 'NESTED GUIDE');
-    mkdirSync(unrelated, { recursive: true });
-    const absent = resolveMemoryDocForTarget('acme/packages/agent/guide', target(nested), { scope: 'project' });
-    const rootSecond = createProfile('root-second', [
-        { path: unrelated, memory: 'content' },
-        { path: repository, memory: 'content' },
-    ]).profileId;
-    const rootFirst = createProfile('root-first', [
-        { path: repository, memory: 'content' },
-        { path: unrelated, memory: 'content' },
-    ]).profileId;
-    const withRootSecond = resolveMemoryDocForTarget('acme/packages/agent/guide', target(nested, rootSecond), { scope: 'project' });
-    const withRootFirst = resolveMemoryDocForTarget('acme/packages/agent/guide', target(nested, rootFirst), { scope: 'project' });
-    assert.equal(absent.name, 'acme/packages/agent/guide');
-    assert.equal(withRootSecond.name, absent.name);
-    assert.equal(withRootFirst.name, absent.name);
-    assert.equal(withRootSecond.path, absent.path);
-    assert.equal(withRootFirst.path, absent.path);
-});

package/dist/core/__tests__/respawn-throttle.test.d.ts

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

package/dist/core/__tests__/respawn-throttle.test.js

@@ -1,20 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import { decideRespawnAttempt, MAX_RESPAWN_ATTEMPTS, respawnBackoffMs } from '../../daemon/reconcilers/node-lifecycle/respawn-policy.js';
-test('respawn policy resets after settlement and exhausts six no-settlement wedge relaunches', () => {
-    const launch = Date.parse('2026-01-01T00:00:00.000Z');
-    assert.deepEqual(decideRespawnAttempt({ last_settled_at: new Date(launch + 1).toISOString(), launched_at: new Date(launch).toISOString(), respawn_failures: 4 }, launch + 2), { failures: 0, notBefore: null, exhausted: false }, 'a turn settled after launch proves progress and resets the sequence');
-    let row = { last_settled_at: null, launched_at: new Date(launch).toISOString(), respawn_failures: 0 };
-    for (let failures = 1; failures <= MAX_RESPAWN_ATTEMPTS; failures++) {
-        const now = launch + failures * 1_000;
-        const attempt = decideRespawnAttempt(row, now);
-        assert.equal(attempt.failures, failures);
-        assert.equal(Date.parse(attempt.notBefore), now + respawnBackoffMs(failures));
-        assert.equal(attempt.exhausted, failures === MAX_RESPAWN_ATTEMPTS);
-        row = {
-            last_settled_at: null,
-            launched_at: new Date(now + respawnBackoffMs(failures)).toISOString(),
-            respawn_failures: attempt.failures,
-        };
-    }
-});

package/dist/core/__tests__/review-model-floor.test.d.ts

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

package/dist/core/__tests__/review-model-floor.test.js

@@ -1,83 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/review-model-floor.test.ts
-//
-// Review workers must not be forced down to light by an explicit `--model`
-// override. Base review work uses the medium floor; the coordinating review
-// persona keeps the stronger default needed to synthesise a broad review.
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { defaultKindsConfig, defaultModelLaddersConfig } from '../../types.js';
-import { buildLaunchSpec, normalizeModel } from '../runtime/launch.js';
-import { writeRawConfig } from '../config.js';
-import { initializeFreshScopedStore } from '../scoped-state/migrate.js';
-const priorHome = process.env['HOME'];
-const ladders = defaultModelLaddersConfig();
-// Review's own kind default IS its floor — an explicit override weaker than
-// this rung is replaced by it, provider and all.
-const REVIEW_FLOOR = defaultKindsConfig()["review"].model;
-let home = '';
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-review-model-floor-'));
-    process.env['HOME'] = home;
-    mkdirSync(join(home, '.crouter'), { recursive: true });
-    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
-    writeRawConfig('user', {
-        kinds: {
-            'audit/reviewers/security': {
-                whenToUse: 'Review one security surface.',
-                model: 'medium',
-            },
-        },
-    });
-});
-after(() => {
-    if (priorHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = priorHome;
-    rmSync(home, { recursive: true, force: true });
-});
-function expected(model) {
-    return normalizeModel(model, ladders);
-}
-function spec(kind, model) {
-    return buildLaunchSpec(kind, 'base', {
-        lifecycle: 'terminal',
-        hasManager: true,
-        cwd: home,
-        profileId: null,
-        ...(model !== undefined ? { model } : {}),
-    }).launch.model;
-}
-test('base review ignores a light override and keeps its medium floor', () => {
-    assert.equal(spec('review', 'light'), expected(REVIEW_FLOOR));
-    assert.equal(spec('review', 'haiku'), expected(REVIEW_FLOOR));
-});
-test('plugin-shaped reviewer sub-kinds keep their configured worker floor', () => {
-    assert.equal(spec('audit/reviewers/security', 'light'), expected('medium'));
-});
-test('review orchestrator uses its stronger coordinating model', () => {
-    assert.equal(buildLaunchSpec('review', 'orchestrator', { lifecycle: 'terminal', hasManager: true, cwd: home, profileId: null }).launch.model, expected(defaultKindsConfig()['review'].orchestratorModel));
-});
-test('review still permits equal-or-stronger explicit models', () => {
-    assert.equal(spec('review', 'strong'), expected('strong'));
-    assert.equal(spec('review', 'ultra'), expected('ultra'));
-});
-// `node new --model` widened to the full spec grammar (provider/tier, exact
-// provider/id, family alias) alongside the bare tier — the review floor must
-// still hold no matter which shape the requested model arrives in.
-test('review honors an explicit provider/tier override at or above its floor', () => {
-    assert.equal(spec('review', 'openai/ultra'), expected('openai/ultra'));
-});
-test('review still floors a provider/tier override below its floor', () => {
-    assert.equal(spec('review', 'openai/light'), expected(REVIEW_FLOOR));
-});
-test('review passes an unrecognized concrete provider/id straight through, unfloored', () => {
-    // A fully concrete id that matches no ladder cell resolves to no known
-    // strength, so floorReviewModel trusts the explicit pin as-given rather than
-    // guessing — same trust boundary as `node config --model` on a dormant node.
-    const concrete = 'anthropic/claude-does-not-exist-9000';
-    assert.equal(spec('review', concrete), concrete);
-});

package/dist/core/__tests__/revive-all.test.d.ts

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

package/dist/core/__tests__/revive-all.test.js

@@ -1,157 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/revive-all.test.ts
-//
-// REGRESSION LOCK — gh issue #9 (revive-all over the canvas). The heart of the
-// feature is the SELECTION predicate `isDisconnected`: which nodes a one-shot
-// "resume everything" sweep relaunches. Getting that wrong is the whole risk —
-// too narrow strands survivors, too broad resurrects finished/closed
-// conversations nobody asked to reopen, or double-spawns a live node.
-//
-// (1) WHY PURE, NOT TMUX — isDisconnected is a total function of (meta, isAlive
-//     probe, scope): zero process, zero tmux, instant. The liveness probe is
-//     injected so the alive/dead branch is exercised without a real pid. The
-//     reviveAll orchestration over it is a thin select-then-reviveNode loop;
-//     reviveNode is covered (double-spawn guard) by revive.test.ts.
-//
-// (2) THE INVARIANTS LOCKED:
-//     - engine running (live pid) → NOT disconnected (never double-spawn).
-//     - no resumable saved session (no pi_session_id AND no pi_session_file) →
-//       NOT disconnected (nothing to resume).
-//     - dead/crashed with a session → disconnected (swept by default).
-//     - done/canceled (terminal-by-choice) → always excluded (no opt-in).
-//     - kind:'human' (the human bridge, never a pi engine) → never disconnected.
-//
-// (3) HOW IT FAILS IF THE LOGIC REGRESSES — drop the terminal-by-choice guard
-//     and the done/canceled exclusion asserts go RED; drop the session
-//     requirement and the no-session assert goes RED; invert the liveness branch
-//     and the live-pid assert goes RED.
-import { test, before, after, beforeEach } 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 { spawnSync } from 'node:child_process';
-import { isDisconnected, TERMINAL_BY_CHOICE, listDisconnected } from '../runtime/revive-all.js';
-import { createNode } from '../canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { beginExecution, recordExecutionPid } from '../canvas/executions.js';
-import { bindSession } from '../canvas/sessions.js';
-const ALIVE = () => true;
-const DEAD = () => false;
-function meta(over = {}) {
-    return {
-        node_id: 'n',
-        name: 'n',
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'developer',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        pi_pid: 1234,
-        pi_session_id: 'uuid-1',
-        pi_session_file: '/abs/sess.jsonl',
-        ...over,
-    };
-}
-// engine liveness branch
-test('a node whose engine is RUNNING (live pid) is NOT disconnected — never double-spawn', () => {
-    assert.equal(isDisconnected(meta({ pi_pid: 1234 }), ALIVE), false);
-});
-test('a node whose engine is DEAD but has a saved session IS disconnected', () => {
-    assert.equal(isDisconnected(meta({ pi_pid: 1234 }), DEAD), true);
-});
-test('a node with a null pid (never/ no longer recorded) and a session IS disconnected', () => {
-    assert.equal(isDisconnected(meta({ pi_pid: null }), DEAD), true);
-});
-// resumable-session requirement
-test('a dead node with NO resumable saved session is NOT disconnected', () => {
-    assert.equal(isDisconnected(meta({ pi_session_id: null, pi_session_file: null }), DEAD), false);
-});
-test('a session FILE alone (older node, no id) is enough to be disconnected', () => {
-    assert.equal(isDisconnected(meta({ pi_session_id: null }), DEAD), true);
-});
-// terminal-by-choice scope
-for (const status of TERMINAL_BY_CHOICE) {
-    test(`a dead-engine '${status}' node is EXCLUDED (terminal-by-choice, no opt-in)`, () => {
-        assert.equal(isDisconnected(meta({ status: status }), DEAD), false);
-    });
-}
-test("a crashed 'dead' node is swept by default (a crash is involuntary, not terminal-by-choice)", () => {
-    assert.equal(isDisconnected(meta({ status: 'dead' }), DEAD), true);
-});
-// Regression (stuck-node incident): a node that already pushed its FINAL REPORT
-// FINISHED its own work and must NEVER be mass-revived, EVEN when a crash
-// mid-reap left it 'dead' (not terminal-by-choice) with the report committed.
-// Resurrecting it as 'active' stranded it re-reviving forever (it can't
-// re-reap). final_report is decisive regardless of status.
-test('a node with final_report set is EXCLUDED even when status is dead (finished its own work)', () => {
-    assert.equal(isDisconnected(meta({ status: 'dead', final_report: 'done report' }), DEAD), false);
-    assert.equal(isDisconnected(meta({ status: 'active', final_report: 'done report' }), DEAD), false);
-});
-test("dormant 'idle' nodes with a saved session are swept by default", () => {
-    assert.equal(isDisconnected(meta({ status: 'idle', intent: 'idle-release' }), DEAD), true);
-});
-// human-bridge carve-out
-test("kind:'human' rows (the human bridge, never a pi engine) are never disconnected", () => {
-    assert.equal(isDisconnected(meta({ kind: 'human', pi_pid: null }), DEAD), false);
-});
-// listDisconnected over a live canvas (the sweep's selection)
-//
-// Locks that the canvas-wide select returns EXACTLY the disconnected set against
-// the REAL isPidAlive probe — a live-engine node (this process's pid) is kept
-// out, a crashed one with a session is in, a done one is excluded. No broker is
-// launched: listDisconnected is the side-effect-free preview the command gates on.
-let home;
-function deadPid() {
-    const r = spawnSync('true', [], { stdio: 'ignore' });
-    return r.pid ?? 0x7ffffffe;
-}
-function fabricate(id, over) {
-    const { pi_pid, pi_session_id = `uuid-${id}`, pi_session_file = null, ...node } = over;
-    createNode({
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        host_kind: 'broker',
-        kind: 'developer',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...node,
-    });
-    const executionId = beginExecution(id, { daemonEpoch: 'test' });
-    if (pi_session_id !== null || pi_session_file !== null) {
-        assert.equal(bindSession(id, { executionId, sessionId: pi_session_id, transcriptPath: pi_session_file }), 'bound');
-    }
-    if (pi_pid !== null && pi_pid !== undefined) {
-        assert.equal(recordExecutionPid(executionId, id, pi_pid), 'recorded');
-    }
-    closeDb();
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-revive-all-'));
-    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('listDisconnected returns EXACTLY the disconnected nodes (crashed-with-session), excluding live + done', () => {
-    // disconnected: dead pid + a saved session.
-    fabricate('crashed', { status: 'active', pi_pid: deadPid() });
-    // connected: a LIVE engine pid (this process — read-only here) → excluded.
-    fabricate('live', { status: 'active', pi_pid: process.pid });
-    // terminal-by-choice: done + dead pid + session → excluded.
-    fabricate('finished', { status: 'done', pi_pid: deadPid() });
-    // no resumable session → excluded.
-    fabricate('sessionless', { status: 'active', pi_pid: deadPid(), pi_session_id: null });
-    const ids = listDisconnected().map((m) => m.node_id).sort();
-    assert.deepEqual(ids, ['crashed'], 'only the crashed-with-session node is swept');
-});

package/dist/core/__tests__/revive-capacity.test.d.ts

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