@crouton-kit/crouter 0.3.20 → 0.3.22

package/dist/core/__tests__/broker-dialogs.test.js

@@ -1,126 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/broker-dialogs.test.ts
-//
-// Broker dialog handling — the §5.4 C2 forward-progress proof plus the T8 attach
-// gates G5/G5b/G6. Split out of broker-lifecycle.test.ts (see its header for the
-// full file map); the tests are the original acceptance gate, unchanged, on their
-// own isolated harness. The attach-client helpers live in
-// helpers/broker-clients.ts (the PRODUCTION ViewSocketClient, §0 one-writer: a
-// viewer holds ONLY a socket).
-import { test, before, after, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { createHarness, hasTmux } from './helpers/harness.js';
-import { isPidAlive } from '../canvas/pid.js';
-import { createAttachKit } from './helpers/broker-clients.js';
-let h;
-let root;
-const kit = createAttachKit(() => h);
-const { attach, attachUntil } = kit;
-before(async () => {
-    if (!hasTmux())
-        return;
-    h = await createHarness({ sessionPrefix: 'crtr-brkdlg' });
-    root = h.spawnRoot('broker-dialogs suite root');
-});
-after(async () => {
-    if (h !== undefined)
-        await h.dispose();
-});
-afterEach(() => {
-    kit.closeAll();
-});
-const brokerPid = (id) => h.node(id).pi_pid;
-// ===========================================================================
-// C2 forward-progress (zero-viewer path) — an unattended blocking dialog
-// resolves to its default (false) IMMEDIATELY: with no controller connected the
-// broker's REAL makeBrokerUiContext falls back to noOp resolution, so the engine
-// never deadlocks AND never waits on a per-dialog timeout (the design §5.4
-// timeout premise is false). Red/green: the OLD broker armed a setTimeout and
-// resolved only after `timeout` ms; the fixed broker resolves in ~0ms. (Supports
-// acceptance item 7: the existing suite stays green; this only ADDS coverage.)
-// ===========================================================================
-test('C2 — unattended dialog resolves to its default IMMEDIATELY (noOp), never waits on a timeout', { skip: !hasTmux() }, async () => {
-    const id = await h.spawnHeadlessChild(root, 'headless worker — dialog');
-    const pid = h.node(id).pi_pid;
-    // Drive the fake engine to call uiContext.confirm(..., { timeout: 5000 }) with
-    // NO controller. C2 fix: makeBrokerUiContext resolves the default (false) AT
-    // ONCE — it does NOT arm/await the timeout. A generous < 2000ms bound is still a
-    // hard fail against the old ~5000ms timeout-wait while staying robust on slow CI.
-    h.fakeCmd(id, { cmd: 'dialog', timeout: 5000 });
-    const results = await h.waitFor(() => {
-        const r = h.dialogResults(id);
-        return r.length > 0 ? r : null;
-    }, { timeoutMs: 15_000, label: 'unattended dialog resolved' });
-    assert.equal(results[0].resolved, false, 'unattended confirm resolves to its default (false / deny)');
-    assert.ok(results[0].ms < 2000, `C2: resolved IMMEDIATELY (noOp), not after the 5000ms timeout — got ${results[0].ms}ms`);
-    assert.equal(isPidAlive(pid), true, 'the broker made forward progress (still alive, did not hang or exit)');
-});
-// ---------------------------------------------------------------------------
-// G5 — dialog forward + answer. Guards: a blocking dialog reaches the controller
-// as extension_ui_request and the controller's extension_ui_response unblocks the
-// engine with ITS answer (not the default). Failure mode: a dialog the controller
-// can't see/answer (silent deadlock).
-// ---------------------------------------------------------------------------
-test('G5 — controller receives an extension_ui_request, answers it, and the engine proceeds with that answer', { skip: !hasTmux() }, async () => {
-    const id = await h.spawnHeadlessChild(root, 'headless worker — G5a');
-    const c = await attach(id, 'controller', 'g5-ctrl');
-    h.fakeCmd(id, { cmd: 'dialog', timeout: 20_000 }); // generous: the controller answers first
-    const req = await c.waitFrame((f) => f.type === 'extension_ui_request', 'G5 dialog forwarded to controller');
-    assert.equal(req.method, 'confirm', 'G5: the forwarded dialog is the confirm() the engine raised');
-    const reqId = req.id;
-    c.send({ type: 'extension_ui_response', id: reqId, confirmed: true });
-    const results = await h.waitFor(() => {
-        const r = h.dialogResults(id);
-        return r.length > 0 ? r : null;
-    }, { label: 'G5 dialog resolved by the controller', timeoutMs: 15_000 });
-    assert.equal(results[0].resolved, true, 'G5: the engine proceeded with the controller answer (true), not the default (false)');
-});
-// ---------------------------------------------------------------------------
-// G5 (mid-dialog attach) — Guards: a dialog raised under a prior controller stays
-// pending across that controller's detach (M2) and is delivered to whoever takes
-// control next via welcome.pending_dialog. Failure mode: a pending dialog lost on
-// controller handoff.
-// ---------------------------------------------------------------------------
-test('G5 — a controller attaching MID-dialog receives the pending dialog via welcome.pending_dialog', { skip: !hasTmux() }, async () => {
-    const id = await h.spawnHeadlessChild(root, 'headless worker — G5b');
-    const a = await attach(id, 'controller', 'g5b-A');
-    h.fakeCmd(id, { cmd: 'dialog', timeout: 30_000 }); // stays pending long enough for the handoff
-    const reqA = await a.waitFrame((f) => f.type === 'extension_ui_request', 'G5b dialog forwarded to controller A');
-    const reqId = reqA.id;
-    a.send({ type: 'bye' });
-    a.close(); // M2: detach frees control but does NOT cancel the pending dialog
-    // Controller B takes control (retry covers the close→controllerId=null beat) and
-    // its welcome carries the still-pending dialog.
-    const b = await attachUntil(id, 'controller', 'g5b-B', (x) => x.welcome.role === 'controller' && x.welcome.pending_dialog != null, 'G5b controller B takes control with the pending dialog');
-    assert.equal(b.welcome.pending_dialog.id, reqId, 'G5b: welcome.pending_dialog is the same dialog raised under A');
-    assert.equal(b.welcome.pending_dialog.method, 'confirm', 'G5b: the pending dialog is the confirm()');
-    b.send({ type: 'extension_ui_response', id: reqId, confirmed: true });
-    const results = await h.waitFor(() => {
-        const r = h.dialogResults(id);
-        return r.length > 0 ? r : null;
-    }, { label: 'G5b dialog resolved by controller B', timeoutMs: 15_000 });
-    assert.equal(results[0].resolved, true, 'G5b: controller B answered the handed-off dialog and the engine proceeded');
-});
-// ---------------------------------------------------------------------------
-// G6 — anti-deadlock. (a) a zero-viewer dialog resolves to its default AT ONCE
-// (noOp). (b) an ATTENDED dialog the controller never answers resolves on a SHORT
-// per-dialog broker timeout. Guards: the engine never hangs on a dialog with no
-// answerer. Failure mode: a forever-blocked turn.
-// ---------------------------------------------------------------------------
-test('G6 — zero-viewer dialog resolves immediately; an unanswered attended dialog resolves on the broker timeout', { skip: !hasTmux() }, async () => {
-    const id = await h.spawnHeadlessChild(root, 'headless worker — G6');
-    const pid = brokerPid(id);
-    // (a) zero viewers → immediate noOp default (NOT the 5000ms timeout).
-    h.fakeCmd(id, { cmd: 'dialog', timeout: 5000 });
-    const r1 = await h.waitFor(() => (h.dialogResults(id).length >= 1 ? h.dialogResults(id) : null), { label: 'G6a zero-viewer dialog resolved', timeoutMs: 15_000 });
-    assert.equal(r1[0].resolved, false, 'G6a: zero-viewer dialog resolves to the default (deny)');
-    assert.ok(r1[0].ms < 2000, `G6a: resolved immediately (noOp), not after the 5000ms timeout — got ${r1[0].ms}ms`);
-    // (b) controller attached but silent → the broker resolves on the SHORT explicit
-    // per-dialog timeout (800ms), never the 120s default.
-    const c = await attach(id, 'controller', 'g6-ctrl');
-    h.fakeCmd(id, { cmd: 'dialog', timeout: 800 });
-    await c.waitFrame((f) => f.type === 'extension_ui_request', 'G6b dialog forwarded to controller'); // received, deliberately NOT answered
-    const r2 = await h.waitFor(() => (h.dialogResults(id).length >= 2 ? h.dialogResults(id) : null), { label: 'G6b attended dialog resolved on timeout', timeoutMs: 15_000 });
-    assert.equal(r2[1].resolved, false, 'G6b: an unanswered attended dialog resolves to the default (deny)');
-    assert.ok(r2[1].ms >= 600 && r2[1].ms < 5000, `G6b: resolved on the ~800ms per-dialog timeout, not instantly and not the 120s default — got ${r2[1].ms}ms`);
-    assert.equal(isPidAlive(pid), true, 'G6: the engine made forward progress on both dialogs (still alive)');
-});

package/dist/core/__tests__/broker-lifecycle.test.js

@@ -1,87 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/broker-lifecycle.test.ts
-//
-// The broker-backed lifecycle suite — the acceptance-gate proof of the headless-
-// broker migration (plan T11). It drives the REAL `crtr` CLI into an isolated
-// REAL tmux session and spawns `--headless` nodes onto the REAL headless broker
-// host (host.ts), which boots a REAL detached broker PROCESS (broker.ts) per
-// node. The broker hosts a fake SDK engine (fixtures/fake-engine.ts) loaded via
-// the CRTR_BROKER_ENGINE seam — NOTHING in the broker, the host, the stophook,
-// the inbox-watcher, the stop-guard, or the daemon (superviseTick) is mocked.
-// Every assertion reads straight off the canvas data layer.
-//
-// The suite is SPLIT across sibling files (one isolated harness each) so
-// node:test's file-level parallelism applies — the tests themselves are the
-// original acceptance gate, unchanged:
-//   THIS FILE                        — items 1–2 + 3 (LIVE): spawn, LIVE wake
-//   broker-dormant-wake.test.ts      — item 3 (DORMANT): idle-release → daemon revive
-//   broker-crash-teardown.test.ts    — items 4–6 + M-1/M-2: crash, teardown, boot failure
-//   broker-dialogs.test.ts           — §5.4 C2 + gates G5/G5b/G6 (dialogs)
-//   broker-attach-stream.test.ts     — gates G1/G1b/G2/G3 (drive + relay + snapshot)
-//   broker-attach-limits.test.ts     — gates G4/G7/G8/G9 (arbitration + caps + one-writer)
-//
-// Acceptance items (plan §4) → the asserting test:
-//   1 spawn --headless → host_kind='broker', null placement, live broker pid     → "spawn"
-//   2 supervised by broker-pid signal-0 (stophook recordPid = broker pid)         → "spawn"
-//   3 inbox wakes LIVE (in-broker watcher) AND DORMANT (idle-release → daemon)    → "live wake" here + "dormant wake" (broker-dormant-wake.test.ts)
-//   7 tmux stays default — the existing suite passes UNMODIFIED (this split only
-//     MOVES tests between files + extracts harness wiring; nothing is rewritten).
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { createHarness, hasTmux } from './helpers/harness.js';
-import { appendInbox } from '../feed/inbox.js';
-import { isPidAlive } from '../canvas/pid.js';
-let h;
-let root;
-before(async () => {
-    if (!hasTmux())
-        return;
-    h = await createHarness({ sessionPrefix: 'crtr-broker' });
-    root = h.spawnRoot('broker-suite root');
-});
-after(async () => {
-    if (h !== undefined)
-        await h.dispose();
-});
-// ===========================================================================
-// Item 1 + 2 — spawn --headless: broker host, NULL placement, a live broker pid
-// that IS the daemon's supervision signal (stophook recordPid(process.pid)).
-// ===========================================================================
-test('spawn --headless → broker host_kind, null placement, live broker pid; daemon leaves a healthy broker', { skip: !hasTmux() }, async () => {
-    const id = await h.spawnHeadlessChild(root, 'headless worker — spawn');
-    const node = h.node(id);
-    // Item 1: the broker host + a paneless placement.
-    assert.equal(node.host_kind, 'broker', "host_kind === 'broker'");
-    assert.equal(node.window ?? null, null, 'window is NULL (paneless broker)');
-    assert.equal(node.pane ?? null, null, 'pane is NULL (paneless broker)');
-    assert.equal(node.tmux_session ?? null, null, 'tmux_session is NULL (paneless broker)');
-    assert.ok(node.pi_pid != null, 'a broker pid was recorded as pi_pid');
-    assert.equal(isPidAlive(node.pi_pid), true, 'the broker pid is alive');
-    // Item 2: the supervision signal IS the broker pid — the stophook recorded
-    // process.pid (the broker's own pid) on session_start, == the boot proof pid.
-    const boot = await h.awaitBoot(id);
-    assert.equal(boot.pid, node.pi_pid, 'boot-proof pid (broker process.pid) === supervised pi_pid');
-    // The daemon supervises it by that pid alone: a healthy broker is left untouched.
-    const before = h.bootCount(id);
-    await h.tick();
-    assert.equal(h.status(id), 'active', 'a healthy broker stays active across a daemon tick');
-    assert.equal(h.node(id).pi_pid, node.pi_pid, 'pid unchanged — not revived');
-    assert.equal(h.bootCount(id), before, 'no reboot');
-    assert.equal(isPidAlive(node.pi_pid), true, 'broker still alive');
-});
-// ===========================================================================
-// Item 3 (LIVE) — the in-broker inbox-watcher delivers an inbox push WITHOUT an
-// exit or revive (the broker stays alive; pi.sendUserMessage → injected).
-// ===========================================================================
-test('LIVE wake — in-broker watcher injects an inbox push with no exit/revive', { skip: !hasTmux() }, async () => {
-    const id = await h.spawnHeadlessChild(root, 'headless worker — live wake');
-    const pid = h.node(id).pi_pid;
-    const boots = h.bootCount(id);
-    appendInbox(id, { from: 'tester', tier: 'normal', kind: 'message', label: 'live-wake', data: { body: 'do this live' } });
-    // The REAL in-broker watcher (800ms poll + 1000ms debounce) delivers via
-    // pi.sendUserMessage → fake-pi.injected.jsonl.
-    await h.awaitWake(id, { match: /do this live/, timeoutMs: 15_000 });
-    // No exit, no revive: same broker pid, still alive, no new boot.
-    assert.equal(h.bootCount(id), boots, 'no new boot — the live broker was not revived');
-    assert.equal(h.node(id).pi_pid, pid, 'pi_pid unchanged — the broker never exited');
-    assert.equal(isPidAlive(pid), true, 'the broker is still alive after the live wake');
-});

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

@@ -1,181 +0,0 @@
-// Tests for parseSkillQualifier (slash-only form) and config migration.
-//
-// Run with: node --import tsx/esm --test 'src/core/__tests__/resolver.test.ts'
-import { test, describe, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { parseSkillQualifier, resolveSkill } from '../resolver.js';
-import { resetScopeCache } from '../scope.js';
-import { CrtrError } from '../errors.js';
-import { InputError } from '../io.js';
-import { readConfig } from '../config.js';
-import { SCHEMA_VERSION } from '../../types.js';
-// ---------------------------------------------------------------------------
-// parseSkillQualifier — slash-only form
-// ---------------------------------------------------------------------------
-describe('parseSkillQualifier', () => {
-    test('bare name returns single segment', () => {
-        const r = parseSkillQualifier('foo');
-        assert.deepEqual(r, { segments: ['foo'] });
-    });
-    test('plugin/name returns two segments', () => {
-        const r = parseSkillQualifier('ai/interface');
-        assert.deepEqual(r, { segments: ['ai', 'interface'] });
-    });
-    test('plugin/nested/name returns three segments', () => {
-        const r = parseSkillQualifier('ai/interface/cli-design');
-        assert.deepEqual(r, { segments: ['ai', 'interface', 'cli-design'] });
-    });
-    test('scope-qualified user/name sets scope, single segment', () => {
-        const r = parseSkillQualifier('user/my-skill');
-        assert.deepEqual(r, { scope: 'user', segments: ['my-skill'] });
-    });
-    test('scope-qualified project/name sets scope', () => {
-        const r = parseSkillQualifier('project/my-skill');
-        assert.deepEqual(r, { scope: 'project', segments: ['my-skill'] });
-    });
-    test('scope-qualified user/ai/x/y sets scope and leaves rest as segments', () => {
-        const r = parseSkillQualifier('user/ai/x/y');
-        assert.deepEqual(r, { scope: 'user', segments: ['ai', 'x', 'y'] });
-    });
-    test('colon in input throws InputError with invalid_qualifier', () => {
-        assert.throws(() => parseSkillQualifier('ai:interface/cli-design'), (e) => {
-            assert.ok(e instanceof InputError, 'should be InputError');
-            assert.equal(e.payload.error, 'invalid_qualifier');
-            assert.equal(e.payload.received, 'ai:interface/cli-design');
-            assert.ok(e.payload.next.includes('ai/interface/cli-design'), `next should contain slash form, got: ${e.payload.next}`);
-            return true;
-        });
-    });
-    test('legacy scope:name form throws invalid_qualifier', () => {
-        assert.throws(() => parseSkillQualifier('user:my-skill'), (e) => {
-            assert.ok(e instanceof InputError);
-            assert.equal(e.payload.error, 'invalid_qualifier');
-            assert.ok(e.payload.next.includes('user/my-skill'));
-            return true;
-        });
-    });
-    test('legacy scope:plugin/name form throws invalid_qualifier', () => {
-        assert.throws(() => parseSkillQualifier('user:ai/interface/cli-design'), (e) => {
-            assert.ok(e instanceof InputError);
-            assert.equal(e.payload.error, 'invalid_qualifier');
-            assert.ok(e.payload.next.includes('user/ai/interface/cli-design'));
-            return true;
-        });
-    });
-});
-// ---------------------------------------------------------------------------
-// Config migration: colon keys → slash keys on readConfig with old schema_version
-// ---------------------------------------------------------------------------
-describe('config migration: skill keys colon → slash', () => {
-    let testHomeDir;
-    let origHome;
-    let crouterDir;
-    before(() => {
-        testHomeDir = join(tmpdir(), `crtr-resolver-test-${Date.now()}`);
-        mkdirSync(testHomeDir, { recursive: true });
-        origHome = process.env['HOME'];
-        process.env['HOME'] = testHomeDir;
-        crouterDir = join(testHomeDir, '.crouter');
-        mkdirSync(crouterDir, { recursive: true });
-    });
-    after(() => {
-        if (origHome === undefined) {
-            delete process.env['HOME'];
-        }
-        else {
-            process.env['HOME'] = origHome;
-        }
-        rmSync(testHomeDir, { recursive: true, force: true });
-    });
-    test('colon keys are migrated to slash keys and written with new schema_version', () => {
-        const oldConfig = {
-            schema_version: 1,
-            marketplaces: {},
-            plugins: {},
-            skills: {
-                'ai:foo': { enabled: true },
-                'ai:interface/cli-design': { enabled: false },
-            },
-            auto_update: { crtr: 'notify', content: 'notify', interval_hours: 24 },
-            max_panes_per_window: 3,
-        };
-        writeFileSync(join(crouterDir, 'config.json'), JSON.stringify(oldConfig), 'utf8');
-        const cfg = readConfig('user');
-        assert.ok(!('ai:foo' in cfg.skills), 'old colon key should be gone');
-        assert.ok('ai/foo' in cfg.skills, 'slash key should exist');
-        assert.equal(cfg.skills['ai/foo']?.enabled, true, 'enabled state preserved');
-        assert.ok(!('ai:interface/cli-design' in cfg.skills), 'old colon key should be gone');
-        assert.ok('ai/interface/cli-design' in cfg.skills, 'slash key should exist for nested');
-        assert.equal(cfg.skills['ai/interface/cli-design']?.enabled, false, 'disabled state preserved');
-        assert.equal(cfg.schema_version, SCHEMA_VERSION, 'schema_version bumped to current');
-    });
-});
-// ---------------------------------------------------------------------------
-// resolveSkill — leaf-name fallback
-// ---------------------------------------------------------------------------
-describe('resolveSkill leaf-name fallback', () => {
-    let testHomeDir;
-    let origHome;
-    function writePluginSkill(plugin, skillPath) {
-        const root = join(testHomeDir, '.crouter', 'plugins', plugin);
-        mkdirSync(join(root, '.crouter-plugin'), { recursive: true });
-        writeFileSync(join(root, '.crouter-plugin', 'plugin.json'), JSON.stringify({ name: plugin, version: '0.0.1' }), 'utf8');
-        const skillDir = join(root, 'skills', ...skillPath.split('/'));
-        mkdirSync(skillDir, { recursive: true });
-        writeFileSync(join(skillDir, 'SKILL.md'), `---\nname: ${skillPath.split('/').pop()}\n---\nbody`, 'utf8');
-    }
-    before(() => {
-        testHomeDir = join(tmpdir(), `crtr-leaf-test-${Date.now()}`);
-        mkdirSync(testHomeDir, { recursive: true });
-        origHome = process.env['HOME'];
-        process.env['HOME'] = testHomeDir;
-        resetScopeCache();
-        // Unique leaf: only one plugin has it, reached via nested path.
-        writePluginSkill('ai', 'interface/cli-design');
-        // Colliding leaf: two plugins both expose `dup` at different paths.
-        writePluginSkill('pa', 'x/dup');
-        writePluginSkill('pb', 'y/dup');
-    });
-    after(() => {
-        if (origHome === undefined)
-            delete process.env['HOME'];
-        else
-            process.env['HOME'] = origHome;
-        resetScopeCache();
-        rmSync(testHomeDir, { recursive: true, force: true });
-    });
-    test('bare leaf name resolves to the nested skill', () => {
-        const s = resolveSkill('cli-design');
-        assert.equal(s.name, 'interface/cli-design');
-        assert.equal(s.plugin, 'ai');
-    });
-    test('full path still resolves directly', () => {
-        const s = resolveSkill('ai/interface/cli-design');
-        assert.equal(s.name, 'interface/cli-design');
-        assert.equal(s.plugin, 'ai');
-    });
-    test('colliding leaf name throws ambiguous listing full paths', () => {
-        assert.throws(() => resolveSkill('dup'), (e) => {
-            assert.ok(e instanceof CrtrError, 'should be CrtrError');
-            assert.equal(e.code, 'ambiguous');
-            assert.match(e.message, /pa\/x\/dup/);
-            assert.match(e.message, /pb\/y\/dup/);
-            return true;
-        });
-    });
-    test('colliding leaf is resolvable via full path', () => {
-        const s = resolveSkill('pb/y/dup');
-        assert.equal(s.plugin, 'pb');
-        assert.equal(s.name, 'y/dup');
-    });
-    test('unknown leaf still throws not_found', () => {
-        assert.throws(() => resolveSkill('no-such-leaf-xyz'), (e) => {
-            assert.ok(e instanceof CrtrError);
-            assert.equal(e.code, 'not_found');
-            return true;
-        });
-    });
-});

package/dist/core/__tests__/spike-harness.test.js

@@ -1,242 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/spike-harness.test.ts
-//
-// SPIKE — a throwaway-grade proof that a faithful integration harness for the
-// node/canvas runtime is feasible. It drives the REAL `crtr` CLI into an
-// isolated REAL tmux session, substitutes a FAKE-PI vehicle (the fake-pi-host
-// fixture) via the CRTR_PI_BINARY seam, and proves the spawned window actually
-// exec's the fake pi with the right argv+env, that the fake loads the REAL
-// extensions, and that one real lifecycle hook drives a real canvas transition.
-//
-// Milestones (de-risk order):
-//   1. SEAM      — piCommand substitutes CRTR_PI_BINARY only when set (unit).
-//   2. ROUND-TRIP— real `node new` → isolated tmux window → fake pi boots with
-//                  CRTR_NODE_ID + the -e env intact (GO/NO-GO).
-//   3. REAL HOOKS— the fake pi loads the real stophook and a clean /quit drives
-//                  status=done via the real session_shutdown handler.
-//   4. TEARDOWN  — the isolated session + fake-pi procs are killed; no strays.
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawnSync } from 'node:child_process';
-import { mkdtempSync, rmSync, existsSync, readFileSync, readdirSync, writeFileSync, } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-import { createNode, getNode } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
-import { piCommand } from '../runtime/placement.js';
-import { CANVAS_EXTENSIONS } from '../runtime/launch.js';
-// --- locations --------------------------------------------------------------
-const HERE = dirname(fileURLToPath(import.meta.url)); // src/core/__tests__
-const CROUTER = join(HERE, '..', '..', '..'); // package root
-const CLI_SRC = join(CROUTER, 'src', 'cli.ts');
-const FAKE_PI_HOST = join(HERE, 'fixtures', 'fake-pi-host.ts');
-const TSX_ESM = createRequire(import.meta.url).resolve('tsx/esm');
-// A multi-word launcher baked verbatim ahead of the (shell-quoted) argv.
-const FAKE_PI_BINARY = `${process.execPath} --import ${TSX_ESM} ${FAKE_PI_HOST}`;
-function hasTmux() {
-    return spawnSync('tmux', ['-V'], { stdio: 'ignore' }).status === 0;
-}
-function tmuxSessionExists(session) {
-    return spawnSync('tmux', ['has-session', '-t', session], { stdio: 'ignore' }).status === 0;
-}
-// --- env isolation: scrub every canvas var the harness itself runs under, so
-// the spawned CLI cannot leak into the real canvas. -------------------------
-const CANVAS_ENV_KEYS = [
-    'CRTR_NODE_ID',
-    'CRTR_HOME',
-    'CRTR_ROOT_SESSION',
-    'CRTR_SUBTREE',
-    'CRTR_NODE_SESSION',
-    'CRTR_PARENT_NODE_ID',
-    'CRTR_FRONT_DOOR',
-    'CRTR_KIND',
-    'CRTR_MODE',
-    'CRTR_LIFECYCLE',
-    'CRTR_NODE_CWD',
-    'CRTR_PI_BINARY',
-    'TMUX',
-    'TMUX_PANE',
-];
-function cleanBaseEnv() {
-    const e = {};
-    for (const [k, v] of Object.entries(process.env))
-        if (v !== undefined)
-            e[k] = v;
-    for (const k of CANVAS_ENV_KEYS)
-        delete e[k];
-    // Contain per-invocation bootstrap + auto-update side effects.
-    e['CRTR_NO_BOOTSTRAP'] = '1';
-    e['CRTR_NO_AUTO_UPDATE'] = '1';
-    e['CRTR_NO_BOOT_SKILL'] = '1';
-    e['CRTR_NO_MODE_CMDS'] = '1';
-    e['CRTR_NO_AUTO_INIT'] = '1';
-    return e;
-}
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: CROUTER,
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'resident',
-        status: 'active',
-        parent: null,
-        ...over,
-    };
-}
-async function waitFor(probe, opts = {}) {
-    const timeoutMs = opts.timeoutMs ?? 20_000;
-    const intervalMs = opts.intervalMs ?? 150;
-    const deadline = Date.now() + timeoutMs;
-    for (;;) {
-        const v = probe();
-        if (v)
-            return v;
-        if (Date.now() > deadline)
-            throw new Error(`waitFor timed out: ${opts.label ?? 'condition'}`);
-        await new Promise((r) => setTimeout(r, intervalMs));
-    }
-}
-// --- harness state ----------------------------------------------------------
-let home;
-let tmpHome;
-let origHome;
-const sessionsToKill = new Set();
-const pidsToKill = new Set();
-before(() => {
-    origHome = process.env['CRTR_HOME'];
-    home = mkdtempSync(join(tmpdir(), 'crtr-spike-home-'));
-    tmpHome = mkdtempSync(join(tmpdir(), 'crtr-spike-HOME-'));
-    // The harness reads/writes the isolated canvas in-process.
-    process.env['CRTR_HOME'] = home;
-    closeDb();
-});
-after(() => {
-    for (const s of sessionsToKill)
-        spawnSync('tmux', ['kill-session', '-t', s], { stdio: 'ignore' });
-    for (const p of pidsToKill) {
-        try {
-            process.kill(p, 'SIGKILL');
-        }
-        catch {
-            /* already gone */
-        }
-    }
-    closeDb();
-    if (home)
-        rmSync(home, { recursive: true, force: true });
-    if (tmpHome)
-        rmSync(tmpHome, { recursive: true, force: true });
-    if (origHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = origHome;
-});
-// ===========================================================================
-// MILESTONE 1 — the CRTR_PI_BINARY seam (always runs; no tmux needed).
-// ===========================================================================
-test('M1 seam: piCommand exec\'s `pi` when CRTR_PI_BINARY is unset, substitutes when set', () => {
-    const saved = process.env['CRTR_PI_BINARY'];
-    try {
-        delete process.env['CRTR_PI_BINARY'];
-        const unset = piCommand(['-e', '/abs/ext.ts', '-n', 'label']);
-        assert.equal(unset, "pi '-e' '/abs/ext.ts' '-n' 'label'", 'unset → identical to exec pi');
-        assert.ok(unset.startsWith('pi '), 'unset → leads with the literal pi binary');
-        process.env['CRTR_PI_BINARY'] = '/tmp/fake-pi';
-        const set = piCommand(['-e', '/abs/ext.ts']);
-        assert.ok(set.startsWith('/tmp/fake-pi '), 'set → leads with the substituted binary');
-        assert.ok(!set.startsWith('pi '), 'set → no longer the literal pi');
-        assert.equal(set, "/tmp/fake-pi '-e' '/abs/ext.ts'", 'argv still shell-quoted after the substitution');
-        // A multi-word launcher is spliced verbatim (argv stays quoted).
-        process.env['CRTR_PI_BINARY'] = 'node --import tsx/esm host.ts';
-        assert.equal(piCommand(['-n', 'x']), "node --import tsx/esm host.ts '-n' 'x'", 'multi-word binary spliced ahead of the quoted argv');
-        // An explicit binary arg still overrides the env.
-        assert.ok(piCommand(['-n', 'x'], 'pi').startsWith('pi '), 'explicit binary arg wins over the env seam');
-    }
-    finally {
-        if (saved === undefined)
-            delete process.env['CRTR_PI_BINARY'];
-        else
-            process.env['CRTR_PI_BINARY'] = saved;
-    }
-});
-// ===========================================================================
-// MILESTONES 2 + 3 — real CLI → isolated tmux → fake pi → real hooks.
-// THE GO/NO-GO. Shares one spawned child across both milestones.
-// ===========================================================================
-test('M2+M3 round-trip: real `node new` reaches the fake pi via the seam, and a real hook drives status=done', { skip: !hasTmux() }, async () => {
-    const session = `crtr-spike-${process.pid}-rt`;
-    sessionsToKill.add(session);
-    // Pre-create the isolated session (default tmux server — the runtime shells
-    // `tmux` with no -L, so an -L server would be invisible to the real CLI).
-    spawnSync('tmux', ['new-session', '-d', '-s', session, '-c', CROUTER, 'sleep 600'], {
-        stdio: 'ignore',
-    });
-    assert.ok(tmuxSessionExists(session), 'isolated tmux session created');
-    // Bootstrap the acting node in the isolated canvas (the parent `node new`
-    // spawns under). createNode shares the harness CRTR_HOME.
-    createNode(node('A', { name: 'acting-root' }));
-    // Drive the REAL CLI: `crtr node new` AS node A, into the isolated session,
-    // with the fake-pi seam. Body passed as a positional (dodges the stdin hang).
-    const env = cleanBaseEnv();
-    env['CRTR_HOME'] = home;
-    env['HOME'] = tmpHome;
-    env['CRTR_NODE_ID'] = 'A';
-    env['CRTR_NODE_SESSION'] = session;
-    env['CRTR_PI_BINARY'] = FAKE_PI_BINARY;
-    const res = spawnSync(process.execPath, ['--import', TSX_ESM, CLI_SRC, 'node', 'new', 'spike task', '--parent', 'A', '--cwd', CROUTER], { cwd: CROUTER, env, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 60_000 });
-    assert.equal(res.status, 0, `node new should exit 0\n--- stdout ---\n${res.stdout}\n--- stderr ---\n${res.stderr}`);
-    // Find the spawned child: the only node dir that isn't the acting root.
-    closeDb();
-    const nodesDir = join(home, 'nodes');
-    const childId = readdirSync(nodesDir).find((d) => d !== 'A');
-    assert.ok(childId, 'a child node dir was created by node new');
-    // ---- MILESTONE 2 assertions: the round-trip reached the fake pi --------
-    const bootPath = join(nodesDir, childId, 'fake-pi.boot.json');
-    const errPath = join(nodesDir, childId, 'fake-pi.error');
-    await waitFor(() => existsSync(bootPath), {
-        timeoutMs: 30_000,
-        label: `fake-pi boot proof at ${bootPath}${existsSync(errPath) ? ` (error file: ${readFileSync(errPath, 'utf8')})` : ''}`,
-    });
-    const boot = JSON.parse(readFileSync(bootPath, 'utf8'));
-    if (typeof boot.pid === 'number')
-        pidsToKill.add(boot.pid);
-    // env delivered via tmux -e arrived in the fake pi's process.env.
-    assert.equal(boot.env.CRTR_NODE_ID, childId, 'CRTR_NODE_ID is the CHILD id, intact');
-    assert.equal(boot.env.CRTR_HOME, home, 'CRTR_HOME isolated value intact');
-    assert.ok(boot.env.CRTR_KIND, 'CRTR_KIND present');
-    assert.ok(boot.env.CRTR_MODE, 'CRTR_MODE present');
-    assert.ok(boot.env.CRTR_LIFECYCLE, 'CRTR_LIFECYCLE present');
-    assert.equal(boot.env.CRTR_FRONT_DOOR, '1', 'CRTR_FRONT_DOOR overlay present');
-    // argv from buildPiArgv arrived: every canvas -e extension + the kickoff.
-    // Assert against the live CANVAS_EXTENSIONS count (8 at current HEAD — the
-    // placement-v3 refactor added canvas-resume) so this never drifts again.
-    assert.equal(boot.extPaths.length, CANVAS_EXTENSIONS.length, `all ${CANVAS_EXTENSIONS.length} canvas -e extension paths in argv`);
-    assert.ok(boot.loaded.some((p) => p.includes('canvas-stophook')), 'real stophook module loaded by the fake pi');
-    assert.ok(boot.loaded.some((p) => p.includes('canvas-inbox-watcher')), 'real inbox-watcher module loaded by the fake pi');
-    assert.equal(boot.failedExt.length, 0, `no extension failed to load: ${JSON.stringify(boot.failedExt)}`);
-    assert.equal(boot.resuming, false, 'fresh start (no --session)');
-    assert.equal(boot.prompt, 'spike task', 'kickoff prompt is the last positional');
-    // The REAL stophook session_start handler ran inside the fake pi and wrote
-    // shared canvas state (proves the hook chain, not just the boot).
-    closeDb();
-    const afterBoot = getNode(childId);
-    assert.ok(afterBoot, 'child node readable from the shared canvas');
-    assert.equal(afterBoot.pi_session_id, boot.sessionId, 'stophook captured pi_session_id');
-    assert.equal(afterBoot.status, 'active', 'child active after boot');
-    // ---- MILESTONE 3: a clean /quit drives a real transition to done -------
-    writeFileSync(join(nodesDir, childId, 'fake-pi.cmd'), JSON.stringify({ cmd: 'shutdown' }));
-    const done = await waitFor(() => {
-        closeDb();
-        return getNode(childId)?.status === 'done' ? true : false;
-    }, { timeoutMs: 20_000, label: 'child status=done after clean /quit' });
-    assert.ok(done, 'real session_shutdown hook resolved the node to done');
-    assert.equal(getNode(childId)?.status, 'done', 'status=done via the real stophook');
-    // ---- MILESTONE 4: teardown leaves no stray session ---------------------
-    spawnSync('tmux', ['kill-session', '-t', session], { stdio: 'ignore' });
-    sessionsToKill.delete(session);
-    assert.ok(!tmuxSessionExists(session), 'isolated session killed, no stray left');
-});