@north-light/crouter 0.3.318 → 0.3.319

package/dist/core/__tests__/seam/yield-refresh-transaction.test.js

@@ -1,100 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/seam/yield-refresh-transaction.test.ts
-//
-// Regression: one-shot <yield-message/> handoff must survive pre-session_start cycle
-// death and only clear once session_start confirms a successful boot, and a
-// competing strict-resume revive (issue #146: a real `surface node focus` while
-// the refresh is still pending) must not reopen the old session. This test runs
-// against the real broker process (headless harness) and a deterministic one-shot
-// pre-start fault injection so a single retry is exercised in-band.
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync } from 'node:fs';
-import { createHarness } from '../helpers/harness.js';
-import { isPidAlive } from '../../canvas/pid.js';
-import { reviveNode } from '../../runtime/revive.js';
-import { readYieldMessage, yieldMessagePath } from '../../runtime/kickoff.js';
-import { FAIL_BEFORE_SESSION_START_ONCE } from '../fixtures/fake-engine.js';
-let h;
-let root;
-before(async () => {
-    h = await createHarness({ headless: true, sessionPrefix: 'crtr-bug146' });
-    root = h.spawnRoot('bug146-suite root');
-});
-after(async () => {
-    if (h !== undefined)
-        await h.dispose();
-});
-// 30s (approved compiled-seam cap): three real broker boots plus the durable
-// respawn backoff's first ~5s delay before the successful retry.
-test('yield-message survives one pre-session_start retry and clears on session_start', { timeout: 30_000 }, async () => {
-    const note = `Issue #146 pre-session_start replay ${FAIL_BEFORE_SESSION_START_ONCE} keeps the wake note`;
-    const id = await h.spawnHeadlessChild(root, 'headless worker — yield message transactional retry');
-    const baseBoot = h.bootCount(id);
-    const baseCycles = h.node(id).cycles ?? 0;
-    const oldPid = h.node(id).pi_pid;
-    const rc = h.cli(id, ['node', 'yield', note]);
-    assert.equal(rc.code, 0, `node yield should succeed\n--stderr--\n${rc.stderr}`);
-    // `node yield` arms intent=refresh; the current turn ending is what lets the
-    // stophook release the old broker. The supervision tick classifies that real
-    // ChildProcess exit, persists its backoff, and launches the fresh cycle once
-    // the backoff matures.
-    await h.stop(id);
-    await h.waitFor(() => !isPidAlive(oldPid), { label: 'yielded broker exited before session_start' });
-    await h.awaitFleetExit(id);
-    await h.tick();
-    const initialRefreshBackoff = h.node(id);
-    assert.equal(initialRefreshBackoff.respawn_failures, 1, 'the old broker death is durably counted');
-    assert.ok(initialRefreshBackoff.respawn_not_before != null, 'the initial refresh retry is durably deferred');
-    assert.equal(initialRefreshBackoff.pi_pid, null, 'classification clears the old broker pid');
-    await h.tick(Date.parse(initialRefreshBackoff.respawn_not_before) + 1);
-    // The initial refresh attempt launches and fails before session_start,
-    // leaving the note still present in node context.
-    const failedCyclePid = await h.waitFor(() => {
-        const pid = h.node(id)?.pi_pid;
-        return pid != null && pid !== oldPid ? pid : null;
-    }, { label: 'tick-driven refresh attempt recorded its broker pid', timeoutMs: 30_000 });
-    await h.waitFor(() => !isPidAlive(failedCyclePid), { label: 'one-shot cycling broker died before session_start' });
-    // PID death precedes Node's ChildProcess `exit` delivery. Wait through the
-    // authoritative fleet barrier, then classify the failure once so the contender
-    // below reaches refresh arbitration while durable backoff is pending.
-    await h.awaitFleetExit(id);
-    await h.tick();
-    const afterFirstExit = h.node(id);
-    assert.equal(h.fleet.has(id), false, 'the failed broker has left the authoritative fleet before focus competes');
-    assert.equal(afterFirstExit?.cycles, baseCycles + 1, 'the first refresh attempt advances cycles');
-    assert.equal(afterFirstExit?.intent, 'refresh', 'the durable refresh intent still confronts the strict-resume contender');
-    assert.equal(afterFirstExit?.cycle_pending, true, 'cycle_pending remains true until session_start confirms');
-    assert.equal(afterFirstExit?.respawn_failures, 2, 'the failed refresh attempt is durably counted');
-    assert.ok(afterFirstExit?.respawn_not_before != null, 'focus competes while the durable refresh backoff is pending');
-    assert.equal(readYieldMessage(id), note, 'yield note stays present after pre-session_start failure');
-    assert.equal(existsSync(yieldMessagePath(id)), true, 'yield file survives the failed cycle');
-    // A real `surface node focus` on the node right now asks the revive arbiter for
-    // a STRICT RESUME (issue #146). It must lose to the durable pending refresh:
-    // the retry still roots a fresh cycle carrying the note, never reopening the
-    // old session. Driving reviveNode directly is exactly what focus's revive path
-    // calls, minus a tmux pane this contract does not involve.
-    const focusRevive = await reviveNode(id, { resume: true, capacity: 'freeze' });
-    const focusPid = focusRevive.launch?.pid;
-    assert.ok(focusPid != null, 'the competing focus invocation launches the replacement broker');
-    assert.equal(focusRevive.resumed, false, 'refresh intent overrides this invocation\'s strict-resume request');
-    assert.equal(h.fleet.get(id)?.pid, focusPid, 'the focus invocation owns the authoritative fleet slot');
-    // Registering the manual launch cancels the exit policy's deferred recovery.
-    // Its pid must therefore be the successful observed boot, proving these
-    // assertions belong to the contender above rather than an already-queued boot.
-    const boot = await h.awaitBoot(id, { minCount: baseBoot + 1, timeoutMs: 120_000 });
-    assert.equal(boot.pid, focusPid, 'the competing focus invocation owns the confirmed boot');
-    const afterRetry = h.node(id);
-    assert.equal(afterRetry?.cycles, baseCycles + 2, 'the retry advances once from the latest locked cycle');
-    assert.equal(afterRetry?.cycle_pending, false, 'session_start cleared cycle_pending');
-    assert.equal(readYieldMessage(id), null, 'yield note cleared only after confirmed session_start');
-    assert.equal(existsSync(yieldMessagePath(id)), false, 'yield file removed after confirmed boot');
-    assert.ok(boot.prompt !== null, 'successful retry records a kickoff prompt');
-    assert.equal(boot.prompt.includes(note), true, 'the successful retry kickoff still contains the yield note');
-    assert.match(boot.prompt, /<goal file="[^"]+">/, 'a no-roadmap base refresh includes its original goal');
-    assert.equal(boot.prompt.includes('headless worker — yield message transactional retry'), true, 'the kickoff carries the original base-node mandate');
-    assert.equal(boot.resuming, false, 'a competing focus resume=true cannot reopen the old session while the refresh is pending');
-    const updated = h.node(id);
-    assert.equal(updated?.mode, 'base', 'a plain yield refresh remains base');
-    assert.ok(updated?.pi_session_id != null, 'successful retry recorded a session id');
-});
-// Keep this file one purpose and one assertion surface: real runtime replay.

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

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

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

@@ -1,49 +0,0 @@
-// secrets.test.ts — the 0600 relay-token store (`../secrets.ts`). Covers the
-// round-trip (set/get/delete) and the one load-bearing invariant a JSON
-// config file doesn't get for free: the file is written 0600, not the
-// process's default umask-derived mode.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, statSync, existsSync, chmodSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { readSecrets, writeSecrets, getRelayToken, setRelayToken, deleteRelayToken } from '../secrets.js';
-let home;
-let realHome;
-before(() => {
-    realHome = process.env['HOME'];
-    home = mkdtempSync(join(tmpdir(), 'crtr-secrets-'));
-    process.env['HOME'] = home;
-});
-beforeEach(() => {
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    rmSync(home, { recursive: true, force: true });
-    if (realHome !== undefined)
-        process.env['HOME'] = realHome;
-    else
-        delete process.env['HOME'];
-});
-test('a scope with no secrets.json yet reads as empty', () => {
-    assert.deepEqual(readSecrets('user'), { relayTokens: {} });
-    assert.equal(getRelayToken('cloud', 'user'), undefined);
-});
-test('set/get/delete round-trip a token by ref', () => {
-    setRelayToken('cloud', 'sekret-token-value', 'user');
-    assert.equal(getRelayToken('cloud', 'user'), 'sekret-token-value');
-    deleteRelayToken('cloud', 'user');
-    assert.equal(getRelayToken('cloud', 'user'), undefined);
-});
-test('writeSecrets writes secrets.json 0600, even over a pre-existing looser-mode file', () => {
-    writeSecrets('user', { relayTokens: { a: 'x' } });
-    const p = join(home, '.crouter', 'secrets.json');
-    assert.ok(existsSync(p));
-    assert.equal(statSync(p).mode & 0o777, 0o600);
-    // Re-write over an existing file that had a looser mode — chmodSync must
-    // re-tighten it, not just rely on the initial writeFileSync mode.
-    chmodSync(p, 0o644);
-    assert.equal(statSync(p).mode & 0o777, 0o644);
-    writeSecrets('user', { relayTokens: { a: 'x', b: 'y' } });
-    assert.equal(statSync(p).mode & 0o777, 0o600);
-});

package/dist/core/__tests__/self-update.test.d.ts

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

package/dist/core/__tests__/self-update.test.js

@@ -1,46 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync, spawnSync } from 'node:child_process';
-import { chmodSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import test from 'node:test';
-const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..');
-const SELF_UPDATE = join(ROOT, 'scripts', 'self-update.mjs');
-test('self-update installs the downloaded release without replacing the stable global shim', () => {
-    const directory = mkdtempSync(join(tmpdir(), 'crtr-self-update-test-'));
-    try {
-        const release = join(directory, 'release');
-        const archive = join(directory, 'release.tgz');
-        const bin = join(directory, 'bin');
-        const stableShim = join(bin, 'crtr');
-        const marker = join(directory, 'selected');
-        const calls = join(directory, 'npm-calls');
-        const fakeBin = join(directory, 'fake-bin');
-        mkdirSync(join(release, 'scripts'), { recursive: true });
-        mkdirSync(bin);
-        mkdirSync(fakeBin);
-        writeFileSync(join(release, 'scripts', 'install-runtime.mjs'), `import { writeFileSync } from 'node:fs';\nwriteFileSync(process.env.CRTR_SELF_UPDATE_MARKER, 'selected');\n`);
-        execFileSync('tar', ['-czf', archive, '-C', release, '.']);
-        symlinkSync('../stable-crtr', stableShim);
-        writeFileSync(join(fakeBin, 'npm'), `#!/usr/bin/env node\nimport { copyFileSync, appendFileSync } from 'node:fs';\nimport { basename, join } from 'node:path';\nconst args = process.argv.slice(2);\nappendFileSync(process.env.CRTR_SELF_UPDATE_CALLS, args.join(' ') + '\\n');\nif (args[0] !== 'pack') process.exit(1);\nconst destination = args[args.indexOf('--pack-destination') + 1];\ncopyFileSync(process.env.CRTR_SELF_UPDATE_ARCHIVE, join(destination, basename(process.env.CRTR_SELF_UPDATE_ARCHIVE)));\nprocess.stdout.write(JSON.stringify([{ filename: basename(process.env.CRTR_SELF_UPDATE_ARCHIVE) }]));\n`);
-        chmodSync(join(fakeBin, 'npm'), 0o755);
-        const result = spawnSync(process.execPath, [SELF_UPDATE], {
-            encoding: 'utf8',
-            env: {
-                ...process.env,
-                PATH: `${fakeBin}:${process.env.PATH}`,
-                CRTR_SELF_UPDATE_ARCHIVE: archive,
-                CRTR_SELF_UPDATE_CALLS: calls,
-                CRTR_SELF_UPDATE_MARKER: marker,
-            },
-        });
-        assert.equal(result.status, 0, result.stderr);
-        assert.equal(readFileSync(marker, 'utf8'), 'selected');
-        assert.equal(readlinkSync(stableShim), '../stable-crtr');
-        assert.match(readFileSync(calls, 'utf8'), /^pack @north-light\/crouter@latest --json --pack-destination .+\/crtr-self-update-\S+\n$/);
-    }
-    finally {
-        rmSync(directory, { recursive: true, force: true });
-    }
-});

package/dist/core/__tests__/session-branch.test.d.ts

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

package/dist/core/__tests__/session-branch.test.js

@@ -1,61 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/session-branch.test.ts
-//
-// The pinned Pi SDK's createBranchedSession mutates the manager that calls it.
-// This regression keeps that call detached: ask provenance follows one captured
-// ancestry while the source manager keeps its file/session identity and accepts
-// later progress in the original session.
-import { after, before, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, readFileSync, rmSync, statSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { SessionManager } from '../runtime/broker-sdk.js';
-import { materializeSessionBranchAt } from '../runtime/session-branch.js';
-let dir;
-before(() => {
-    dir = mkdtempSync(join(tmpdir(), 'crtr-session-branch-'));
-});
-after(() => {
-    rmSync(dir, { recursive: true, force: true });
-});
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function assistant(text) {
-    return {
-        role: 'assistant',
-        content: [{ type: 'text', text }],
-        api: 'anthropic-messages',
-        provider: 'anthropic',
-        model: 'sonnet',
-        usage: { input: 1, output: 1, cacheRead: 0, cacheWrite: 0, totalTokens: 2, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
-        stopReason: 'stop',
-        timestamp: Date.now(),
-    };
-}
-test('detached SDK materialization captures only the selected ancestry and leaves the source session writable', () => {
-    const source = SessionManager.create(dir);
-    const root = source.appendCustomEntry('test', { marker: 'ROOT-ANCESTRY' });
-    const selectedLeaf = source.appendMessage(assistant('CHOSEN-ANCESTRY'));
-    source.branch(root);
-    source.appendCustomEntry('test', { marker: 'OFF-PATH-SIBLING' });
-    source.branch(selectedLeaf);
-    const sourceFile = source.getSessionFile();
-    assert.ok(sourceFile, 'the persisted source session exists');
-    const sourceSessionId = source.getSessionId();
-    const branchFile = join(dir, 'branch-point.jsonl');
-    materializeSessionBranchAt({ sourceFile, sourceSessionId, leafId: selectedLeaf }, branchFile);
-    assert.equal(source.getSessionFile(), sourceFile, 'the live manager keeps its original file');
-    assert.equal(source.getSessionId(), sourceSessionId, 'the live manager keeps its original session id');
-    assert.equal(statSync(branchFile).mode & 0o777, 0o600, 'the immutable provenance is private');
-    source.appendCustomEntry('test', { marker: 'LATER-SOURCE-APPEND' });
-    const reopened = SessionManager.open(sourceFile);
-    reopened.appendCustomEntry('test', { marker: 'REOPENED-SOURCE-APPEND' });
-    const branchText = readFileSync(branchFile, 'utf8');
-    assert.match(branchText, /ROOT-ANCESTRY/);
-    assert.match(branchText, /CHOSEN-ANCESTRY/);
-    assert.doesNotMatch(branchText, /OFF-PATH-SIBLING/);
-    assert.doesNotMatch(branchText, /LATER-SOURCE-APPEND/);
-    assert.doesNotMatch(branchText, /REOPENED-SOURCE-APPEND/);
-    const sourceText = readFileSync(sourceFile, 'utf8');
-    assert.match(sourceText, /LATER-SOURCE-APPEND/);
-    assert.match(sourceText, /REOPENED-SOURCE-APPEND/);
-});

package/dist/core/__tests__/session-cycles.test.d.ts

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

package/dist/core/__tests__/session-cycles.test.js

@@ -1,133 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/session-cycles.test.ts
-//
-// `cycleAwareMessages` reuses pi's own `buildSessionContext` to replay a PRIOR
-// cycle's branch, so a cycle that was compacted before it yielded renders its
-// compaction summary (and only the kept + post-compaction messages) instead of
-// every raw pre-compaction message. This is a light smoke test — the
-// compaction resolution itself is SDK behavior being delegated to, not
-// reimplemented here; this only proves the wiring is real.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { buildSessionContext } from '@earendil-works/pi-coding-agent';
-import { cycleAwareMessages, CRTR_CYCLE_CUSTOM_TYPE } from '../runtime/session-cycles.js';
-function userMsg(id, parentId, text) {
-    return {
-        type: 'message',
-        id,
-        parentId,
-        timestamp: new Date(0).toISOString(),
-        message: { role: 'user', content: text, timestamp: 0 },
-    };
-}
-function assistantMsg(id, parentId, content, stopReason, errorMessage) {
-    return {
-        type: 'message',
-        id,
-        parentId,
-        timestamp: new Date(0).toISOString(),
-        message: { role: 'assistant', content, stopReason, errorMessage, timestamp: 0 },
-    };
-}
-function cycleManager(entries, currentId) {
-    const byId = new Map(entries.map((entry) => [entry.id, entry]));
-    const branchFrom = (fromId) => {
-        const path = [];
-        let current = byId.get(fromId);
-        while (current) {
-            path.push(current);
-            current = current.parentId ? byId.get(current.parentId) : undefined;
-        }
-        return path.reverse();
-    };
-    return {
-        buildSessionContext: () => buildSessionContext(entries, currentId, byId),
-        getEntries: () => entries,
-        getBranch: (fromId) => branchFrom(fromId ?? currentId),
-    };
-}
-test('cycleAwareMessages: a compacted prior cycle replays via buildSessionContext (one summary, no raw pre-compaction messages)', () => {
-    // Cycle 0: m1 -> m2 -> [compaction c1, keeping from m2] -> m3 (cycle 0's leaf
-    // at yield time). Cycle marker cy1 roots a FRESH branch (parentId: null, per
-    // resetLeaf()+appendCustomEntry semantics), fromLeaf points back at m3. Cycle
-    // 1: m4 is the live leaf.
-    const m1 = userMsg('m1', null, 'pre-compaction message — must NOT appear in the replay');
-    const m2 = userMsg('m2', 'm1', 'kept message — compaction keeps from here');
-    const c1 = {
-        type: 'compaction',
-        id: 'c1',
-        parentId: 'm2',
-        timestamp: new Date(0).toISOString(),
-        summary: 'summary of the abandoned context',
-        firstKeptEntryId: 'm2',
-        tokensBefore: 12_000,
-    };
-    const m3 = userMsg('m3', 'c1', 'post-compaction message, cycle 0 leaf at yield');
-    const cy1 = {
-        type: 'custom',
-        id: 'cy1',
-        parentId: null,
-        timestamp: new Date(1).toISOString(),
-        customType: CRTR_CYCLE_CUSTOM_TYPE,
-        data: { cycle: 2, fromLeaf: 'm3' },
-    };
-    const m4 = userMsg('m4', 'cy1', 'cycle 1 live message');
-    const entries = [m1, m2, c1, m3, cy1, m4];
-    // Minimal fake mirroring the real SDK's SessionManager just enough to drive
-    // cycleAwareMessages: buildSessionContext() plus the tree accessors it reads.
-    const out = cycleAwareMessages(cycleManager(entries, 'm4'));
-    assert.ok(out);
-    const summaries = out.filter(({ message }) => message.role === 'compactionSummary');
-    assert.equal(summaries.length, 1, 'exactly one compactionSummary message from the replayed prior cycle');
-    const texts = out.map(({ message }) => (typeof message.content === 'string' ? message.content : ''));
-    assert.ok(!texts.some((t) => t.includes('pre-compaction message')), 'the pre-compaction raw message (m1) must NOT appear');
-    assert.ok(texts.some((t) => t.includes('kept message')), 'the kept message (m2) DOES appear');
-    assert.ok(texts.some((t) => t.includes('cycle 0 leaf at yield')), 'the post-compaction message (m3) DOES appear');
-    assert.ok(texts.some((t) => t.includes('cycle 1 live message')), 'the live cycle (m4) DOES appear');
-    const dividers = out.filter(({ message }) => message.customType === 'crtr-cycle-divider');
-    assert.equal(dividers.length, 1, 'one divider between the replayed prior cycle and the live one');
-    assert.equal(dividers[0].id, 'cy1~divider', 'the synthesized divider stays tied to its cycle marker');
-});
-test('cycleAwareMessages: a yielded cycle keeps terminal assistant content without an abort notice', () => {
-    const m1 = userMsg('m1', null, 'yield after this turn');
-    const toolCall = { type: 'toolCall', id: 'yield-call', name: 'bash', arguments: { command: 'crtr node yield' } };
-    const m2 = assistantMsg('m2', 'm1', [toolCall], 'aborted', 'Request was aborted');
-    const cy1 = {
-        type: 'custom',
-        id: 'cy1',
-        parentId: null,
-        timestamp: new Date(1).toISOString(),
-        customType: CRTR_CYCLE_CUSTOM_TYPE,
-        data: { cycle: 2, fromLeaf: 'm2' },
-    };
-    const m3 = userMsg('m3', 'cy1', 'fresh cycle');
-    const out = cycleAwareMessages(cycleManager([m1, m2, cy1, m3], 'm3'));
-    assert.ok(out);
-    const yieldedAssistant = out.find(({ message }) => message.role === 'assistant').message;
-    assert.deepEqual(yieldedAssistant.content, [toolCall], 'the yielded turn remains available to transcript renderers');
-    assert.equal(yieldedAssistant.stopReason, undefined, 'yield is not presented as a failed assistant turn');
-    assert.equal(yieldedAssistant.errorMessage, undefined, 'the provider abort text is omitted with the yield boundary');
-    assert.equal(out.filter(({ message }) => message.customType === 'crtr-cycle-divider').length, 1);
-});
-// Observed shape: the yield's self-abort landed as the NEXT request was
-// starting, so the provider caught a bare AbortError instead of seeing its own
-// signal and stamped `stopReason: 'error'` on an empty turn. Pi's assistant
-// component reserves a red `Error: …` line for exactly that stopReason, so the
-// annotation must come off here too — a yield is not a failure.
-test('cycleAwareMessages: a yield abort recorded as a provider error is still not a failed turn', () => {
-    const m1 = userMsg('m1', null, 'yield after this turn');
-    const m2 = assistantMsg('m2', 'm1', [], 'error', 'This operation was aborted');
-    const cy1 = {
-        type: 'custom',
-        id: 'cy1',
-        parentId: null,
-        timestamp: new Date(1).toISOString(),
-        customType: CRTR_CYCLE_CUSTOM_TYPE,
-        data: { cycle: 2, fromLeaf: 'm2' },
-    };
-    const m3 = userMsg('m3', 'cy1', 'fresh cycle');
-    const out = cycleAwareMessages(cycleManager([m1, m2, cy1, m3], 'm3'));
-    assert.ok(out);
-    const yieldedAssistant = out.find(({ message }) => message.role === 'assistant').message;
-    assert.equal(yieldedAssistant.stopReason, undefined, 'yield is not presented as a failed assistant turn');
-    assert.equal(yieldedAssistant.errorMessage, undefined, 'the aborted-request text is omitted with the yield boundary');
-});

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

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

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

@@ -1,111 +0,0 @@
-// session-model.test.ts — the invariant that makes catch-up trustworthy:
-//
-//   applySnapshot(welcome) === fold(reduce, the events that produced it)
-//
-// A viewer learns the session two ways — one atomic `welcome` when it attaches,
-// or the live edge stream while it stays attached — and those two paths MUST
-// converge on the same state. Before D1 this was false by construction: the
-// broker's retained display levels were not in the snapshot, so a late joiner
-// could only get them as synthetic edges replayed AFTER the welcome. This test
-// is the guard that they stay convergent.
-//
-// It also pins the two behaviors the terminal and web viewers had drifted on
-// before the shared reducer existed: `agent_settled` clearing `isStreaming`
-// (which the web never learned), and a `notify` never being mistaken for a
-// dialog.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { applySnapshot, initialSessionState, reduce, } from '../session-model/session-state.js';
-const engine = (patch = {}) => ({
-    model: undefined,
-    thinkingLevel: 'off',
-    isStreaming: false,
-    isCompacting: false,
-    steeringMode: 'off',
-    followUpMode: 'off',
-    sessionFile: '/tmp/s.jsonl',
-    sessionId: 's1',
-    sessionName: 'a task',
-    autoCompactionEnabled: true,
-    messageCount: 0,
-    pendingMessageCount: 0,
-    ...patch,
-});
-const welcome = (over = {}, state = engine(), display) => ({
-    type: 'welcome',
-    role: 'controller',
-    agentDir: '/home/u/.pi/agent',
-    snapshot: {
-        messages: [],
-        stats: { contextUsage: { tokens: 1234 } },
-        state,
-        display: display ?? { statuses: {}, widgets: {}, title: undefined },
-    },
-    ...over,
-});
-const fold = (from, frames) => frames.reduce((s, f) => reduce(s, f), from);
-test('applySnapshot(welcome) equals folding the edges that produced the same broker state', () => {
-    // The live path: a viewer attached from t=0 watches these edges go by.
-    const edges = [
-        welcome(),
-        { type: 'extension_ui_request', id: 'u1', method: 'setStatus', statusKey: 'prov', statusText: 'anthropic' },
-        {
-            type: 'extension_ui_request',
-            id: 'u2',
-            method: 'setWidget',
-            widgetKey: 'recap',
-            widgetLines: ['line a', 'line b'],
-            widgetPlacement: 'belowEditor',
-        },
-        { type: 'extension_ui_request', id: 'u3', method: 'setTitle', title: 'node · a task' },
-        { type: 'agent_start' },
-        { type: 'session_info_changed', name: 'renamed task' },
-        { type: 'agent_settled' },
-    ];
-    const live = fold(initialSessionState(), edges);
-    // The catch-up path: a viewer attaching AFTER all of that gets ONE welcome,
-    // whose snapshot carries the broker's retained levels and pi's current state.
-    const late = applySnapshot(welcome({}, engine({ sessionName: 'renamed task', isStreaming: false }), {
-        statuses: { prov: 'anthropic' },
-        widgets: { recap: { lines: ['line a', 'line b'], placement: 'belowEditor' } },
-        title: 'node · a task',
-    }));
-    assert.deepEqual(late, live, 'the two ways to learn a session must agree');
-});
-test('agent_settled clears isStreaming (the frozen-Working… fix, now shared by both viewers)', () => {
-    const s0 = reduce(initialSessionState(), welcome());
-    const streaming = reduce(s0, { type: 'agent_start' });
-    assert.equal(streaming.engine?.isStreaming, true);
-    // agent_settled ALONE — no agent_end — must settle it. A dormant orchestrator
-    // between wakes showed a frozen spinner when this was missed.
-    const settled = reduce(streaming, { type: 'agent_settled' });
-    assert.equal(settled.engine?.isStreaming, false);
-});
-test('a notify is never a dialog, and never disturbs one that is pending', () => {
-    const s0 = reduce(initialSessionState(), welcome());
-    const asked = reduce(s0, { type: 'extension_ui_request', id: 'ask-1', method: 'input', title: 'Paste the code' });
-    assert.equal(asked.dialog?.id, 'ask-1');
-    const notified = reduce(asked, { type: 'extension_ui_request', id: 'n-1', method: 'notify', message: 'background progress' });
-    assert.equal(notified, asked, 'a notify carries no session state — same reference, dialog untouched');
-    // A display paint is equally inert with respect to the pending dialog.
-    const painted = reduce(asked, { type: 'extension_ui_request', id: 's-1', method: 'setStatus', statusKey: 'k', statusText: 'v' });
-    assert.equal(painted.dialog?.id, 'ask-1', 'a chrome paint must not clear a pending dialog');
-    // And only the MATCHING correlated dismiss clears it.
-    assert.equal(reduce(asked, { type: 'extension_ui_dismiss', id: 'other' }), asked);
-    assert.equal(reduce(asked, { type: 'extension_ui_dismiss', id: 'ask-1' }).dialog, null);
-});
-test('a welcome is a COMPLETE catch-up: a re-welcome drops a dead broker s levels and queue', () => {
-    const s0 = fold(initialSessionState(), [
-        welcome(),
-        { type: 'extension_ui_request', id: 'u1', method: 'setStatus', statusKey: 'gone', statusText: 'stale' },
-        { type: 'queue_update', steering: ['one', 'two'], followUp: [] },
-    ]);
-    assert.equal(s0.display.statuses['gone'], 'stale');
-    assert.deepEqual(s0.queued, [{ text: 'one' }, { text: 'two' }]);
-    assert.equal(s0.engine?.pendingMessageCount, 2);
-    // A fresh broker (post-revive) welcomes with its OWN levels and an empty queue,
-    // and emits no queue_update to overwrite the panel — so the welcome must.
-    const s1 = reduce(s0, welcome());
-    assert.deepEqual(s1.display.statuses, {}, 'a dead broker s status keys must not survive');
-    assert.deepEqual(s1.queued, [], 'a dead broker s queued rows must not survive');
-});

package/dist/core/__tests__/spawn-worktree-id-conflict.test.d.ts

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

package/dist/core/__tests__/spawn-worktree-id-conflict.test.js

@@ -1,71 +0,0 @@
-// spawn-worktree-id-conflict.test.ts — regression for a real reviewed defect:
-// spawnChild used to select the caller-supplied --node-id and call
-// createManagedWorktree BEFORE spawnNode's duplicate check ran, so a
-// `--worktree --node-id <existing>` spawn threw NodeIdConflictError but left
-// a registered worktree (checkout dir + `crtr/<id>` branch) behind — the
-// failure-cleanup catch in spawnChild intentionally keeps a worktree whenever
-// `getNode(nodeId)` already exists, which is always true for the pre-existing
-// conflicting node. The fix preflights format+duplicate BEFORE any worktree is
-// allocated.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { gitSync } from '../git.js';
-import { getNode } from '../canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../canvas/db.js';
-import { spawnNode } from '../runtime/nodes.js';
-import { spawnChild } from '../runtime/spawn.js';
-import { managedWorktreePath } from '../worktree.js';
-import { findDaemonPids, stopDaemonProcess } from '../../daemon/manage.js';
-let home;
-let repoDir;
-function run(args, cwd) {
-    const res = gitSync(args, cwd);
-    if (res.status !== 0)
-        throw new Error(`git ${args.join(' ')} failed in ${cwd}: ${res.stderr || res.stdout}`);
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-worktree-conflict-home-'));
-    process.env['CRTR_HOME'] = home;
-    repoDir = mkdtempSync(join(tmpdir(), 'crtr-worktree-conflict-repo-'));
-    run(['init', '-b', 'main'], repoDir);
-    run(['config', 'user.email', 'test@example.com'], repoDir);
-    run(['config', 'user.name', 'Test'], repoDir);
-    writeFileSync(join(repoDir, 'README.md'), 'hello\n');
-    run(['add', '.'], repoDir);
-    run(['commit', '-m', 'init'], repoDir);
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    process.env['CRTR_HOME'] = home;
-    migrate(openDb());
-});
-after(async () => {
-    closeDb();
-    await Promise.all(findDaemonPids().map((pid) => stopDaemonProcess(pid)));
-    rmSync(home, { recursive: true, force: true });
-    rmSync(repoDir, { recursive: true, force: true });
-});
-test('a --worktree spawn at an already-existing node id throws and leaves NO worktree registered', async () => {
-    const nodeId = 'duplicate-id';
-    await spawnNode({ kind: 'general', cwd: '/tmp/work', nodeId });
-    await assert.rejects(() => spawnChild({ kind: 'general', cwd: repoDir, prompt: '', worktree: true, nodeId }));
-    assert.ok(!existsSync(managedWorktreePath(nodeId)), 'the conflicting spawn must not leave a worktree checkout directory');
-    assert.equal(gitSync(['show-ref', '--verify', '--quiet', `refs/heads/crtr/${nodeId}`], repoDir).status, 1, 'the conflicting spawn must not leave a registered crtr/<id> branch');
-    assert.ok(!gitSync(['worktree', 'list', '--porcelain'], repoDir).stdout.includes(managedWorktreePath(nodeId)), 'git must not register the conflicting worktree at all');
-    // The pre-existing node is untouched.
-    assert.equal(getNode(nodeId).kind, 'general');
-    assert.equal(getNode(nodeId).managed_worktree, undefined);
-});
-test('spawnNode({ nodeId }): a hyphen-less opaque id spawns at the exact given id', async () => {
-    // Regression for the reviewed opaque-id-contract violation: the old validator
-    // required >=2 hyphen segments and rejected a hyphen-less id outright,
-    // contradicting the design's "opaque, never parsed for structure" ID scheme
-    // that remote and cloud spawns depend on.
-    const meta = await spawnNode({ kind: 'general', cwd: '/tmp/work', nodeId: 'remote42' });
-    assert.equal(meta.node_id, 'remote42');
-    assert.notEqual(getNode('remote42'), null);
-});

package/dist/core/__tests__/stdin-body-no-discard.test.d.ts

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

package/dist/core/__tests__/stdin-body-no-discard.test.js

@@ -1,33 +0,0 @@
-// stdin-body-no-discard.test.ts — regression for issue #514's flawed fix: a
-// bounded first-byte read (`readStdinBody`, since deleted) silently discarded
-// a delayed pipe's content instead of draining it. The stdin BODY contract is
-// standard Unix drain-to-EOF: `readStdinRaw()` (`io.ts`) must preserve content
-// that arrives after a delay, not just content that's immediately readable.
-//
-// Run with: node --import tsx/esm --test src/core/__tests__/stdin-body-no-discard.test.ts
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { PassThrough } from 'node:stream';
-import { readStdinRaw } from '../io.js';
-/** Swap process.stdin for a fake stream for the duration of `fn`, restoring
- *  the real one afterward even on throw. */
-async function withFakeStdin(fake, fn) {
-    const real = process.stdin;
-    fake.isTTY = false;
-    Object.defineProperty(process, 'stdin', { value: fake, configurable: true });
-    try {
-        return await fn();
-    }
-    finally {
-        Object.defineProperty(process, 'stdin', { value: real, configurable: true });
-    }
-}
-test('readStdinRaw drains full content from a producer whose first byte arrives after a delay', async () => {
-    const delayed = new PassThrough();
-    setTimeout(() => {
-        delayed.write('delayed-body');
-        delayed.end();
-    }, 300);
-    const result = await withFakeStdin(delayed, () => readStdinRaw());
-    assert.equal(result, 'delayed-body');
-});

package/dist/core/__tests__/stdout-errors.test.d.ts

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