@north-light/crouter 0.3.173 → 0.3.174

package/dist/core/__tests__/command-plugins-surfaces.test.js

@@ -1,359 +0,0 @@
-// Phase-2 surface tests: the lifecycle surfaces (pkg plugin install / show and
-// sys doctor) must surface the Phase-1 validator's STABLE TYPED ISSUES to the
-// caller, and must do so WITHOUT executing the plugin binary. Covers spec item
-// 6 at the surface seam (the validator itself is tested in
-// command-plugins.test.ts). Run with:
-//   node --import tsx/esm --test src/core/__tests__/command-plugins-surfaces.test.ts
-//
-// Every test runs against an ISOLATED home (HOME → temp) with cwd pinned to a
-// dir that has no .crouter ancestor, so discovery is deterministic. Each fixture
-// executable writes a sentinel file if it is ever spawned; every surface
-// assertion also checks the sentinel is absent — proving validation stayed
-// static.
-import { test, describe, before, after, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, chmodSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { pluginInstall, pluginUpdate } from '../../commands/pkg/plugin-manage.js';
-import { pluginShow } from '../../commands/pkg/plugin-inspect.js';
-import { sysDoctorLeaf } from '../../commands/sys/doctor.js';
-import { discoverCommandContributions } from '../command-plugins/discovery.js';
-import { resetScopeCache } from '../scope.js';
-import { createApiServer } from '../../daemon/api/server.js';
-import { apiSocketPath, crtrHome } from '../canvas/paths.js';
-import { closeDb } from '../canvas/db.js';
-// A real executable that records the fact it ran. No surface should ever spawn
-// it — the sentinel must never appear.
-const SENTINEL_EXEC = `#!/usr/bin/env node
-const fs = require('fs');
-if (process.env.CMDPLUGIN_SENTINEL) fs.writeFileSync(process.env.CMDPLUGIN_SENTINEL, 'executed');
-process.stdout.write(JSON.stringify({ protocolVersion: 1, ok: true, result: { app_id: 'x', status: 'running' } }));
-`;
-function validManifest() {
-    return {
-        schemaVersion: 1,
-        mounts: [
-            {
-                parent: [],
-                node: {
-                    kind: 'branch',
-                    name: 'app',
-                    description: 'application lifecycle and inspection',
-                    whenToUse: 'you need to create, deploy, inspect, or remove an application',
-                    rootEntry: {
-                        concept: 'applications hosted by a crouter home',
-                        description: 'application lifecycle and inspection',
-                        whenToUse: 'you need to create, deploy, inspect, or remove an application',
-                    },
-                    summary: 'application lifecycle and inspection',
-                    children: [
-                        {
-                            kind: 'leaf',
-                            name: 'show',
-                            description: 'show one application',
-                            whenToUse: 'inspect a single application by id',
-                            summary: 'show one application details',
-                            params: [{ kind: 'positional', name: 'app-id', required: true, constraint: 'the application id' }],
-                            output: [{ name: 'app_id', type: 'string', required: true, constraint: 'the echoed application id' }],
-                            outputKind: 'object',
-                            effects: ['None. Read-only.'],
-                        },
-                    ],
-                },
-            },
-        ],
-    };
-}
-const CASES = [
-    { name: 'escaping executable path', code: 'command_path_unsafe', executable: '../../../../bin/sh' },
-    { name: 'non-executable file', code: 'command_not_executable', execBit: false },
-    (() => { const m = validManifest(); m['schemaVersion'] = 2; return { name: 'unknown schemaVersion', code: 'command_schema_version', manifest: m }; })(),
-    (() => { const m = validManifest(); m['requires'] = { crtr: '>=1' }; return { name: 'unknown top-level key', code: 'command_manifest_invalid', manifest: m }; })(),
-];
-function nestedManifest() {
-    const manifest = validManifest();
-    const mounts = manifest['mounts'];
-    const topLevel = mounts[0];
-    const child = topLevel.node['children'][0];
-    topLevel.node['children'] = [{
-            kind: 'branch',
-            name: 'tools',
-            description: 'application tools',
-            whenToUse: 'inspect application tools',
-            summary: 'application tools',
-            children: [],
-        }];
-    mounts.push({ parent: ['app', 'tools'], node: { ...child, name: 'status' } });
-    return manifest;
-}
-// ---------------------------------------------------------------------------
-// Isolated home + cwd
-// ---------------------------------------------------------------------------
-let home;
-let userRoot;
-let emptyStart;
-let sourceRoot; // holds source plugin dirs for install tests
-let sentinel;
-let realHome;
-let realProfile;
-let realCwd;
-// `sys doctor` scans live nodes for faults via `cliClient().listNodes()` — a
-// thin CLI forwarder since the crtrd-API re-plumb. No node is ever created here
-// (these tests only exercise the static command-plugin validation surface), so
-// the fault scan just needs a reachable daemon that answers with an empty
-// roster. Stand up a real in-process `createApiServer()` on the isolated home's
-// socket so that call resolves instead of trying to autostart a subprocess.
-let server;
-async function waitForSocket(path) {
-    for (let i = 0; i < 200; i++) {
-        if (existsSync(path))
-            return;
-        await new Promise((r) => setTimeout(r, 25));
-    }
-    throw new Error(`api socket never bound at ${path}`);
-}
-before(() => {
-    realHome = process.env['HOME'];
-    realProfile = process.env['CRTR_PROFILE_ID'];
-    realCwd = process.cwd();
-    delete process.env['CRTR_PROFILE_ID'];
-});
-after(() => {
-    process.chdir(realCwd);
-    if (realHome !== undefined)
-        process.env['HOME'] = realHome;
-    else
-        delete process.env['HOME'];
-    if (realProfile !== undefined)
-        process.env['CRTR_PROFILE_ID'] = realProfile;
-    delete process.env['CMDPLUGIN_SENTINEL'];
-    // Remove EVERY test's temp dirs, not just the last beforeEach's set.
-    for (const d of tempDirs) {
-        try {
-            rmSync(d, { recursive: true, force: true });
-        }
-        catch { /* ignore */ }
-    }
-    resetScopeCache();
-});
-const tempDirs = [];
-function mintDir(prefix) {
-    const d = mkdtempSync(join(tmpdir(), prefix));
-    tempDirs.push(d);
-    return d;
-}
-beforeEach(async () => {
-    home = mintDir('crtr-cmdsurf-home-');
-    process.env['HOME'] = home;
-    userRoot = join(home, '.crouter');
-    mkdirSync(join(userRoot, 'plugins'), { recursive: true });
-    emptyStart = mintDir('crtr-cmdsurf-empty-');
-    sourceRoot = mintDir('crtr-cmdsurf-src-');
-    sentinel = join(emptyStart, 'EXECUTED');
-    process.env['CMDPLUGIN_SENTINEL'] = sentinel;
-    process.chdir(emptyStart); // no .crouter ancestor → project scope is empty
-    resetScopeCache();
-    // Canvas home is `<HOME>/.crouter/canvas` (no CRTR_HOME set); create it so the
-    // socket can bind, then stand up the in-process daemon.
-    mkdirSync(crtrHome(), { recursive: true });
-    server = createApiServer();
-    await waitForSocket(apiSocketPath());
-});
-afterEach(async () => {
-    await server?.close();
-    closeDb();
-});
-/** Write a plugin at `<dir>/<name>/` with a command manifest + executable. */
-function writePlugin(dir, name, c) {
-    const root = join(dir, name);
-    mkdirSync(join(root, '.crouter-plugin'), { recursive: true });
-    mkdirSync(join(root, 'bin'), { recursive: true });
-    writeFileSync(join(root, '.crouter-plugin', 'plugin.json'), JSON.stringify({
-        name,
-        version: '0.1.0',
-        description: 'fixture',
-        commands: 'commands.json',
-        transport: { kind: 'exec', executable: c.executable ?? 'bin/cmd.js' },
-    }));
-    writeFileSync(join(root, 'commands.json'), JSON.stringify(c.manifest ?? validManifest()));
-    const execPath = join(root, 'bin', 'cmd.js');
-    writeFileSync(execPath, SENTINEL_EXEC);
-    chmodSync(execPath, c.execBit === false ? 0o644 : 0o755);
-    return root;
-}
-function assertNotExecuted() {
-    assert.equal(existsSync(sentinel), false, 'the plugin binary must never be spawned by a validation surface');
-}
-// ---------------------------------------------------------------------------
-// pkg plugin show
-// ---------------------------------------------------------------------------
-describe('pkg plugin show surfaces command validation', () => {
-    for (const c of CASES) {
-        test(`${c.name} → ${c.code} in commands.issues, no execution`, async () => {
-            writePlugin(join(userRoot, 'plugins'), 'p', c);
-            resetScopeCache();
-            const out = await pluginShow.run({ name: 'p' });
-            const commands = out['commands'];
-            assert.ok(commands, 'show must inventory commands for a plugin declaring a manifest');
-            assert.ok(commands.issues.some((i) => i.code === c.code), `expected ${c.code}, got ${JSON.stringify(commands.issues.map((i) => i.code))}`);
-            // Typed issues render with received/expected/next.
-            const issue = commands.issues.find((i) => i.code === c.code);
-            assert.ok(typeof issue.received === 'string' && typeof issue.expected === 'string' && typeof issue.next === 'string');
-            assert.equal(commands.mounts.length, 0, 'a rejected manifest contributes no mounts');
-            assertNotExecuted();
-        });
-    }
-    test('valid manifest → inventory with the accepted mount and zero issues', async () => {
-        writePlugin(join(userRoot, 'plugins'), 'p', { name: 'valid', code: '' });
-        resetScopeCache();
-        const out = await pluginShow.run({ name: 'p' });
-        const commands = out['commands'];
-        const manifest = out['manifest'];
-        assert.deepEqual(commands.mounts, ['app']);
-        assert.equal(commands.issues.length, 0);
-        assert.deepEqual(manifest.transport, { kind: 'exec', executable: 'bin/cmd.js' }, 'the executable belongs to plugin.json transport, not commands.json');
-        assertNotExecuted();
-    });
-    test('a nested mount composes into an empty exec branch instead of being rejected', async () => {
-        writePlugin(join(userRoot, 'plugins'), 'p', { name: 'nested mount', code: '', manifest: nestedManifest() });
-        resetScopeCache();
-        const out = await pluginShow.run({ name: 'p' });
-        const commands = out['commands'];
-        assert.deepEqual(commands.mounts, ['app']);
-        assert.equal(commands.issues.length, 0);
-        const snapshot = discoverCommandContributions(new Set(), emptyStart);
-        const tools = snapshot.contributions[0].node.children.find((node) => node.name === 'tools');
-        assert.equal(tools.kind, 'branch');
-        assert.deepEqual(tools.children.map((node) => node.name), ['status']);
-        assertNotExecuted();
-    });
-});
-// ---------------------------------------------------------------------------
-// sys doctor
-// ---------------------------------------------------------------------------
-describe('sys doctor surfaces command validation', () => {
-    for (const c of CASES) {
-        test(`${c.name} → fail check with human_action remediation, no execution`, async () => {
-            writePlugin(join(userRoot, 'plugins'), 'p', c);
-            resetScopeCache();
-            const out = await sysDoctorLeaf.run({ scope: 'user', fix: false, remote: false });
-            const checks = out['checks'];
-            const cmdCheck = checks.find((k) => k.name.startsWith('plugin:p:commands') && k.status === 'fail');
-            assert.ok(cmdCheck, `expected a failing command check, got ${JSON.stringify(checks.map((k) => k.name + ':' + k.status))}`);
-            assert.match(cmdCheck.message, new RegExp(c.code));
-            assert.equal(cmdCheck.remediation?.kind, 'human_action', 'command remediation is never auto-applied');
-            assert.equal(out['ok'], false);
-            assertNotExecuted();
-        });
-    }
-    test('--fix never touches plugin content and leaves the command issue unresolved', async () => {
-        writePlugin(join(userRoot, 'plugins'), 'p', { name: 'non-executable file', code: 'command_not_executable', execBit: false });
-        resetScopeCache();
-        const out = await sysDoctorLeaf.run({ scope: 'user', fix: true, remote: false });
-        const checks = out['checks'];
-        const cmdCheck = checks.find((k) => k.name.startsWith('plugin:p:commands') && k.status === 'fail');
-        assert.ok(cmdCheck, 'the command issue is still reported under --fix');
-        assert.notEqual(cmdCheck.fixed, true, '--fix must not chmod the plugin executable');
-        assertNotExecuted();
-    });
-    test('valid manifest → a passing command check', async () => {
-        writePlugin(join(userRoot, 'plugins'), 'p', { name: 'valid', code: '' });
-        resetScopeCache();
-        const out = await sysDoctorLeaf.run({ scope: 'user', fix: false, remote: false });
-        const checks = out['checks'];
-        const cmdCheck = checks.find((k) => k.name === 'plugin:p:commands');
-        assert.ok(cmdCheck && cmdCheck.status === 'pass', 'a valid manifest yields a pass check');
-        assert.match(cmdCheck.message, /app/);
-        assertNotExecuted();
-    });
-});
-// ---------------------------------------------------------------------------
-// Cross-plugin top-level collision (drop-both + issue, visible on surfaces)
-// ---------------------------------------------------------------------------
-describe('cross-plugin top-level collision surfaces on doctor and show', () => {
-    function installTwoClaimants() {
-        // Two distinct plugins, both valid in isolation, both claiming `app`.
-        writePlugin(join(userRoot, 'plugins'), 'p-one', { name: 'valid', code: '' });
-        writePlugin(join(userRoot, 'plugins'), 'p-two', { name: 'valid', code: '' });
-        resetScopeCache();
-    }
-    test('neither claimant mounts: discovery drops the collided command from the tree', () => {
-        installTwoClaimants();
-        const snapshot = discoverCommandContributions(new Set(['sys']));
-        assert.equal(snapshot.contributions.length, 0, 'a collided top-level command must not be mounted by ANY claimant');
-        const collisions = snapshot.issues.filter((i) => i.code === 'command_collision');
-        assert.deepEqual(collisions.map((i) => i.plugin).sort(), ['p-one', 'p-two'], 'both claimants are flagged');
-    });
-    test('sys doctor fails BOTH claimants with the collision (no false pass)', async () => {
-        installTwoClaimants();
-        const out = await sysDoctorLeaf.run({ scope: 'user', fix: false, remote: false });
-        const checks = out['checks'];
-        for (const name of ['p-one', 'p-two']) {
-            const passCheck = checks.find((k) => k.name === `plugin:${name}:commands` && k.status === 'pass');
-            assert.equal(passCheck, undefined, `${name} must not PASS while its command is dropped by a collision`);
-            const failCheck = checks.find((k) => k.name.startsWith(`plugin:${name}:commands`) && k.status === 'fail' && /command_collision/.test(k.message));
-            assert.ok(failCheck, `${name} must fail with command_collision, got ${JSON.stringify(checks.map((k) => k.name + ':' + k.status))}`);
-            assert.match(failCheck.message, /claimed by multiple plugins/);
-            assert.match(failCheck.message, /p-one/);
-            assert.match(failCheck.message, /p-two/);
-            assert.equal(failCheck.remediation?.kind, 'human_action');
-        }
-        assert.equal(out['ok'], false);
-        assertNotExecuted();
-    });
-    test('pkg plugin show reports the collision on each claimant and lists no mounts', async () => {
-        installTwoClaimants();
-        for (const name of ['p-one', 'p-two']) {
-            const out = await pluginShow.run({ name });
-            const commands = out['commands'];
-            assert.deepEqual(commands.mounts, [], `${name} must not list the collided command as an accepted mount`);
-            const issue = commands.issues.find((i) => i.code === 'command_collision');
-            assert.ok(issue, `${name} show must carry the command_collision issue`);
-            assert.deepEqual(issue.received.split(', ').sort(), ['p-one', 'p-two'], 'the issue names both claimants');
-        }
-        assertNotExecuted();
-    });
-});
-// ---------------------------------------------------------------------------
-// pkg plugin install / update
-// ---------------------------------------------------------------------------
-describe('pkg plugin install/update surface command validation', () => {
-    for (const c of CASES) {
-        test(`install ${c.name} → ${c.code} in result.commands.issues, no execution`, async () => {
-            const src = writePlugin(sourceRoot, 'p', c);
-            resetScopeCache();
-            const out = await pluginInstall.run({ installRef: src, scope: 'user' });
-            const commands = out['commands'];
-            assert.ok(commands, 'install reports command validation for a plugin declaring a manifest');
-            assert.ok(commands.issues.some((i) => i.code === c.code), `expected ${c.code}, got ${JSON.stringify(commands.issues.map((i) => i.code))}`);
-            assert.equal(commands.mounts.length, 0);
-            assertNotExecuted();
-        });
-    }
-    test('install valid manifest → accepted contribution, zero issues, no execution', async () => {
-        const src = writePlugin(sourceRoot, 'p', { name: 'valid', code: '' });
-        resetScopeCache();
-        const out = await pluginInstall.run({ installRef: src, scope: 'user' });
-        const commands = out['commands'];
-        assert.deepEqual(commands.mounts, ['app']);
-        assert.equal(commands.issues.length, 0);
-        assertNotExecuted();
-    });
-    test('update re-reports the current command validation for an edited manifest', async () => {
-        // Install valid, then break the on-disk manifest, then update: the report
-        // must reflect the CURRENT (broken) state — validation is per-call.
-        const src = writePlugin(sourceRoot, 'p', { name: 'valid', code: '' });
-        resetScopeCache();
-        await pluginInstall.run({ installRef: src, scope: 'user' });
-        // Break the installed copy's manifest in place.
-        writeFileSync(join(userRoot, 'plugins', 'p', 'commands.json'), JSON.stringify((() => { const m = validManifest(); m['schemaVersion'] = 2; return m; })()));
-        resetScopeCache();
-        const out = await pluginUpdate.run({ name: 'p' });
-        const updated = out['updated'];
-        const entry = updated.find((u) => u.name === 'p');
-        assert.ok(entry.commands, 'update reports command validation');
-        assert.ok(entry.commands.issues.some((i) => i.code === 'command_schema_version'));
-        assertNotExecuted();
-    });
-});

package/dist/core/__tests__/connection-reconnect-resume.test.d.ts

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

package/dist/core/__tests__/connection-reconnect-resume.test.js

@@ -1,36 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/connection-reconnect-resume.test.ts
-//
-// BUG-REGRESSION: connection faults follow the shared broker-owned retry schedule.
-// The broker exercises this policy table directly.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { nextFaultRetry, policyFor } from '../runtime/fault-recovery.js';
-const NOW = Date.parse('2026-06-23T20:00:00.000Z');
-const ISO = (ms) => new Date(ms).toISOString();
-// ---------------------------------------------------------------------------
-// J1 — the policy table itself: connection faults retry on a 5s → 2x → 60s
-// cap, and the planner advances the next attempt.
-// ---------------------------------------------------------------------------
-test('J1 policy table: connection faults use the shared retry schedule', () => {
-    assert.deepEqual(policyFor('connection'), {
-        kind: 'connection',
-        gate: 'online',
-        max: 8,
-        baseDelayMs: 5_000,
-        capDelayMs: 60_000,
-        fatal: false,
-    });
-    const plan = nextFaultRetry({
-        link: 'pi→provider',
-        op: 'generation turn',
-        kind: 'connection',
-        retry: { disposition: 'auto', by: 'daemon' },
-        message: 'Connection error.',
-        since: ISO(NOW),
-    }, NOW);
-    assert.equal(plan.attempt, 1, 'the first plan primes attempt 1');
-    assert.equal(plan.max, 8, 'connection max attempts stay at 8');
-    assert.equal(plan.nextAt, ISO(NOW + 5_000), 'connection starts at 5s');
-    assert.equal(plan.fault.retry.attempt, 1, 'planned marker carries the primed attempt');
-    assert.equal(plan.fault.retry.disposition, 'auto', 'planned marker stays auto');
-});

package/dist/core/__tests__/finalization-migration.test.d.ts

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

package/dist/core/__tests__/finalization-migration.test.js

@@ -1,38 +0,0 @@
-import { after, before, test } 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 { MIGRATIONS, migrate } from '../canvas/db.js';
-let home;
-const previousHome = process.env['CRTR_HOME'];
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-finalization-migration-'));
-    process.env['CRTR_HOME'] = home;
-});
-after(() => {
-    rmSync(home, { recursive: true, force: true });
-    if (previousHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = previousHome;
-});
-test('v16 repairs a v15 database missing canonical finalization columns', () => {
-    const db = new DatabaseSync(join(home, 'migration.db'));
-    try {
-        MIGRATIONS[0](db);
-        db.exec('PRAGMA user_version = 15');
-        migrate(db);
-        const columns = db.prepare('PRAGMA table_info(nodes)').all();
-        assert.ok(columns.some(({ name }) => name === 'final_report'));
-        assert.ok(columns.some(({ name }) => name === 'finalized_at'));
-        // migrate() always brings a db to the latest schema, not just v16 — assert
-        // against the live migration count rather than a version snapshot that will
-        // go stale every time a new migration is appended.
-        assert.equal(db.prepare('PRAGMA user_version').get().user_version, MIGRATIONS.length);
-    }
-    finally {
-        db.close();
-    }
-});

package/dist/core/__tests__/fixtures/extra-extension.d.ts

@@ -1 +0,0 @@
-export default function register(_pi: unknown): void;

package/dist/core/__tests__/fixtures/extra-extension.js

@@ -1,3 +0,0 @@
-export default function register(_pi) {
-    return;
-}

package/dist/core/__tests__/fixtures/spawn-proof-target.test.d.ts

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

package/dist/core/__tests__/fixtures/spawn-proof-target.test.js

@@ -1,15 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-import { writeFileSync } from 'node:fs';
-// Target-only fixture for the test-runner's nested-spawn regression coverage
-// (see ../test-runner-cheap-sharding.test.ts). Run directly by the real
-// suite it is a trivial always-passing test; that regression instead spawns
-// it through runTier() with CRTR_SPAWN_PROOF_FILE set and checks that this
-// marker file was actually written, proving the spawned process really
-// executed this file's test body rather than silently skipping it.
-test('writes an observable proof marker when asked, otherwise no-ops', () => {
-    const proofFile = process.env.CRTR_SPAWN_PROOF_FILE;
-    if (proofFile)
-        writeFileSync(proofFile, 'ran');
-    assert.ok(true);
-});

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

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

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

@@ -1,108 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/fork.test.ts
-//
-// Covers `crtr node new --fork-from`: the spawn-time branch where a new node is
-// born as a COPY of an existing pi conversation. Two pure layers are unit-tested
-// here — `buildPiArgv` emitting `--fork` (vs `--session`), and `resolveForkSource`
-// turning a node id / path / uuid into the `--fork <path|id>` argument. The tmux
-// spawn itself is exercised elsewhere (it needs a live pi + tmux).
-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 } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
-import { buildPiArgv } from '../runtime/launch.js';
-import { resolveForkSource } from '../runtime/spawn.js';
-let home;
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'developer',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-fork-'));
-    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'];
-});
-// ---------------------------------------------------------------------------
-// buildPiArgv — `--fork` is the spawn-time branch (not `--session`)
-// ---------------------------------------------------------------------------
-test('buildPiArgv emits --fork <src> and delivers the kickoff prompt', () => {
-    const m = node('n');
-    const { argv } = buildPiArgv(m, { prompt: 'continue from here', forkFrom: '/abs/src.jsonl' });
-    const i = argv.indexOf('--fork');
-    assert.ok(i >= 0, 'argv carries --fork');
-    assert.equal(argv[i + 1], '/abs/src.jsonl', 'forks from the resolved source');
-    assert.ok(!argv.includes('--session'), 'a fork never also resumes');
-    assert.equal(argv[argv.length - 1], 'continue from here', 'the kickoff prompt is the last positional');
-});
-test('buildPiArgv prefers --fork over --session when both are somehow set', () => {
-    const m = node('n');
-    const { argv } = buildPiArgv(m, { forkFrom: '/abs/src.jsonl', resumeSessionPath: '/abs/own.jsonl' });
-    assert.ok(argv.includes('--fork'), 'fork wins');
-    assert.ok(!argv.includes('--session'), 'resume is suppressed when forking');
-});
-test('buildPiArgv without forkFrom is unchanged (fresh launch, no --fork)', () => {
-    const m = node('n');
-    const { argv } = buildPiArgv(m, { prompt: 'go' });
-    assert.ok(!argv.includes('--fork'), 'no fork on an ordinary fresh launch');
-    assert.ok(!argv.includes('--session'), 'no resume either');
-});
-// ---------------------------------------------------------------------------
-// resolveForkSource — node id / path / uuid → the `--fork` argument
-// ---------------------------------------------------------------------------
-test('resolveForkSource resolves a node id to its absolute session FILE', () => {
-    createNode(node('src', { pi_session_id: 'uuid-1', pi_session_file: '/abs/src.jsonl' }));
-    assert.equal(resolveForkSource('src'), '/abs/src.jsonl');
-});
-test('resolveForkSource THROWS when a node has a session id but no captured FILE', () => {
-    // Broker-cut contract (U6/§B.broker): the broker forks an absolute .jsonl PATH,
-    // never a bare session id. A node row carrying only pi_session_id (no
-    // pi_session_file) can no longer be forked — it fails loudly pre-launch.
-    createNode(node('src', { pi_session_id: 'uuid-1' }));
-    assert.throws(() => resolveForkSource('src'), /no pi session yet|session FILE/);
-});
-test('resolveForkSource throws when the node has no pi session to fork yet', () => {
-    createNode(node('fresh'));
-    assert.throws(() => resolveForkSource('fresh'), /no pi session yet/);
-});
-test('resolveForkSource passes an absolute path straight through', () => {
-    assert.equal(resolveForkSource('/some/where/sess.jsonl'), '/some/where/sess.jsonl');
-});
-test('resolveForkSource makes a relative path absolute', () => {
-    assert.equal(resolveForkSource('sub/sess.jsonl'), join(process.cwd(), 'sub/sess.jsonl'));
-});
-test('resolveForkSource THROWS on a bare/partial uuid that resolves to no session', () => {
-    // Broker-cut contract (U6): an unknown bare/partial uuid is scanned against
-    // pi's sessions store and fails loudly when it matches nothing — it is no
-    // longer passed through verbatim (the broker fork won't resolve a uuid).
-    const sessRoot = mkdtempSync(join(tmpdir(), 'crtr-pi-agent-'));
-    process.env['PI_CODING_AGENT_DIR'] = sessRoot;
-    try {
-        assert.throws(() => resolveForkSource('019e8ce3-322e'), /no pi session/);
-    }
-    finally {
-        delete process.env['PI_CODING_AGENT_DIR'];
-        rmSync(sessRoot, { recursive: true, force: true });
-    }
-});
-test('resolveForkSource rejects an empty reference', () => {
-    assert.throws(() => resolveForkSource('   '), /requires a node id/);
-});

package/dist/core/__tests__/full/broker-attach-limits.test.d.ts

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