@north-light/crouter 0.3.318 → 0.3.320

package/dist/core/keybindings/__tests__/resolve.test.js

@@ -1,171 +0,0 @@
-import { after, before, beforeEach, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { KeybindingConcurrentEditError, KeybindingValidationError, canonicalTerminalStroke, matchesTerminalInput, normalizeSparseOverrides, persistUserKeybindings, resolveKeybindings, resolveUserKeybindings, } from '../index.js';
-import { ensureScopeInitialized, readConfig, readRawScopeConfig, updateRawConfigAtomically, writeRawConfig } from '../../config.js';
-import { closeScopedStores } from '../../scoped-state/db.js';
-import { resetScopeCache } from '../../scope.js';
-const typeCheckedBindingId = 'crtr.graph.down';
-// @ts-expect-error The catalog type rejects IDs that are not built in.
-const rejectedBindingId = 'crtr.graph.not-real';
-// @ts-expect-error The Attach submenu opener has no tmux-global pair.
-const rejectedAttachGlobalId = 'crtr.tmux.menu-global.attach';
-void typeCheckedBindingId;
-void rejectedBindingId;
-void rejectedAttachGlobalId;
-let home;
-let realHome;
-let realCwd;
-before(() => {
-    realHome = process.env['HOME'];
-    realCwd = process.cwd();
-});
-beforeEach(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-keybindings-'));
-    process.env['HOME'] = home;
-    process.chdir(realCwd);
-    resetScopeCache();
-    ensureScopeInitialized('user', join(home, '.crouter'));
-});
-after(() => {
-    closeScopedStores();
-    process.chdir(realCwd);
-    if (realHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = realHome;
-});
-test.afterEach(() => {
-    closeScopedStores();
-    rmSync(home, { recursive: true, force: true });
-});
-test('terminal literal space matches named space bindings', () => {
-    const raw = { input: ' ' };
-    assert.equal(canonicalTerminalStroke(raw), 'space');
-    assert.equal(matchesTerminalInput(resolveKeybindings(), 'crtr.browse.toggle-fold', raw), true);
-});
-test('invalid values and unknown IDs diagnose precisely while valid overrides still apply', () => {
-    const resolved = resolveKeybindings({
-        'crtr.unknown': ['x'],
-        'crtr.graph.down': 'down',
-        'crtr.attach.graph.toggle': ['alt+x'],
-    });
-    assert.equal(resolved.gestures('crtr.graph.down')[0], 'j');
-    assert.deepEqual(resolved.gestures('crtr.attach.graph.toggle'), ['alt+x']);
-    assert.deepEqual(new Set(resolved.diagnostics.map((item) => item.code)), new Set(['unknown-binding', 'invalid-override']));
-});
-test('colliding overrides fall back without affecting unrelated contexts', () => {
-    const resolved = resolveKeybindings({
-        'crtr.graph.down': ['k'],
-        'crtr.inspector.quit': ['z'],
-        'crtr.attach.graph.toggle': ['alt+c'],
-        'crtr.attach.detach': ['j'],
-        'crtr.setup.list-down': ['space'],
-    });
-    assert.equal(resolved.gestures('crtr.graph.down')[0], 'j');
-    assert.deepEqual(resolved.gestures('crtr.inspector.quit'), ['z']);
-    assert.deepEqual(resolved.gestures('crtr.attach.graph.toggle'), ['alt+g']);
-    assert.deepEqual(resolved.gestures('crtr.attach.detach'), ['ctrl+d']);
-    assert.deepEqual(resolved.gestures('crtr.setup.list-down'), ['j', 'down']);
-    assert.equal(resolved.diagnostics.filter((item) => item.code === 'collision').length, 4);
-});
-test('tmux menu selectors collide only inside their own menu', () => {
-    // The tmux.root opener may take a menu selector's key (detach = shift+d) — a
-    // globally-active root binding never collides with a menu-scoped selector.
-    const opener = resolveKeybindings({ 'crtr.tmux.menu.open': ['shift+d'] });
-    assert.deepEqual(opener.gestures('crtr.tmux.menu.open'), ['shift+d']);
-    assert.deepEqual(opener.diagnostics, []);
-    // Symmetrically, a menu selector may reuse an in-pane key (promote onto the
-    // browse-down `j`) — selectors are checked only within their own tmux.menu, so
-    // they never collide with in-pane terminal bindings (e.g. browse's own `o`).
-    const selector = resolveKeybindings({ 'crtr.tmux.menu.promote': ['j'] });
-    assert.deepEqual(selector.gestures('crtr.tmux.menu.promote'), ['j']);
-    assert.deepEqual(selector.diagnostics, []);
-    const attachSelector = resolveKeybindings({ 'crtr.tmux.menu.attach.detach': ['o'] });
-    assert.deepEqual(attachSelector.gestures('crtr.tmux.menu.attach.detach'), ['o']);
-    assert.deepEqual(attachSelector.diagnostics, [], 'attach submenu selectors may reuse top-level menu selectors');
-    const attachCollision = resolveKeybindings({ 'crtr.tmux.menu.attach.detach': ['c'] });
-    assert.deepEqual(attachCollision.gestures('crtr.tmux.menu.attach.detach'), ['d']);
-    assert.ok(attachCollision.diagnostics.some((item) => item.code === 'collision'), 'selectors in the same attach submenu must remain unique');
-});
-test('reachability rejects deliberate unbinding that would trap a context', () => {
-    const graph = resolveKeybindings({
-        'crtr.graph.dismiss': [],
-        'crtr.graph.down': ['escape'],
-    });
-    assert.deepEqual(graph.gestures('crtr.graph.dismiss'), ['escape']);
-    assert.deepEqual(graph.gestures('crtr.graph.down'), ['j']);
-    assert.ok(graph.diagnostics.some((item) => item.code === 'unreachable'));
-    assert.ok(graph.diagnostics.some((item) => item.code === 'collision'));
-    const setup = resolveKeybindings({
-        'crtr.setup.keybindings.discard': [],
-        'crtr.setup.keybindings.save': [],
-    });
-    assert.equal(setup.diagnostics.filter((item) => item.code === 'unreachable').length, 1);
-});
-test('sparsification omits defaults, preserves explicit unbinds, and reset removes the override', () => {
-    assert.deepEqual(normalizeSparseOverrides({ 'crtr.attach.graph.toggle': ['alt+g'] }), {});
-    assert.deepEqual(normalizeSparseOverrides({ 'crtr.graph.close-subtree': [] }), {
-        'crtr.graph.close-subtree': [],
-    });
-    assert.deepEqual(normalizeSparseOverrides({}), {});
-    assert.throws(() => normalizeSparseOverrides({ 'crtr.graph.down': ['k'] }), KeybindingValidationError);
-});
-test('user resolution ignores project keybindings', () => {
-    writeRawConfig('user', { keybindings: { 'crtr.graph.down': ['down'] } });
-    const project = mkdtempSync(join(tmpdir(), 'crtr-keybindings-project-'));
-    mkdirSync(join(project, '.crouter'), { recursive: true });
-    writeFileSync(join(project, '.crouter', 'config.json'), JSON.stringify({ keybindings: { 'crtr.graph.down': ['up'] } }));
-    try {
-        process.chdir(project);
-        assert.deepEqual(resolveUserKeybindings().gestures('crtr.graph.down'), ['down']);
-    }
-    finally {
-        process.chdir(realCwd);
-        rmSync(project, { recursive: true, force: true });
-    }
-});
-test('config hard cut exposes only sparse keybindings and ignores unsupported raw fields', () => {
-    updateRawConfigAtomically('user', () => ({
-        canvasNav: { prefixKey: 'alt+x' },
-        keybindings: { 'crtr.graph.down': ['down'], bad: 3 },
-    }));
-    const config = readConfig('user');
-    assert.deepEqual(config.keybindings, { 'crtr.graph.down': ['down'] });
-    assert.equal(Object.hasOwn(config, 'canvasNav'), false);
-});
-test('atomic persistence preserves latest unrelated fields and writes only sparse normalized overrides', () => {
-    updateRawConfigAtomically('user', () => ({
-        customFutureField: { retained: true },
-        max_panes_per_window: 4,
-        canvasNav: { prefixKey: 'alt+z' },
-    }));
-    persistUserKeybindings({
-        'crtr.attach.graph.toggle': ['M-X'],
-        'crtr.graph.close-subtree': [],
-        'crtr.graph.down': ['j'],
-    });
-    const raw = readRawScopeConfig('user');
-    assert.deepEqual(raw.customFutureField, { retained: true });
-    assert.equal(raw.max_panes_per_window, 4);
-    assert.deepEqual(raw.keybindings, {
-        'crtr.attach.graph.toggle': ['alt+shift+x'],
-        'crtr.graph.close-subtree': [],
-    });
-    assert.equal(raw.canvasNav, undefined);
-});
-test('reset-all removes the top-level member and concurrent keybinding edits are refused', () => {
-    const original = { 'crtr.graph.down': ['down'] };
-    updateRawConfigAtomically('user', () => ({ keybindings: original, retained: 1 }));
-    persistUserKeybindings({}, { expectedKeybindings: original });
-    let raw = readRawScopeConfig('user');
-    assert.equal(raw.keybindings, undefined);
-    assert.equal(raw.retained, 1);
-    updateRawConfigAtomically('user', () => ({ keybindings: { 'crtr.graph.up': ['up'] }, retained: 2 }));
-    assert.throws(() => persistUserKeybindings({}, { expectedKeybindings: original }), KeybindingConcurrentEditError);
-    raw = readRawScopeConfig('user');
-    assert.deepEqual(raw.keybindings, { 'crtr.graph.up': ['up'] });
-    assert.equal(raw.retained, 2);
-});

package/dist/core/profiles/__tests__/env-store.test.d.ts

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

package/dist/core/profiles/__tests__/env-store.test.js

@@ -1,99 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/profiles/__tests__/env-store.test.ts
-//
-// Regression lock for the independent review of commit b6c7008e (`crtr profile
-// env`): reserved crtr identity/routing names and NUL-containing values must
-// never be stored or injected, and a prototype-shaped name (`__proto__`) must
-// round-trip like any other name instead of silently vanishing.
-import { test, before, after, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createProfile } from '../manifest.js';
-import { initializeFreshScopedStore } from '../../scoped-state/migrate.js';
-import { resetScopeCache } from '../../scope.js';
-import { isReservedEnvName, listProfileEnvNames, readProfileEnvVars, removeProfileEnvVar, setProfileEnvVar, } from '../env-store.js';
-import { envBranch } from '../../../commands/profile/env.js';
-function setLeaf() {
-    const leaf = envBranch.children.find((child) => child.name === 'set');
-    assert.ok(leaf?.kind === 'leaf', 'profile env set is registered as a leaf');
-    return leaf;
-}
-function removeLeaf() {
-    const leaf = envBranch.children.find((child) => child.name === 'remove');
-    assert.ok(leaf?.kind === 'leaf', 'profile env remove is registered as a leaf');
-    return leaf;
-}
-let home;
-let previousHome;
-before(() => {
-    previousHome = process.env.HOME;
-});
-beforeEach(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-env-store-home-'));
-    process.env.HOME = home;
-    resetScopeCache();
-    initializeFreshScopedStore({ kind: 'user', root: join(home, '.crouter') });
-});
-afterEach(() => {
-    rmSync(home, { recursive: true, force: true });
-    resetScopeCache();
-});
-after(() => {
-    if (previousHome === undefined)
-        delete process.env.HOME;
-    else
-        process.env.HOME = previousHome;
-    resetScopeCache();
-});
-test('setProfileEnvVar rejects a crtr identity/routing name and never persists it', () => {
-    const { profileId } = createProfile('reserved-name');
-    for (const bad of ['CRTR_HOME', 'CRTR_PIDFILE', 'CRTR_RUNTIME_HOME', 'CRTR_SUBTREE', 'HOME']) {
-        assert.equal(isReservedEnvName(bad), true);
-        assert.throws(() => setProfileEnvVar(profileId, bad, '/tmp/wrong-canvas'), /reserved/);
-    }
-    assert.deepEqual(listProfileEnvNames(profileId), []);
-    assert.deepEqual(readProfileEnvVars(profileId), {});
-});
-test('setProfileEnvVar rejects a NUL-containing value without disclosing it', () => {
-    const { profileId } = createProfile('nul-value');
-    const secret = 'prefix\0SUPERSECRET_NUL';
-    try {
-        setProfileEnvVar(profileId, 'SOME_TOKEN', secret);
-        assert.fail('expected setProfileEnvVar to throw');
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        assert.ok(!message.includes('SUPERSECRET_NUL'), `error message disclosed the value: ${message}`);
-    }
-    assert.deepEqual(listProfileEnvNames(profileId), []);
-});
-test('__proto__ round-trips as an ordinary own-property name', () => {
-    const { profileId } = createProfile('proto-name');
-    const created = setProfileEnvVar(profileId, '__proto__', 'not-a-prototype');
-    assert.equal(created, true);
-    assert.deepEqual(listProfileEnvNames(profileId), ['__proto__']);
-    assert.equal(readProfileEnvVars(profileId)['__proto__'], 'not-a-prototype');
-    const removed = removeProfileEnvVar(profileId, '__proto__');
-    assert.equal(removed, true);
-    assert.deepEqual(listProfileEnvNames(profileId), []);
-});
-test('set preserves input exactly except one trailing line ending', async () => {
-    const { profileId } = createProfile('exact-bytes');
-    await setLeaf().run({ profile: profileId, name: 'EDGE_VALUE', value: '  edge value  \n' });
-    assert.equal(readProfileEnvVars(profileId)['EDGE_VALUE'], '  edge value  ');
-});
-test('remove enforces the same name validation as set', async () => {
-    const { profileId } = createProfile('remove-bad-name');
-    await assert.rejects(() => removeLeaf().run({ profile: profileId, name: 'bad-name' }), /invalid --name/);
-});
-test('readProfileEnvVars sanitizes a reserved name or NUL value written some other way', () => {
-    const { profileId } = createProfile('hand-edited');
-    // Establish the profile's env.json, then hand-write a store shape a
-    // pre-reservation version (or manual edit) could have produced.
-    setProfileEnvVar(profileId, 'GOOD_TOKEN', 'fine');
-    const envJsonPath = join(home, '.crouter', 'profiles', profileId, 'env.json');
-    writeFileSync(envJsonPath, JSON.stringify({ vars: { GOOD_TOKEN: 'fine', CRTR_HOME: '/tmp/evil', BAD_VALUE: 'x\0y' } }, null, 2) + '\n');
-    const injected = readProfileEnvVars(profileId);
-    assert.deepEqual(injected, { GOOD_TOKEN: 'fine' });
-});

package/dist/core/profiles/__tests__/fuzzy-match.test.d.ts

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

package/dist/core/profiles/__tests__/fuzzy-match.test.js

@@ -1,51 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { fuzzyMatchProfile } from '../fuzzy-match.js';
-const PROFILES = [
-    { profileId: 'crouter-1a2b3c4d', name: 'crouter' },
-    { profileId: 'northlight-5e6f7a8b', name: 'Northlight' },
-    { profileId: 'personal-ops-9c0d1e2f', name: 'personal ops' },
-];
-function idOf(operand) {
-    return fuzzyMatchProfile(operand, PROFILES).match?.profileId ?? null;
-}
-test('a truncated name resolves to the profile it prefixes', () => {
-    assert.equal(idOf('crout'), 'crouter-1a2b3c4d');
-    assert.equal(idOf('north'), 'northlight-5e6f7a8b');
-});
-test('case and separators are irrelevant', () => {
-    assert.equal(idOf('CROUTER'), 'crouter-1a2b3c4d');
-    assert.equal(idOf('personal-ops'), 'personal-ops-9c0d1e2f');
-    assert.equal(idOf('PersonalOps'), 'personal-ops-9c0d1e2f');
-});
-test('a transposition or a dropped character still resolves', () => {
-    assert.equal(idOf('cruoter'), 'crouter-1a2b3c4d');
-    assert.equal(idOf('crouterr'), 'crouter-1a2b3c4d');
-    assert.equal(idOf('northlite'), 'northlight-5e6f7a8b');
-});
-test('the id slug matches without its generated hex suffix', () => {
-    assert.equal(idOf('personal-ops-9c0d1e2f'), 'personal-ops-9c0d1e2f');
-    assert.equal(idOf('personalops'), 'personal-ops-9c0d1e2f');
-});
-test('a genuinely unrelated operand matches nothing', () => {
-    assert.equal(idOf('zzzzzzzzzz'), null);
-    assert.equal(idOf(''), null);
-});
-test('equally close candidates are reported as a tie, never guessed', () => {
-    const twins = [
-        { profileId: 'alpha-00000001', name: 'alpha' },
-        { profileId: 'alpha-00000002', name: 'alpho' },
-    ];
-    const result = fuzzyMatchProfile('alphx', twins);
-    assert.equal(result.match, null);
-    assert.deepEqual(result.tied.map((c) => c.profileId), ['alpha-00000001', 'alpha-00000002']);
-});
-test('a stronger tier wins over a closer edit distance in a weaker tier', () => {
-    // "nort" is a prefix of northlight and one edit from "note" — the prefix
-    // must win, because a user who stopped typing meant the thing they started.
-    const candidates = [
-        { profileId: 'northlight-5e6f7a8b', name: 'northlight' },
-        { profileId: 'note-11111111', name: 'note' },
-    ];
-    assert.equal(fuzzyMatchProfile('nort', candidates).match?.profileId, 'northlight-5e6f7a8b');
-});

package/dist/core/profiles/__tests__/root-profile.test.d.ts

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

package/dist/core/profiles/__tests__/root-profile.test.js

@@ -1,59 +0,0 @@
-import { test, before, after, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { loadProfileManifest, profileRoot, ROOT_PROFILE_ID } from '../manifest.js';
-import { selectProfileForCwd } from '../select.js';
-import { resetScopeCache } from '../../scope.js';
-let home;
-let cwd;
-let previousHome;
-let previousCwd;
-function forceNonInteractive() {
-    Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true, writable: true });
-    Object.defineProperty(process.stdout, 'isTTY', { value: false, configurable: true, writable: true });
-}
-function restoreInteractiveFlags() {
-    Reflect.deleteProperty(process.stdin, 'isTTY');
-    Reflect.deleteProperty(process.stdout, 'isTTY');
-}
-before(() => {
-    previousHome = process.env.HOME;
-    previousCwd = process.cwd();
-});
-beforeEach(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-root-profile-home-'));
-    cwd = mkdtempSync(join(tmpdir(), 'crtr-root-profile-cwd-'));
-    process.env.HOME = home;
-    process.chdir(cwd);
-    forceNonInteractive();
-    resetScopeCache();
-});
-afterEach(() => {
-    restoreInteractiveFlags();
-    process.chdir(previousCwd);
-    rmSync(home, { recursive: true, force: true });
-    rmSync(cwd, { recursive: true, force: true });
-    resetScopeCache();
-});
-after(() => {
-    process.chdir(previousCwd);
-    if (previousHome === undefined)
-        delete process.env.HOME;
-    else
-        process.env.HOME = previousHome;
-    resetScopeCache();
-});
-// A headless node spawn in an uncovered cwd must never prompt: `isTTY` is
-// forced false above, so a regression that reached for the interactive picker
-// would hang this test the same way it would hang the spawn.
-test('selectProfileForCwd falls back to the stable root profile when nothing covers cwd', async () => {
-    const profileId = await selectProfileForCwd(cwd);
-    assert.equal(profileId, ROOT_PROFILE_ID);
-    const entry = loadProfileManifest(ROOT_PROFILE_ID);
-    assert.equal(entry.profileId, ROOT_PROFILE_ID);
-    assert.equal(entry.manifest.name, 'root');
-    assert.equal(entry.manifest.last_used_at !== null, true);
-    assert.equal(existsSync(profileRoot(ROOT_PROFILE_ID)), true);
-});

package/dist/core/review/__tests__/capture-origin.test.d.ts

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

package/dist/core/review/__tests__/capture-origin.test.js

@@ -1,150 +0,0 @@
-import assert from 'node:assert/strict';
-import { existsSync, mkdtempSync, readdirSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, test } from 'node:test';
-import { createNode } from '../../canvas/canvas.js';
-import { closeDb, migrate, openDb } from '../../canvas/db.js';
-import { resetSession } from '../../canvas/sessions.js';
-import { resetScopeCache } from '../../scope.js';
-import { closeScopedStores } from '../../scoped-state/db.js';
-import { initializeFreshScopedStore } from '../../scoped-state/migrate.js';
-import { SessionManager } from '../../runtime/broker-sdk.js';
-import { captureOrigin } from '../companion.js';
-import { stageReview } from '../stage.js';
-import { getReviewByIdempotencyKey } from '../store.js';
-import { ReviewOperationError } from '../types.js';
-const registry = (models = [{ provider: 'p', id: 'm' }, { provider: 'q', id: 'n' }]) => ({
-    find: (provider, id) => models.find((model) => model.provider === provider && model.id === id),
-    getAll: () => models,
-    hasConfiguredAuth: () => true,
-});
-const homes = [];
-const previousHome = process.env['HOME'];
-const previousCrtrHome = process.env['CRTR_HOME'];
-afterEach(() => {
-    closeDb();
-    closeScopedStores();
-    for (const home of homes.splice(0))
-        rmSync(home, { recursive: true, force: true });
-    if (previousHome === undefined)
-        delete process.env['HOME'];
-    else
-        process.env['HOME'] = previousHome;
-    if (previousCrtrHome === undefined)
-        delete process.env['CRTR_HOME'];
-    else
-        process.env['CRTR_HOME'] = previousCrtrHome;
-    resetScopeCache();
-});
-function home() {
-    const value = mkdtempSync(join(tmpdir(), 'crtr-review-capture-'));
-    homes.push(value);
-    process.env['HOME'] = value;
-    process.env['CRTR_HOME'] = join(value, 'canvas');
-    resetScopeCache();
-    initializeFreshScopedStore({ kind: 'user', root: join(value, '.crouter') });
-    initializeFreshScopedStore({ kind: 'provider', root: join(value, '.pi', 'agent') });
-    migrate(openDb());
-    return value;
-}
-function node(id, cwd, sourceFile, launchModel) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd,
-        kind: 'developer',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'idle',
-        pi_session_file: sourceFile,
-        launch: { extensions: [], env: {}, ...(launchModel === undefined ? {} : { model: launchModel }) },
-    };
-}
-function seededOrigin(options = {}) {
-    const cwd = home();
-    const session = SessionManager.create(join(cwd, 'sessions'));
-    if (options.sessionModel !== undefined)
-        session.appendModelChange(options.sessionModel.provider, options.sessionModel.id);
-    session.appendThinkingLevelChange(options.thinking ?? 'low');
-    session.appendMessage({
-        role: 'assistant',
-        content: [{ type: 'text', text: 'persisted' }],
-        api: 'openai-completions',
-        provider: options.sessionModel?.provider ?? 'p',
-        model: options.sessionModel?.id ?? 'm',
-        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(),
-    });
-    const sourceFile = options.sourceFile ?? session.getSessionFile();
-    createNode(node('origin', cwd, sourceFile, options.launchModel));
-    resetSession('origin', { sessionId: session.getSessionId(), transcriptPath: sourceFile });
-    return { cwd, session, sourceFile };
-}
-async function capture(options) {
-    return captureOrigin('origin', { registry: registry() });
-}
-async function expectOriginError(action, reason) {
-    let caught;
-    try {
-        await action();
-    }
-    catch (error) {
-        caught = error;
-    }
-    assert.ok(caught instanceof ReviewOperationError);
-    assert.equal(caught.code, 'review_origin_unforkable');
-    assert.equal(caught.detail.reason, reason);
-    return caught;
-}
-test('detached capture takes provider/id and explicit thinking from the launch recipe', async () => {
-    const { session, sourceFile } = seededOrigin({ launchModel: 'p/m:high', thinking: 'low' });
-    const captured = await capture({ launchModel: 'p/m:high', thinking: 'low' });
-    assert.deepEqual(captured, {
-        sourceFile: realpathSync(sourceFile),
-        sourceSessionId: session.getSessionId(),
-        leafId: session.getLeafId(),
-        modelSpec: 'p/m:high',
-    });
-});
-test('detached capture takes an absent thinking suffix from the persisted branch', async () => {
-    seededOrigin({ launchModel: 'p/m', thinking: 'low' });
-    assert.equal((await capture({ launchModel: 'p/m', thinking: 'low' })).modelSpec, 'p/m:low');
-});
-test('detached capture records off explicitly and does not let :off override the session', async () => {
-    seededOrigin({ launchModel: 'p/m', thinking: 'off' });
-    assert.equal((await capture({ launchModel: 'p/m', thinking: 'off' })).modelSpec, 'p/m:off');
-    closeDb();
-    for (const value of homes.splice(0))
-        rmSync(value, { recursive: true, force: true });
-    seededOrigin({ launchModel: 'p/m:off', thinking: 'high' });
-    assert.equal((await capture({ launchModel: 'p/m:off', thinking: 'high' })).modelSpec, 'p/m:high');
-});
-test('detached capture honors a dormant launch-model swap over the session model', async () => {
-    seededOrigin({ launchModel: 'q/n:high', thinking: 'low', sessionModel: { provider: 'p', id: 'm' } });
-    assert.equal((await capture({ launchModel: 'q/n:high', thinking: 'low' })).modelSpec, 'q/n:high');
-});
-test('detached capture refuses no recorded model and an unregistered launch model', async () => {
-    seededOrigin({ thinking: 'low' });
-    await expectOriginError(() => capture({ thinking: 'low' }), 'model_unresolvable');
-    closeDb();
-    for (const value of homes.splice(0))
-        rmSync(value, { recursive: true, force: true });
-    seededOrigin({ launchModel: 'p/definitely-not-a-model:high', thinking: 'low' });
-    const error = await expectOriginError(() => captureOrigin('origin', { registry: registry() }), 'model_unresolvable');
-    assert.equal(error.detail.model_reason, 'unregistered');
-});
-test('missing source sessions refuse capture and discard review staging', async () => {
-    const cwd = home();
-    const missing = join(cwd, 'sessions', 'missing.jsonl');
-    createNode(node('origin', cwd, missing, 'p/m:high'));
-    await expectOriginError(() => captureOrigin('origin', { registry: registry() }), 'no_forkable_session');
-    const target = join(cwd, 'target.md');
-    writeFileSync(target, '# target\n');
-    await expectOriginError(() => stageReview({ origin_kind: 'inline', origin_node_id: 'origin', file: target, idempotency_key: 'missing-source' }), 'no_forkable_session');
-    const reviews = join(cwd, 'reviews');
-    assert.equal(existsSync(reviews) ? readdirSync(reviews).length : 0, 0);
-    assert.equal(getReviewByIdempotencyKey('missing-source'), null);
-});

package/dist/core/review/__tests__/comments.test.d.ts

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

package/dist/core/review/__tests__/comments.test.js

@@ -1,116 +0,0 @@
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { test } from 'node:test';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { closeDb, migrate, openDb } from '../../canvas/db.js';
-import { commitBindingRequest, openRequest } from '../../human/requests.js';
-import { createComment, deleteComment, editComment, getComment, listCommentEvents, listComments, listReviewEvents, reopenComment, resolveComment, } from '../comments.js';
-function seedReview(reviewId) {
-    const created = '2026-01-01T00:00:00.000Z';
-    commitBindingRequest({
-        request_id: reviewId,
-        idempotency_key: `idempotency-${reviewId}`,
-        requester_node_id: 'origin',
-        companion_node_id: 'companion',
-        request_dir: '/tmp/review',
-        file: '/tmp/source.md',
-        specification: {
-            origin_kind: 'inline',
-            origin_session_file: '/tmp/session.jsonl',
-            origin_session_id: 'session',
-            origin_leaf_id: 'leaf',
-            model_spec: 'anthropic/claude',
-            branch_file: '/tmp/branch.jsonl',
-            baseline_sha256: 'baseline',
-            baseline_bytes: 4,
-            captured_at: created,
-        },
-        anchor_base_sha256: 'baseline',
-        anchor_base_bytes: Buffer.from('base'),
-        created_at: created,
-        inbox_listed: false,
-    });
-    assert.equal(openRequest(reviewId, created), true);
-}
-test('comment projection and audit are durable, idempotent, and terminally tombstoned', () => {
-    const home = mkdtempSync(join(tmpdir(), 'crtr-comments-store-'));
-    const previousHome = process.env['CRTR_HOME'];
-    process.env['CRTR_HOME'] = home;
-    migrate(openDb());
-    try {
-        const reviewId = 'review-comments-test';
-        seedReview(reviewId);
-        const created = createComment({
-            review_id: reviewId,
-            text: 'first finding',
-            anchor: { line: 2, end_line: 2, quote: 'source' },
-            line_text: 'the source line',
-            doc_hash: 'document-a',
-            actor: { kind: 'human', node_id: null },
-            operation_id: 'create',
-        });
-        assert.equal(created.changed, true);
-        assert.equal(created.comment.revision, 1);
-        assert.equal(created.comment.created_seq, 1);
-        assert.equal(created.comment.anchor_state, 'live');
-        openDb().prepare("UPDATE review_comments SET anchor_state = 'detached' WHERE comment_id = ?").run(created.comment.comment_id);
-        assert.equal(getComment(created.comment.comment_id)?.anchor_state, 'detached');
-        assert.equal(listComments(reviewId)[0]?.anchor_state, 'detached');
-        const edited = editComment(created.comment.comment_id, {
-            text: 'edited finding',
-            actor: { kind: 'node', node_id: 'companion' },
-            operation_id: 'edit',
-        });
-        assert.equal(edited.changed, true);
-        assert.equal(edited.comment.revision, 2);
-        assert.throws(() => editComment(created.comment.comment_id, {
-            text: 'stale edit',
-            if_revision: 1,
-            actor: { kind: 'human', node_id: null },
-            operation_id: 'stale',
-        }), (error) => error instanceof Error && error.message === 'comment revision is stale');
-        assert.equal(resolveComment(created.comment.comment_id, {
-            actor: { kind: 'node', node_id: 'companion' }, operation_id: 'resolve',
-        }).comment.revision, 3);
-        assert.equal(resolveComment(created.comment.comment_id, {
-            actor: { kind: 'node', node_id: 'companion' }, operation_id: 'resolve-repeat',
-        }).changed, false);
-        assert.equal(reopenComment(created.comment.comment_id, {
-            actor: { kind: 'node', node_id: 'companion' }, operation_id: 'reopen',
-        }).comment.revision, 4);
-        assert.equal(deleteComment(created.comment.comment_id, {
-            actor: { kind: 'human', node_id: null }, operation_id: 'delete',
-        }).comment.revision, 5);
-        assert.equal(deleteComment(created.comment.comment_id, {
-            actor: { kind: 'human', node_id: null }, operation_id: 'delete-repeat',
-        }).changed, false);
-        assert.throws(() => editComment(created.comment.comment_id, {
-            text: 'resurrection', actor: { kind: 'human', node_id: null }, operation_id: 'resurrect',
-        }), (error) => error instanceof Error && error.message === 'comment is a deleted tombstone');
-        assert.deepEqual(listComments(reviewId), []);
-        assert.equal(listComments(reviewId, { status: 'all' }).length, 1);
-        assert.equal(getComment(created.comment.comment_id)?.status, 'deleted');
-        const events = listCommentEvents(created.comment.comment_id);
-        assert.deepEqual(events.map((event) => event.kind), [
-            'created', 'edited', 'resolved', 'reopened', 'deleted',
-        ]);
-        assert.deepEqual(events[1].payload.previous_anchor, {
-            line: 2, end_line: 2, quote: 'source',
-        });
-        assert.equal(events[4].payload.previous_text, 'edited finding');
-        assert.equal(events.every((event) => event.state_change === 1), true);
-        const firstPage = listReviewEvents(reviewId, { limit: 2 });
-        assert.equal(firstPage.events.length, 2);
-        const secondPage = listReviewEvents(reviewId, { since_seq: firstPage.next_since_seq });
-        assert.deepEqual(secondPage.events.map((event) => event.kind), ['resolved', 'reopened', 'deleted']);
-    }
-    finally {
-        closeDb();
-        rmSync(home, { recursive: true, force: true });
-        if (previousHome === undefined)
-            delete process.env['CRTR_HOME'];
-        else
-            process.env['CRTR_HOME'] = previousHome;
-    }
-});