@crouton-kit/crouter 0.3.33 → 0.3.34

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

@@ -1,185 +0,0 @@
-// Phase 2 keystone — runtime authority moved into the WAL'd row.
-//
-// These four guard the load-bearing invariants of the split:
-//   1. concurrency  — two writers of DIFFERENT runtime fields both land (the old
-//                     whole-meta read-modify-write dropped one).
-//   2. isolation    — a single-column setter never disturbs the other runtime
-//                     fields (single-statement atomicity).
-//   3. persistence  — meta.json on disk holds NO runtime fields, yet getNode
-//                     still returns them (hydrated from the row).
-//   4. backfill     — a v2-shaped db with runtime still in meta migrates (v3) so
-//                     runtime lands in the authoritative row.
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, readFileSync, writeFileSync, } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { DatabaseSync } from 'node:sqlite';
-import { createNode, getNode, setStatus, setIntent, setPresence, recordPid, clearPid, } from '../canvas/canvas.js';
-import { openDb, closeDb, MIGRATIONS } from '../canvas/db.js';
-import { nodeDir, nodeMetaPath, canvasDbPath, ensureHome, } from '../canvas/paths.js';
-let home;
-function node(id, over = {}) {
-    return {
-        node_id: id,
-        name: id,
-        created: new Date().toISOString(),
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-keystone-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-// 1. concurrency — both interleaved writers survive.
-test('concurrency: an interleaved setStatus and recordPid both land', () => {
-    createNode(node('a', { status: 'active', pi_pid: null }));
-    // Two writers each take a STALE snapshot, exactly as the old cross-process
-    // race did (the daemon stamping pi_pid while the node flips status).
-    const snapDaemon = getNode('a');
-    const snapNode = getNode('a');
-    assert.equal(snapDaemon?.pi_pid ?? null, null);
-    assert.equal(snapNode?.status, 'active');
-    // Interleave their writes through the atomic per-column setters.
-    recordPid('a', 4321); // writer 1 (daemon)
-    setStatus('a', 'idle'); // writer 2 (node)
-    // Under the OLD whole-meta read-modify-write, writer 2 writing back its stale
-    // snapshot (pi_pid still null) would have CLOBBERED writer 1's pid. Atomic
-    // single-column UPDATEs serialized by WAL keep BOTH.
-    const m = getNode('a');
-    assert.equal(m?.pi_pid, 4321, 'the pid write survived');
-    assert.equal(m?.status, 'idle', 'the status write survived');
-});
-// 2. isolation — single-column atomicity in both directions.
-test('isolation: setPresence and setStatus/setIntent never disturb each other', () => {
-    createNode(node('a', { status: 'active', intent: 'refresh', pi_pid: 99 }));
-    setPresence('a', { tmux_session: 's', window: '@1' });
-    let m = getNode('a');
-    assert.equal(m?.status, 'active', 'status undisturbed by setPresence');
-    assert.equal(m?.intent, 'refresh', 'intent undisturbed by setPresence');
-    assert.equal(m?.pi_pid, 99, 'pi_pid undisturbed by setPresence');
-    assert.equal(m?.tmux_session, 's');
-    assert.equal(m?.window, '@1');
-    // The reverse: flipping status + intent leaves presence and pid intact.
-    setStatus('a', 'done');
-    setIntent('a', 'done');
-    m = getNode('a');
-    assert.equal(m?.status, 'done');
-    assert.equal(m?.intent, 'done');
-    assert.equal(m?.tmux_session, 's', 'tmux_session undisturbed by setStatus/setIntent');
-    assert.equal(m?.window, '@1', 'window undisturbed by setStatus/setIntent');
-    assert.equal(m?.pi_pid, 99, 'pi_pid undisturbed by setStatus/setIntent');
-    clearPid('a');
-    assert.equal(getNode('a')?.pi_pid, null, 'clearPid nulls only the pid');
-    assert.equal(getNode('a')?.tmux_session, 's', 'clearPid leaves presence intact');
-});
-// 3. persistence-split — meta.json has no runtime; getNode still hydrates it.
-test('persistence-split: meta.json holds no runtime fields, getNode hydrates them', () => {
-    createNode(node('a', {
-        status: 'active',
-        intent: 'refresh',
-        pi_pid: 7,
-        tmux_session: 's',
-        window: '@1',
-    }));
-    setStatus('a', 'done');
-    setPresence('a', { tmux_session: 's2', window: '@2' });
-    const raw = JSON.parse(readFileSync(nodeMetaPath('a'), 'utf8'));
-    for (const k of ['status', 'intent', 'pi_pid', 'window', 'tmux_session']) {
-        assert.ok(!(k in raw), `meta.json must NOT contain runtime field "${k}"`);
-    }
-    // identity is still on disk
-    assert.equal(raw['kind'], 'general');
-    assert.equal(raw['node_id'], 'a');
-    // ...while the hydrated view returns runtime from the authoritative row.
-    const m = getNode('a');
-    assert.equal(m?.status, 'done');
-    assert.equal(m?.tmux_session, 's2');
-    assert.equal(m?.window, '@2');
-    assert.equal(m?.intent, 'refresh');
-    assert.equal(m?.pi_pid, 7);
-});
-// 4. backfill — v2-shaped db with runtime in meta migrates so runtime lands in
-// the row.
-test('backfill (v3): runtime in legacy meta.json is copied into the row', () => {
-    ensureHome();
-    // A legacy meta with runtime STILL on disk (pre-keystone shape).
-    mkdirSync(nodeDir('n1'), { recursive: true });
-    writeFileSync(nodeMetaPath('n1'), JSON.stringify({
-        node_id: 'n1',
-        name: 'N1',
-        created: '2020-01-01T00:00:00Z',
-        cwd: '/tmp/work',
-        kind: 'general',
-        mode: 'base',
-        lifecycle: 'terminal',
-        // legacy runtime, still living in meta.json:
-        status: 'idle',
-        intent: 'refresh',
-        pi_pid: 555,
-        window: '@9',
-        tmux_session: 'sess',
-    }, null, 2));
-    // Hand-build a v2-shaped db: all columns present, runtime seeded NULL,
-    // user_version 2 (so the runner runs ONLY v3 = backfill).
-    const raw = new DatabaseSync(canvasDbPath());
-    raw.exec(`
-    CREATE TABLE nodes (
-      node_id    TEXT PRIMARY KEY,
-      name       TEXT NOT NULL,
-      kind       TEXT NOT NULL,
-      mode       TEXT NOT NULL DEFAULT 'base',
-      lifecycle  TEXT NOT NULL DEFAULT 'terminal',
-      status     TEXT NOT NULL DEFAULT 'active',
-      cwd        TEXT NOT NULL,
-      parent     TEXT,
-      created    TEXT NOT NULL,
-      intent       TEXT,
-      pi_pid       INTEGER,
-      "window"     TEXT,
-      tmux_session TEXT
-    );
-  `);
-    raw
-        .prepare('INSERT INTO nodes (node_id, name, kind, mode, lifecycle, status, cwd, parent, created) VALUES (?,?,?,?,?,?,?,?,?)')
-        .run('n1', 'N1', 'general', 'base', 'terminal', 'idle', '/tmp/work', null, '2020-01-01T00:00:00Z');
-    raw.exec('PRAGMA user_version = 2;');
-    // Precondition: runtime columns are NULL before the backfill.
-    const before = raw
-        .prepare('SELECT intent, pi_pid, "window", tmux_session FROM nodes WHERE node_id = ?')
-        .get('n1');
-    assert.equal(before['intent'], null);
-    assert.equal(before['pi_pid'], null);
-    raw.close();
-    // openDb() runs the migration runner forward → v3 backfill copies meta→row.
-    const db = openDb();
-    assert.equal(db.prepare('PRAGMA user_version').get().user_version, MIGRATIONS.length);
-    const r = db
-        .prepare('SELECT status, intent, pi_pid, "window", tmux_session FROM nodes WHERE node_id = ?')
-        .get('n1');
-    assert.equal(r['status'], 'idle', 'status already mirrored — untouched');
-    assert.equal(r['intent'], 'refresh', 'intent backfilled from meta');
-    assert.equal(r['pi_pid'], 555, 'pi_pid backfilled from meta');
-    assert.equal(r['window'], '@9', 'window backfilled from meta');
-    assert.equal(r['tmux_session'], 'sess', 'tmux_session backfilled from meta');
-    // And the hydrated view now reflects it.
-    const m = getNode('n1');
-    assert.equal(m?.intent, 'refresh');
-    assert.equal(m?.pi_pid, 555);
-    assert.equal(m?.window, '@9');
-    assert.equal(m?.tmux_session, 'sess');
-});

package/dist/core/__tests__/listing-completeness.test.d.ts

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

package/dist/core/__tests__/listing-completeness.test.js

@@ -1,31 +0,0 @@
-// Completeness guard for the assembled parent-level listings.
-// Run with: node --import tsx/esm --test src/core/__tests__/listing-completeness.test.ts
-//
-// Each non-hidden child surfaced in a branch's `help.listing` must carry a real
-// self-description: both `description` and `whenToUse` non-empty. The listing is
-// assembled by defineBranch from the child defs, so a blank attribute here means
-// a child def forgot to declare its description/whenToUse. Walks the whole live
-// command tree (buildRoot) so every shipped subtree is covered.
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { buildRoot } from '../../build-root.js';
-test('every non-hidden listing child declares description + whenToUse', async () => {
-    const root = await buildRoot();
-    const missing = [];
-    const walk = (branch, path) => {
-        for (const child of branch.help.listing ?? []) {
-            if (child.tier === 'hidden')
-                continue;
-            if (child.description.trim() === '' || child.whenToUse.trim() === '') {
-                missing.push(`${path} ${child.name}: empty description/whenToUse`);
-            }
-        }
-        for (const child of branch.children) {
-            if (child.kind === 'branch')
-                walk(child, `${path} ${child.name}`);
-        }
-    };
-    for (const subtree of root.subtrees)
-        walk(subtree, subtree.name);
-    assert.deepEqual(missing, [], `listing children missing self-description:\n${missing.join('\n')}`);
-});

package/dist/core/__tests__/memory-resolver.test.d.ts

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

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

@@ -1,119 +0,0 @@
-// Regression test for the namespaced plugin-doc READ path in resolveMemoryDoc.
-//
-// Bug (substrate-unification cut f1b071b, fixed by 945d121): plugin memory docs
-// mount at a virtual `<pluginName>/` namespace and ARE enumerated by
-// listAllMemoryDocs, so `crtr memory list` advertises canonical names like
-// `claude-capture/capture`. But findMemoryMatches (the direct-path lookup inside
-// resolveMemoryDoc) only searched the NATIVE scopeMemoryDir, never each plugin's
-// pluginMemoryDir — so `crtr memory read <plugin>/<leaf>` returned not_found for
-// a name that `list` had just shown. Only the bare-leaf fallback (`read capture`)
-// resolved. The fix taught findMemoryMatches to resolve `<plugin>/<rest>` against
-// each enabled plugin's pluginMemoryDir, native-before-plugin precedence kept.
-//
-// Follow-up bug (same seat): the `<plugin>/<rest>` branch required a non-empty
-// rest (`if (slash <= 0) continue`), so a BARE plugin name never tried the
-// plugin-root INDEX.md — `read claude-godot-prompter` / `read ai` returned
-// not_found even though `<plugin>/INDEX` and `<plugin>/<child>` resolved. The
-// fix resolves a bare plugin name to `<plugin>/memory/INDEX.md`, mirroring the
-// native bare-dir-name -> INDEX.md contract, native-before-plugin kept.
-//
-// This test FAILS on the pre-fix code (the fully-qualified and bare-plugin-name
-// reads throw notFound) and PASSES on the current code.
-//
-// Run: node --import tsx/esm --test src/core/__tests__/memory-resolver.test.ts
-import { test, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { listAllMemoryDocs, resolveMemoryDoc } from '../memory-resolver.js';
-import { resetScopeCache } from '../scope.js';
-// Fixture: a temp PROJECT scope (a `.crouter/` dir discovered by walking up from
-// cwd) holding both a native memory/ tree and one enabled fixture plugin whose
-// memory/ tree mounts under the `fixplug/` namespace.
-let projectDir;
-let prevCwd;
-const PLUGIN = 'fixplug';
-function doc(name) {
-    return `---\nkind: knowledge\nwhen-and-why-to-read: fixture doc ${name}\n---\n\n# ${name}\n`;
-}
-before(() => {
-    prevCwd = process.cwd();
-    projectDir = mkdtempSync(join(tmpdir(), 'crtr-memres-'));
-    const scopeRoot = join(projectDir, '.crouter');
-    // Native scope docs. `fixplug/shared` is a native SHADOW of a plugin doc of
-    // the same canonical name — it must win (native-before-plugin precedence).
-    const memDir = join(scopeRoot, 'memory');
-    mkdirSync(join(memDir, PLUGIN), { recursive: true });
-    writeFileSync(join(memDir, PLUGIN, 'shared.md'), doc('native-shared'));
-    // Fixture plugin: enabled manifest + a flat substrate doc and a nested one.
-    const pluginRoot = join(scopeRoot, 'plugins', PLUGIN);
-    mkdirSync(join(pluginRoot, '.crouter-plugin'), { recursive: true });
-    writeFileSync(join(pluginRoot, '.crouter-plugin', 'plugin.json'), JSON.stringify({ name: PLUGIN, version: '0.0.0' }));
-    const pluginMem = join(pluginRoot, 'memory');
-    mkdirSync(join(pluginMem, 'area'), { recursive: true });
-    writeFileSync(join(pluginMem, 'widget.md'), doc('plugin-widget'));
-    writeFileSync(join(pluginMem, 'area', 'zone.md'), doc('plugin-zone'));
-    writeFileSync(join(pluginMem, 'shared.md'), doc('plugin-shared'));
-    writeFileSync(join(pluginMem, 'SKILL.md'), doc('legacy-plugin-skill'));
-    mkdirSync(join(memDir, 'legacy'), { recursive: true });
-    writeFileSync(join(memDir, 'legacy', 'SKILL.md'), doc('legacy-native-skill'));
-    // Plugin-root INDEX.md: a BARE plugin name must resolve this (mirrors the
-    // native bare-dir-name -> INDEX.md contract for the plugin mount root).
-    writeFileSync(join(pluginMem, 'INDEX.md'), doc('plugin-root-index'));
-    // Explicitly enable the plugin in config (default is enabled, but be robust).
-    writeFileSync(join(scopeRoot, 'config.json'), JSON.stringify({ plugins: { [PLUGIN]: { enabled: true } } }));
-    // Point the scope resolver at the fixture: project scope is found by walking
-    // up from cwd, so chdir into the temp dir and clear the cached project root.
-    process.chdir(projectDir);
-    resetScopeCache();
-});
-after(() => {
-    process.chdir(prevCwd);
-    resetScopeCache();
-    rmSync(projectDir, { recursive: true, force: true });
-});
-test('fully-qualified <plugin>/<leaf> resolves to the plugin substrate doc', () => {
-    // Pre-fix this threw notFound (findMemoryMatches never searched pluginMemoryDir).
-    const d = resolveMemoryDoc(`${PLUGIN}/widget`);
-    assert.equal(d.name, `${PLUGIN}/widget`);
-    assert.ok(d.path.endsWith(join('plugins', PLUGIN, 'memory', 'widget.md')));
-});
-test('fully-qualified multi-segment <plugin>/<a>/<b> resolves the nested doc', () => {
-    // Pre-fix this also threw notFound.
-    const d = resolveMemoryDoc(`${PLUGIN}/area/zone`);
-    assert.equal(d.name, `${PLUGIN}/area/zone`);
-    assert.ok(d.path.endsWith(join('plugins', PLUGIN, 'memory', 'area', 'zone.md')));
-});
-test('the bare leaf still resolves via last-segment fallback', () => {
-    // This worked even pre-fix (leaf fallback scans listAllMemoryDocs, which DID
-    // enumerate plugin docs) — the gap was the direct fully-qualified path only.
-    const d = resolveMemoryDoc('widget');
-    assert.equal(d.name, `${PLUGIN}/widget`);
-});
-test('bare plugin name resolves the plugin-root INDEX.md', () => {
-    // Regression: findMemoryMatches skipped the plugin branch for a bare name
-    // (`if (slash <= 0) continue`), so a bare plugin name never tried the
-    // plugin-root INDEX.md and returned not_found — even though `<plugin>/INDEX`
-    // resolved. The fix resolves the bare mount root to <plugin>/memory/INDEX.md.
-    const d = resolveMemoryDoc(PLUGIN);
-    assert.equal(d.name, PLUGIN);
-    assert.ok(d.path.endsWith(join('plugins', PLUGIN, 'memory', 'INDEX.md')));
-});
-test('native doc wins over a plugin doc of the same canonical name', () => {
-    // native-before-plugin precedence: findMemoryMatches checks scopeMemoryDir
-    // before pluginMemoryDir, so the native shadow at memory/fixplug/shared.md
-    // wins over the plugin's memory/shared.md.
-    const d = resolveMemoryDoc(`${PLUGIN}/shared`);
-    assert.equal(d.name, `${PLUGIN}/shared`);
-    assert.ok(d.path.endsWith(join('memory', PLUGIN, 'shared.md')));
-    assert.ok(!d.path.includes(join('plugins', PLUGIN)));
-});
-test('legacy SKILL.md bundles are not memory docs', () => {
-    const names = listAllMemoryDocs('project').map((d) => d.name);
-    assert.ok(!names.includes('legacy'));
-    assert.ok(!names.includes(`${PLUGIN}/SKILL`));
-    assert.throws(() => resolveMemoryDoc('legacy'), /memory document not found/);
-    assert.throws(() => resolveMemoryDoc('legacy/SKILL'), /memory document not found/);
-    assert.throws(() => resolveMemoryDoc(`${PLUGIN}/SKILL`), /memory document not found/);
-});

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

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

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

@@ -1,60 +0,0 @@
-// Tests for the substrate memory surface in the orchestration kernel:
-//   1. The kernel names the three memory scopes and the document substrate flow
-//      (crtr memory write/list/find/read).
-//   2. Promotion guidance names the three stores without re-listing their dirs.
-//
-// Run: node --import tsx/esm --test src/core/__tests__/memory.test.ts
-import { test, before, beforeEach, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { closeDb } from '../canvas/db.js';
-import { spawnNode } from '../runtime/nodes.js';
-import { promote } from '../runtime/promote.js';
-import { personaDrift } from '../runtime/persona.js';
-import { loadKernel } from '../personas/index.js';
-let home;
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-memory-'));
-    process.env['CRTR_HOME'] = home;
-});
-beforeEach(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-});
-after(() => {
-    closeDb();
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['CRTR_HOME'];
-});
-// ---------------------------------------------------------------------------
-// Kernel + guidance: the document substrate flow
-// ---------------------------------------------------------------------------
-test('the orchestration kernel names the three stores and the substrate commands', () => {
-    const kernel = loadKernel();
-    for (const store of ['user-global', 'project', 'node-local']) {
-        assert.ok(kernel.includes(store), `kernel names the ${store} store`);
-    }
-    // The substrate commands must be present.
-    assert.ok(kernel.includes('crtr memory write'), 'kernel mentions crtr memory write');
-    assert.ok(kernel.includes('crtr memory list'), 'kernel mentions crtr memory list');
-    assert.ok(kernel.includes('crtr memory find'), 'kernel mentions crtr memory find');
-    assert.ok(kernel.includes('crtr memory read'), 'kernel mentions crtr memory read');
-    // It teaches the substrate flow only — no MEMORY.md pointer-line index.
-    assert.ok(!kernel.includes('MEMORY.md'), 'kernel does not mention MEMORY.md');
-    assert.ok(!kernel.includes('pointer line'), 'kernel does not teach the pointer-line flow');
-});
-test('promotion guidance references the three stores; no <memory> block', () => {
-    const meta = spawnNode({ kind: 'general', cwd: '/tmp/work', parent: null });
-    promote(meta.node_id);
-    const drift = personaDrift(meta.node_id);
-    assert.ok(drift !== null, 'promotion drifts the persona');
-    const guidance = drift.guidance;
-    // It NAMES the three stores so a promoting node knows its memory scopes.
-    for (const store of ['user-global', 'project', 'node-local']) {
-        assert.ok(guidance.includes(store), `guidance names the ${store} store`);
-    }
-    // The guidance points at the substrate flow, not a <memory> block.
-    assert.ok(!guidance.includes('<memory>'), 'guidance does not point at a <memory> block');
-});

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

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

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

@@ -1,160 +0,0 @@
-// Run: node --import tsx/esm --test src/core/__tests__/model-ladders.test.ts
-//
-// The runtime model ladder is user-configurable: config.json can override the
-// provider default, the per-provider ladder cells, and persona-strength picks.
-// This test verifies both the merge shape and the cached sync read invalidation
-// on config edits.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { readConfig } from '../config.js';
-import { buildLaunchSpec, equivalentOtherProviderModel, normalizeModel } from '../runtime/launch.js';
-let home;
-const crtrRoot = () => join(home, '.crouter');
-const configFile = () => join(crtrRoot(), 'config.json');
-function writeConfig(config) {
-    mkdirSync(crtrRoot(), { recursive: true });
-    writeFileSync(configFile(), `${JSON.stringify(config, null, 2)}\n`, 'utf8');
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-model-ladders-'));
-    process.env['HOME'] = home;
-});
-beforeEach(() => {
-    rmSync(crtrRoot(), { recursive: true, force: true });
-});
-after(() => {
-    rmSync(home, { recursive: true, force: true });
-    delete process.env['HOME'];
-});
-test('config merge keeps ladder defaults while honoring overrides', () => {
-    writeConfig({
-        modelLadders: {
-            defaultProvider: 'openai',
-            anthropic: {
-                ultra: 'anthropic/custom-ultra-1',
-                strong: 'anthropic/custom-strong-1',
-                medium: 'anthropic/custom-medium-1',
-                light: 'anthropic/custom-light-1',
-            },
-            openai: {
-                ultra: 'openai/custom-ultra-1',
-                strong: 'openai/custom-strong-1',
-                medium: 'openai/custom-medium-1',
-                light: 'openai/custom-light-1',
-            },
-        },
-        personaStrengths: {
-            developer: 'light',
-        },
-    });
-    const cfg = readConfig('user');
-    assert.equal(cfg.modelLadders.defaultProvider, 'openai');
-    assert.equal(cfg.modelLadders.openai.strong, 'openai/custom-strong-1');
-    assert.equal(cfg.modelLadders.anthropic.light, 'anthropic/custom-light-1');
-    assert.equal(cfg.personaStrengths.developer, 'light');
-});
-test('normalizeModel and buildLaunchSpec honor config overrides, and edits invalidate the cache', () => {
-    writeConfig({
-        modelLadders: {
-            defaultProvider: 'openai',
-            anthropic: {
-                ultra: 'anthropic/custom-ultra-1',
-                strong: 'anthropic/custom-strong-1',
-                medium: 'anthropic/custom-medium-1',
-                light: 'anthropic/custom-light-1',
-            },
-            openai: {
-                ultra: 'openai/custom-ultra-1',
-                strong: 'openai/custom-strong-1',
-                medium: 'openai/custom-medium-1',
-                light: 'openai/custom-light-1',
-            },
-        },
-        personaStrengths: {
-            developer: 'light',
-        },
-    });
-    assert.equal(normalizeModel('strong'), 'openai/custom-strong-1', 'config default provider wins over env/default');
-    assert.equal(normalizeModel('opus'), 'anthropic/custom-strong-1', 'family aliases still map to anthropic');
-    const override = buildLaunchSpec('developer', 'base', {
-        lifecycle: 'terminal',
-        hasManager: true,
-        model: 'medium',
-    });
-    assert.equal(override.launch.model, 'openai/custom-medium-1', 'meta.model_override wins over personaStrengths');
-    const persona = buildLaunchSpec('developer', 'base', {
-        lifecycle: 'terminal',
-        hasManager: true,
-    });
-    assert.equal(persona.launch.model, 'openai/custom-light-1', 'personaStrengths wins over persona frontmatter');
-    writeConfig({
-        modelLadders: {
-            defaultProvider: 'anthropic',
-            anthropic: {
-                ultra: 'anthropic/custom-ultra-2',
-                strong: 'anthropic/custom-strong-2',
-                medium: 'anthropic/custom-medium-2',
-                light: 'anthropic/custom-light-2',
-            },
-            openai: {
-                ultra: 'openai/custom-ultra-2',
-                strong: 'openai/custom-strong-2',
-                medium: 'openai/custom-medium-2',
-                light: 'openai/custom-light-2',
-            },
-        },
-        personaStrengths: {
-            developer: 'strong',
-        },
-    });
-    assert.equal(normalizeModel('strong'), 'anthropic/custom-strong-2', 'a config edit invalidates the cached sync read');
-    const edited = buildLaunchSpec('developer', 'base', {
-        lifecycle: 'terminal',
-        hasManager: true,
-    });
-    assert.equal(edited.launch.model, 'anthropic/custom-strong-2', 'edited personaStrengths are picked up on the next launch');
-});
-test('equivalentOtherProviderModel maps a failed ladder model to the other provider at the same strength', () => {
-    writeConfig({
-        modelLadders: {
-            defaultProvider: 'anthropic',
-            anthropic: {
-                ultra: 'anthropic/custom-ultra',
-                strong: 'anthropic/custom-strong:high',
-                medium: 'anthropic/custom-medium',
-                light: 'anthropic/custom-light',
-            },
-            openai: {
-                ultra: 'openai/custom-ultra',
-                strong: 'openai/custom-strong:xhigh',
-                medium: 'openai/custom-medium',
-                light: 'openai/custom-light',
-            },
-        },
-    });
-    assert.deepEqual(equivalentOtherProviderModel('anthropic/custom-strong:medium'), {
-        fromProvider: 'anthropic',
-        toProvider: 'openai',
-        strength: 'strong',
-        model: 'openai/custom-strong:xhigh',
-    });
-    assert.deepEqual(equivalentOtherProviderModel('openai/custom-light'), {
-        fromProvider: 'openai',
-        toProvider: 'anthropic',
-        strength: 'light',
-        model: 'anthropic/custom-light',
-    });
-    assert.equal(equivalentOtherProviderModel('anthropic/custom-strong:medium', new Set(['anthropic'])), null);
-    assert.equal(equivalentOtherProviderModel('some-provider/not-in-ladder'), null);
-});
-test('malformed existing user config surfaces instead of falling back to defaults', () => {
-    mkdirSync(crtrRoot(), { recursive: true });
-    writeFileSync(configFile(), '{\n', 'utf8');
-    assert.throws(() => buildLaunchSpec('developer', 'base', {
-        lifecycle: 'terminal',
-        hasManager: true,
-    }), /JSON|Unexpected token|Unexpected end/);
-});

package/dist/core/__tests__/node-env.test.d.ts

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

package/dist/core/__tests__/node-env.test.js

@@ -1,26 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { nodeEnv } from '../runtime/nodes.js';
-function meta(over = {}) {
-    return {
-        node_id: 'n',
-        name: 'alpha-beta',
-        created: '2026-01-01T00:00:00.000Z',
-        cwd: '/tmp/work',
-        kind: 'developer',
-        mode: 'base',
-        lifecycle: 'terminal',
-        status: 'active',
-        ...over,
-    };
-}
-test('nodeEnv exports CRTR_CYCLES from meta.cycles', () => {
-    const env = nodeEnv(meta({ cycles: 9 }));
-    assert.equal(env.CRTR_CYCLES, '9');
-});
-test('nodeEnv defaults CRTR_CYCLES to 0 when meta.cycles is absent', () => {
-    const withoutCycles = meta();
-    delete withoutCycles.cycles;
-    const env = nodeEnv(withoutCycles);
-    assert.equal(env.CRTR_CYCLES, '0');
-});

package/dist/core/__tests__/pane-column.test.d.ts

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