@north-light/crouter 0.3.173 → 0.3.174

package/dist/core/__tests__/full/park-clock-release.test.js

@@ -1,56 +0,0 @@
-// Regression: a boot-revived settled node that receives no new work must still
-// traverse bounded release. This is the construction that prevents the observed
-// 57-broker / ~5.4GB leak: session_start, not agent_settled, arms the clock.
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { updateNode } from '../../canvas/index.js';
-import { isPidAlive } from '../../canvas/pid.js';
-import { reviveNode } from '../../runtime/revive.js';
-import { createHarness } from '../helpers/harness.js';
-let h;
-let root;
-before(async () => {
-    h = await createHarness({ headless: true, sessionPrefix: 'crtr-park-clock' });
-    root = h.spawnRoot('park-clock suite root');
-});
-after(async () => {
-    if (h !== undefined)
-        await h.dispose();
-});
-test('a revived settled node with no work releases and leaves no broker', { timeout: 30_000 }, async () => {
-    const nodeId = h.fabricateBrokerNode({
-        id: 'settled-no-work',
-        parent: root,
-        status: 'idle',
-        intent: 'idle-release',
-    });
-    // The bound must comfortably exceed the remainder of session_start dispatch:
-    // the stophook arms the clock inside its own session_start handler, and a
-    // bound shorter than the still-running dispatch lets the release timer
-    // preempt at a later handler's await point — the broker then exits before
-    // the boot proof lands and awaitBoot never observes the boot. Production's
-    // 15-minute bound can never preempt a boot; keep the test override above
-    // dispatch time but far below the waitFor budget.
-    updateNode(nodeId, {
-        launch: {
-            extensions: [],
-            tools: [],
-            systemPrompt: '',
-            env: { CRTR_TEST_UNATTENDED_PARK_MS: '1500' },
-        },
-    });
-    reviveNode(nodeId, { resume: true });
-    const boot = await h.awaitBoot(nodeId);
-    assert.equal(h.fleet.has(nodeId), true, 'the revived broker is fleet-owned');
-    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: 'park-clock release 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 idle-release broker');
-    assert.equal(h.node(nodeId)?.intent, 'idle-release', 'the row remains durably dormant');
-    await h.tick();
-    assert.equal(h.fleet.has(nodeId), false, 'a supervision tick does not revive without inbox work');
-});

package/dist/core/__tests__/full/yield-message-transaction.test.d.ts

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

package/dist/core/__tests__/memory-index-render.test.d.ts

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

package/dist/core/__tests__/memory-index-render.test.js

@@ -1,60 +0,0 @@
-// Regression: a directory INDEX is addressed through its extensionless resolver
-// identity, so the assembled memory tree must never display physical INDEX.md.
-// Run: node --import tsx/esm --test src/core/__tests__/memory-index-render.test.ts
-import { afterEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { resolveMemoryDoc } from '../memory-resolver.js';
-import { resetScopeCache } from '../scope.js';
-import { renderPreferencesForSubject } from '../substrate/render.js';
-import { clearSessionCache } from '../substrate/session-cache.js';
-const tempDirs = [];
-function subject(cwd) {
-    return {
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        hasManager: false,
-        cwd,
-        scope: 'user',
-        orchestration: { depth: 0 },
-        profile: null,
-    };
-}
-afterEach(() => {
-    for (const dir of tempDirs.splice(0))
-        rmSync(dir, { recursive: true, force: true });
-    resetScopeCache();
-    clearSessionCache();
-});
-test('a nested plugin INDEX renders as the extensionless identifier memory read accepts', () => {
-    const previousHome = process.env.HOME;
-    const home = mkdtempSync(join(tmpdir(), 'crtr-memory-index-render-'));
-    tempDirs.push(home);
-    const pluginRoot = join(home, '.crouter', 'plugins', 'fixture');
-    const indexPath = join(pluginRoot, 'memory', 'nested', 'INDEX.md');
-    mkdirSync(join(pluginRoot, '.crouter-plugin'), { recursive: true });
-    mkdirSync(join(pluginRoot, 'memory', 'nested'), { recursive: true });
-    writeFileSync(join(pluginRoot, '.crouter-plugin', 'plugin.json'), JSON.stringify({ name: 'fixture', version: '0.1.0', description: 'fixture' }));
-    writeFileSync(indexPath, '---\nkind: preference\nsystem-prompt-visibility: name\nfile-read-visibility: none\n---\n');
-    process.env.HOME = home;
-    resetScopeCache();
-    clearSessionCache();
-    try {
-        const rendered = renderPreferencesForSubject(subject(home)).tree;
-        const identifier = 'fixture/nested/INDEX';
-        assert.match(rendered, /└─ INDEX$/m);
-        assert.doesNotMatch(rendered, /INDEX\.md/);
-        const read = resolveMemoryDoc(identifier);
-        assert.equal(read.path, indexPath);
-        assert.equal(read.name, identifier);
-    }
-    finally {
-        if (previousHome === undefined)
-            delete process.env.HOME;
-        else
-            process.env.HOME = previousHome;
-    }
-});

package/dist/core/__tests__/model-routes.test.d.ts

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

package/dist/core/__tests__/model-routes.test.js

@@ -1,41 +0,0 @@
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { expandModelCandidates } from '../model-routes.js';
-const previousHome = process.env.HOME;
-let home = '';
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-model-routes-'));
-    process.env.HOME = home;
-    mkdirSync(join(home, '.crouter'), { recursive: true });
-    writeFileSync(join(home, '.crouter', 'config.json'), JSON.stringify({
-        modelRoutes: {
-            'anthropic-user': { family: 'anthropic', credentialSource: 'user', providerId: 'anthropic', models: { strong: 'anthropic/a-strong', medium: 'anthropic/a-medium', light: 'anthropic/a-light' } },
-            'openai-user': { family: 'openai', credentialSource: 'user', providerId: 'openai-codex', models: { strong: 'openai-codex/o-strong', medium: 'openai-codex/o-medium', light: 'openai-codex/o-light' } },
-            'anthropic-funded': { family: 'anthropic', credentialSource: 'northlight', providerId: 'funded-anthropic', models: { strong: 'funded-anthropic/a-strong', medium: 'funded-anthropic/a-medium', light: 'funded-anthropic/a-light' } },
-            'openai-funded': { family: 'openai', credentialSource: 'northlight', providerId: 'funded-openai', models: { strong: 'funded-openai/o-strong', medium: 'funded-openai/o-medium', light: 'funded-openai/o-light' } },
-        },
-        modelRouting: { credentialSourceOrder: ['user', 'northlight'], familyOrder: ['anthropic', 'openai'], strengthFallback: ['medium', 'light'] },
-    }));
-});
-after(() => {
-    if (previousHome === undefined)
-        delete process.env.HOME;
-    else
-        process.env.HOME = previousHome;
-    rmSync(home, { recursive: true, force: true });
-});
-test('declared routes expand credential source, strength, then family preference', () => {
-    const candidates = expandModelCandidates({ kind: 'logical', family: 'openai', strength: 'strong', spec: 'openai-codex/o-strong' }, home, null);
-    assert.deepEqual(candidates.map((candidate) => `${candidate.credentialSource}/${candidate.family}/${candidate.strength}`), [
-        'user/openai/strong', 'user/anthropic/strong', 'user/openai/medium', 'user/anthropic/medium', 'user/openai/light', 'user/anthropic/light',
-        'northlight/openai/strong', 'northlight/anthropic/strong', 'northlight/openai/medium', 'northlight/anthropic/medium', 'northlight/openai/light', 'northlight/anthropic/light',
-    ]);
-    assert.deepEqual(candidates.map((candidate) => candidate.rank), [...Array(12).keys()]);
-});
-test('concrete routes retain provider/model first and only move to same-model credential sources', () => {
-    const candidates = expandModelCandidates({ kind: 'concrete', spec: 'anthropic/a-strong' }, home, null);
-    assert.deepEqual(candidates.map((candidate) => `${candidate.providerId}/${candidate.modelId}`), ['anthropic/a-strong', 'funded-anthropic/a-strong']);
-});

package/dist/core/__tests__/on-read-identity.test.d.ts

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

package/dist/core/__tests__/on-read-identity.test.js

@@ -1,61 +0,0 @@
-// The explicit file-context loader resolves a doc's identity with the same
-// explicit-name-then-path-fallback rule the boot resolver uses (schema.ts's
-// resolveDocName), never deriving `name` from the physical path alone.
-//
-// Run: node --import tsx/esm --test src/core/__tests__/on-read-identity.test.ts
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { closeDb } from '../canvas/db.js';
-import { resetScopeCache } from '../scope.js';
-import { spawnNode } from '../runtime/nodes.js';
-import { renderOnReadDocs } from '../substrate/on-read.js';
-let home;
-let work;
-let prevHomeEnv;
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-onread-identity-home-'));
-    process.env['CRTR_HOME'] = home;
-    prevHomeEnv = process.env['HOME'];
-});
-beforeEach(() => {
-    closeDb();
-    resetScopeCache();
-    rmSync(home, { recursive: true, force: true });
-    if (prevHomeEnv === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = prevHomeEnv;
-    work = mkdtempSync(join(tmpdir(), 'crtr-onread-identity-work-'));
-});
-after(() => {
-    closeDb();
-    resetScopeCache();
-    rmSync(home, { recursive: true, force: true });
-    rmSync(work, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-    if (prevHomeEnv === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = prevHomeEnv;
-});
-test('an explicitly routed doc injects on-read under its frontmatter name, not the path-derived one', () => {
-    const node = spawnNode({ kind: 'general', cwd: work, parent: null }).node_id;
-    const memDir = join(work, '.crouter', 'memory');
-    mkdirSync(memDir, { recursive: true });
-    writeFileSync(join(memDir, 'physical-guide.md'), '---\nkind: knowledge\n' +
-        'name: acme-project\n' +
-        'when-and-why-to-read: When reading acme source, this knowledge should be read because it carries the project-specific implementation constraints.\n' +
-        'file-read-visibility: content\n' +
-        'applies-to: "src/**"\n---\n' +
-        'ACME PROJECT OPERATING GUIDE\n');
-    const readFile = join(work, 'src', 'file.ts');
-    mkdirSync(join(work, 'src'), { recursive: true });
-    writeFileSync(readFile, 'export const x = 1;\n');
-    const rendered = renderOnReadDocs(node, readFile, new Set());
-    assert.ok(rendered.includes('ACME PROJECT OPERATING GUIDE'), 'the matching explicit route fires');
-    assert.ok(rendered.includes('<memory kind="knowledge" name="acme-project"'), `expected explicit frontmatter name "acme-project" in the injected envelope, got: ${rendered}`);
-    assert.ok(!rendered.includes('name="physical-guide"'), 'must not fall back to the path-derived name when frontmatter sets one');
-});

package/dist/core/__tests__/phase4-review-migration.test.d.ts

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

package/dist/core/__tests__/phase4-review-migration.test.js

@@ -1,100 +0,0 @@
-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 { DatabaseSync } from 'node:sqlite';
-import { closeDb, MIGRATIONS, openDb } from '../canvas/db.js';
-import { canvasDbPath, ensureHome } from '../canvas/paths.js';
-let home;
-const legacyOutboxTable = ['consult', 'outbox'].join('_');
-function userVersion(db) {
-    return db.prepare('PRAGMA user_version').get().user_version;
-}
-function names(db, type) {
-    return new Set(db.prepare('SELECT name FROM sqlite_master WHERE type = ?').all(type)
-        .map((row) => row.name));
-}
-function columns(db, table) {
-    return db.prepare(`PRAGMA table_info(${table})`).all().map((row) => row.name);
-}
-function migrateToVersion(db, target) {
-    for (let version = userVersion(db); version < target; version += 1) {
-        MIGRATIONS[version](db);
-        db.exec(`PRAGMA user_version = ${version + 1}`);
-    }
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-phase4-review-migration-'));
-    process.env['CRTR_HOME'] = home;
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-test('v27/v28 review schema, v29 anchor state, and v30 outbox drop migrate fresh and from v28', () => {
-    const db = openDb();
-    assert.equal(userVersion(db), 30);
-    assert.equal(names(db, 'table').has(legacyOutboxTable), false);
-    const tables = names(db, 'table');
-    assert.deepEqual(['reviews', 'review_comments', 'review_comment_events'].every((name) => tables.has(name)), true);
-    assert.deepEqual(columns(db, 'reviews'), [
-        'review_id', 'idempotency_key', 'origin_kind', 'origin_node_id', 'bridge_node_id',
-        'companion_node_id', 'review_dir', 'file', 'origin_session_file', 'origin_session_id',
-        'origin_leaf_id', 'model_spec', 'branch_file', 'baseline_sha256', 'baseline_bytes',
-        'anchor_base_sha256', 'anchor_base_bytes', 'state', 'created', 'captured_at', 'opened_at',
-        'output_path', 'subtitle', 'approved_at', 'approved_sha256', 'changed', 'comments_total',
-        'comments_unresolved', 'result_json', 'canceled_at', 'cancel_reason', 'cancel_actor',
-        'delivery_entry_id', 'delivered_at', 'delivery_error', 'projected_at', 'projection_error',
-    ]);
-    assert.deepEqual(columns(db, 'review_comments'), [
-        'comment_id', 'review_id', 'status', 'revision', 'text', 'anchor_line', 'anchor_end_line',
-        'anchor_col_start', 'anchor_col_end', 'anchor_quote', 'anchor_line_text', 'anchor_doc_hash',
-        'author_kind', 'author_node_id', 'updated_by_kind', 'updated_by_node_id', 'created_at',
-        'updated_at', 'resolved_at', 'deleted_at', 'created_seq', 'anchor_state',
-    ]);
-    assert.deepEqual(columns(db, 'review_comment_events'), [
-        'seq', 'review_id', 'comment_id', 'kind', 'state_change', 'revision_after', 'actor_kind',
-        'actor_node_id', 'at', 'operation_id', 'payload',
-    ]);
-    const indexes = names(db, 'index');
-    for (const index of [
-        'idx_reviews_state', 'idx_reviews_origin', 'idx_reviews_file', 'idx_reviews_bridge',
-        'idx_review_comments_review_line_seq', 'idx_review_comments_review_status',
-        'idx_review_comment_events_review_seq', 'idx_review_comment_events_comment_seq',
-    ]) {
-        assert.equal(indexes.has(index), true, `missing ${index}`);
-    }
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    ensureHome();
-    const raw = new DatabaseSync(canvasDbPath());
-    migrateToVersion(raw, 28);
-    assert.equal(userVersion(raw), 28);
-    raw.prepare(`
-    INSERT INTO review_comments
-      (comment_id, review_id, status, revision, text, anchor_line, anchor_end_line,
-       anchor_line_text, anchor_doc_hash, author_kind, updated_by_kind, created_at,
-       updated_at, created_seq)
-    VALUES ('v28-comment', 'v28-review', 'open', 1, 'existing', 1, 1,
-            'source', 'hash', 'human', 'human', '2026-01-01T00:00:00.000Z',
-            '2026-01-01T00:00:00.000Z', 1)
-  `).run();
-    migrateToVersion(raw, 29);
-    assert.equal(userVersion(raw), 29);
-    raw.prepare(`
-    INSERT INTO ${legacyOutboxTable}
-      (node_id, ticket_node_id, request_id, work_kind, status, updated_at)
-    VALUES ('legacy-outbox-node', 'legacy-ticket-node', 'legacy-request', 'follow_up', 'pending', '2026-01-01T00:00:00.000Z')
-  `).run();
-    raw.close();
-    const migrated = openDb();
-    assert.equal(userVersion(migrated), 30);
-    assert.equal(names(migrated, 'table').has('reviews'), true);
-    assert.equal(names(migrated, 'table').has('review_comments'), true);
-    assert.equal(names(migrated, 'table').has('review_comment_events'), true);
-    assert.equal(migrated.prepare("SELECT anchor_state FROM review_comments WHERE comment_id = 'v28-comment'").get().anchor_state, 'live');
-    assert.throws(() => migrated.prepare("UPDATE review_comments SET anchor_state = 'invalid' WHERE comment_id = 'v28-comment'").run());
-    assert.equal(names(migrated, 'table').has(legacyOutboxTable), false);
-});

package/dist/core/__tests__/prune-to-limit.test.d.ts

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

package/dist/core/__tests__/prune-to-limit.test.js

@@ -1,126 +0,0 @@
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode, getRow, recordPid, pruneToLimit, } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
-import { nodeDir } from '../canvas/paths.js';
-let home;
-// A timestamp `secondsAgo` before now — created order doubles as recency order
-// here (no telemetry.json is written, so recencyMs falls back to created epoch).
-const at = (secondsAgo) => new Date(Date.now() - secondsAgo * 1000).toISOString();
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: at(0),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'dead',
-        ...over,
-    };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-prune-limit-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-    delete process.env['CRTR_NODE_ID'];
-});
-test('keeps all live nodes even when liveCount exceeds the cap', () => {
-    // 5 live (active/idle with a running pi) + 2 old terminal; cap of 3.
-    // target = max(3, 5) = 5, so NO live node is ever deleted; the 2 terminal
-    // fall beyond rank 5 and are pruned.
-    for (let i = 0; i < 5; i++) {
-        createNode(node(`live-${i}`, { status: 'active', created: at(i) }));
-        recordPid(`live-${i}`, process.pid); // process.pid is alive → isPidAlive true
-    }
-    createNode(node('old-a', { status: 'dead', created: at(100) }));
-    createNode(node('old-b', { status: 'done', created: at(101) }));
-    const result = pruneToLimit({ maxNodes: 3 });
-    assert.equal(result.dryRun, false);
-    assert.deepEqual(result.pruned.map((p) => p.node_id).sort(), ['old-a', 'old-b']);
-    for (let i = 0; i < 5; i++) {
-        assert.ok(getRow(`live-${i}`) !== null, `live-${i} must survive past the cap`);
-    }
-});
-test('deletes the oldest terminal nodes beyond max(cap, liveCount)', () => {
-    // 1 live + 5 terminal of descending recency; cap of 3 → target = max(3,1) = 3.
-    // Ranked by recency DESC: live-0, term-0, term-1 (top 3, kept), then
-    // term-2, term-3, term-4 (rank >= 3, pruned).
-    createNode(node('live-0', { status: 'idle', created: at(0) }));
-    recordPid('live-0', process.pid);
-    for (let i = 0; i < 5; i++) {
-        createNode(node(`term-${i}`, { status: 'dead', created: at(10 + i) }));
-    }
-    const result = pruneToLimit({ maxNodes: 3 });
-    assert.deepEqual(result.pruned.map((p) => p.node_id).sort(), ['term-2', 'term-3', 'term-4']);
-    // The kept set: the live node + the two newest terminal.
-    for (const id of ['live-0', 'term-0', 'term-1']) {
-        assert.ok(getRow(id) !== null, `${id} must survive`);
-        assert.ok(existsSync(nodeDir(id)), `${id} dir must survive`);
-    }
-    // The pruned set: rows AND dirs gone.
-    for (const id of ['term-2', 'term-3', 'term-4']) {
-        assert.equal(getRow(id), null, `${id} row should be pruned`);
-        assert.ok(!existsSync(nodeDir(id)), `${id} dir should be removed`);
-    }
-});
-test('a non-terminal node with a dead pid is never a prune candidate (issue #114)', () => {
-    // An active row whose broker crashed: status stays 'active' but pi_pid is
-    // NULL (never recorded), so isPidAlive would be false. It must still be
-    // protected — crash-recovery, not the count-based pruner, owns this row —
-    // even though it's the oldest node and cap is exceeded by newer terminal rows.
-    createNode(node('crashed-active', { status: 'active', created: at(100) }));
-    for (let i = 0; i < 5; i++) {
-        createNode(node(`term-${i}`, { status: 'dead', created: at(i) }));
-    }
-    const result = pruneToLimit({ maxNodes: 3 });
-    assert.ok(!result.pruned.some((p) => p.node_id === 'crashed-active'), 'a crashed-but-active node must not be selected for pruning');
-    assert.ok(getRow('crashed-active') !== null, 'crashed-active row must survive');
-    assert.ok(existsSync(nodeDir('crashed-active')), 'crashed-active dir must survive');
-});
-test('count pruning retains an open managed worktree node beyond the cap', () => {
-    createNode(node('open-worktree', {
-        created: at(100),
-        managed_worktree: {
-            state: 'open',
-            path: join(home, 'worktrees', 'open-worktree'),
-            branch: 'crtr/open-worktree',
-            repo_root: '/tmp/repo',
-            base_ref: 'main',
-            base_sha: 'base',
-            created: at(100),
-        },
-    }));
-    for (let i = 0; i < 3; i++) {
-        createNode(node(`term-${i}`, { created: at(i) }));
-    }
-    const result = pruneToLimit({ maxNodes: 1 });
-    assert.ok(!result.pruned.some((p) => p.node_id === 'open-worktree'));
-    assert.ok(getRow('open-worktree') !== null, 'node remains to own its managed worktree');
-    assert.ok(existsSync(nodeDir('open-worktree')), 'node dir remains');
-});
-test('--dry-run reports candidates but deletes nothing', () => {
-    for (let i = 0; i < 5; i++) {
-        createNode(node(`term-${i}`, { status: 'dead', created: at(i) }));
-    }
-    const result = pruneToLimit({ maxNodes: 3, dryRun: true });
-    assert.equal(result.dryRun, true);
-    assert.deepEqual(result.pruned.map((p) => p.node_id).sort(), ['term-3', 'term-4']);
-    // Nothing deleted — all rows + dirs intact.
-    for (let i = 0; i < 5; i++) {
-        assert.ok(getRow(`term-${i}`) !== null, `term-${i} must survive a dry run`);
-        assert.ok(existsSync(nodeDir(`term-${i}`)), `term-${i} dir must survive a dry run`);
-    }
-});

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

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

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

@@ -1,69 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/reset.test.ts
-//
-// resetRoot now handles ONLY the non-root child `/new` (a session-id refresh).
-// A root's `/new` mints a fresh node via relaunchRoot — see relaunch-root.test.ts.
-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 { createNode, getNode, subscribe } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
-import { resetRoot } from '../runtime/reset.js';
-let home;
-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,
-    };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-reset-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-test('resetRoot on a non-root child refreshes the session id (no reap, no reset)', () => {
-    createNode(node('root', { parent: null }));
-    createNode(node('child', { parent: 'root', pi_session_id: 'old' }));
-    subscribe('root', 'child', true);
-    const res = resetRoot('child', 'fresh', '/abs/sessions/fresh.jsonl');
-    assert.equal(res.reset, false, 'a child `/new` is not a graph reset');
-    assert.deepEqual(res.reaped, []);
-    assert.deepEqual(res.detached, []);
-    assert.equal(getNode('child')?.pi_session_id, 'fresh', 'session id refreshed');
-    assert.equal(getNode('child')?.pi_session_file, '/abs/sessions/fresh.jsonl', 'session FILE refreshed too');
-    assert.equal(getNode('child')?.status, 'active', 'child not reaped');
-    assert.equal(getNode('root')?.status, 'active', 'the subscribing root is untouched');
-});
-test('resetRoot on a ROOT is a no-op (roots route to relaunchRoot, not here)', () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident', pi_session_id: 'keep' }));
-    createNode(node('child', { parent: 'root' }));
-    subscribe('root', 'child', true);
-    const res = resetRoot('root', 'new-sess');
-    assert.equal(res.reset, false);
-    assert.deepEqual(res.reaped, [], 'a root `/new` reaps nothing here');
-    assert.equal(getNode('root')?.status, 'active', 'root left untouched');
-    assert.equal(getNode('root')?.pi_session_id, 'keep', 'a root session id is NOT refreshed here');
-    assert.equal(getNode('child')?.status, 'active', 'descendant left untouched');
-});
-test('resetRoot is a no-op for an unknown node', () => {
-    const res = resetRoot('ghost', 'x');
-    assert.equal(res.reset, false);
-    assert.deepEqual(res.reaped, []);
-    assert.deepEqual(res.detached, []);
-});

package/dist/core/__tests__/spawn-no-kickoff.test.d.ts

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