@crouton-kit/crouter 0.3.32 → 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.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.js

@@ -1,108 +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 { 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'));
-    // 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)));
-});

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__/pane-column.test.js

@@ -1,153 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/pane-column.test.ts
-//
-// STEP 2 of the placement/focus migration: the `pane` runtime column —
-// LOCATION's authoritative handle (the durable tmux `%pane_id`). This step is
-// PURELY ADDITIVE: the column exists, setPresence writes it, getNode/getRow read
-// it back, but nothing READS it for behavior yet (population wires up in Steps
-// 3+). Covers:
-//   - migration v5 adds `pane` to a fresh db (and a legacy v4 db migrates up)
-//   - createNode seeds pane; setPresence writes it atomically with window/session
-//   - getNode (hydrated view) + getRow (row) both read pane back
-//   - a row never given a pane reads pane=null (legacy/back-compat)
-//   - the migration is idempotent / forward-only (re-open is a no-op)
-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 { DatabaseSync } from 'node:sqlite';
-import { createNode, getNode, getRow, setPresence } from '../canvas/canvas.js';
-import { openDb, closeDb, migrate, MIGRATIONS } from '../canvas/db.js';
-import { 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,
-    };
-}
-function userVersion(db) {
-    return db.prepare('PRAGMA user_version').get().user_version;
-}
-function nodeColumns(db) {
-    return db.prepare('PRAGMA table_info(nodes)').all().map((r) => r.name);
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-pane-'));
-    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'];
-});
-// ---------------------------------------------------------------------------
-// Migration v5 — the additive `pane` column.
-// ---------------------------------------------------------------------------
-test('a fresh db migrates to the latest version and has the pane column', () => {
-    const db = openDb();
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    assert.ok(nodeColumns(db).includes('pane'), 'nodes.pane exists on a fresh db');
-});
-test('a v4 db migrates forward, adding pane=NULL without disturbing existing data', () => {
-    // Hand-build a db at exactly v4: baseline + the four v2 runtime columns +
-    // edges WITH the v4 FK shape, user_version=4 — the shape just before v5.
-    ensureHome();
-    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
-    );
-    CREATE TABLE edges (
-      type TEXT NOT NULL, from_id TEXT NOT NULL, to_id TEXT NOT NULL,
-      active INTEGER NOT NULL DEFAULT 1, created TEXT NOT NULL,
-      PRIMARY KEY (type, from_id, to_id),
-      FOREIGN KEY (from_id) REFERENCES nodes(node_id) ON DELETE CASCADE,
-      FOREIGN KEY (to_id)   REFERENCES nodes(node_id) ON DELETE CASCADE
-    );
-    PRAGMA user_version = 4;
-  `);
-    raw
-        .prepare('INSERT INTO nodes (node_id, name, kind, status, cwd, created, window, tmux_session) VALUES (?,?,?,?,?,?,?,?)')
-        .run('legacy', 'Legacy', 'general', 'idle', '/tmp/work', '2020-01-01T00:00:00Z', '@9', 'crtr');
-    assert.equal(userVersion(raw), 4);
-    assert.ok(!nodeColumns(raw).includes('pane'), 'precondition: no pane column at v4');
-    raw.close();
-    // openDb() runs v5 forward.
-    const db = openDb();
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    assert.ok(nodeColumns(db).includes('pane'), 'pane column added by v5');
-    // The pre-existing row is intact; its pane backfills NULL (additive default).
-    const row = db
-        .prepare('SELECT status, window, tmux_session, pane FROM nodes WHERE node_id = ?')
-        .get('legacy');
-    assert.equal(row['status'], 'idle', 'existing status untouched');
-    assert.equal(row['window'], '@9', 'existing window untouched');
-    assert.equal(row['tmux_session'], 'crtr', 'existing session untouched');
-    assert.equal(row['pane'], null, 'pane defaults NULL for a legacy row');
-});
-test('the migration is idempotent / forward-only on re-run and re-open', () => {
-    const db = openDb();
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    // Re-running migrate() is a no-op — the gate skips applied steps, so the v5
-    // ALTER ADD COLUMN never fires twice (which would throw "duplicate column").
-    assert.doesNotThrow(() => migrate(db));
-    assert.equal(userVersion(db), MIGRATIONS.length);
-    // Re-opening from disk is likewise a no-op.
-    closeDb();
-    const db2 = openDb();
-    assert.equal(userVersion(db2), MIGRATIONS.length);
-    assert.ok(nodeColumns(db2).includes('pane'));
-});
-// ---------------------------------------------------------------------------
-// Round-trip: pane is a RUNTIME field, authoritative in the row, read back by
-// both the hydrated view (getNode) and the row (getRow).
-// ---------------------------------------------------------------------------
-test('createNode seeds pane and getNode/getRow read it back', () => {
-    createNode(node('n', { tmux_session: 'crtr', window: '@1', pane: '%5' }));
-    assert.equal(getNode('n')?.pane, '%5', 'getNode hydrates pane from the row');
-    assert.equal(getRow('n')?.pane, '%5', 'getRow returns pane on the NodeRow');
-});
-test('a node created without a pane reads pane=null (legacy / back-compat)', () => {
-    createNode(node('n', { tmux_session: 'crtr', window: '@1' }));
-    assert.equal(getNode('n')?.pane, null, 'no pane given → null on the hydrated view');
-    assert.equal(getRow('n')?.pane, null, 'no pane given → null on the row');
-});
-test('setPresence writes pane atomically alongside window + session', () => {
-    createNode(node('n'));
-    setPresence('n', { tmux_session: 'user-sess', window: '@2', pane: '%7' });
-    const m = getNode('n');
-    assert.equal(m?.pane, '%7', 'setPresence wrote the pane');
-    assert.equal(m?.window, '@2', 'setPresence wrote the window in the same statement');
-    assert.equal(m?.tmux_session, 'user-sess', 'setPresence wrote the session in the same statement');
-});
-test('setPresence without pane writes null (the Step-2 contract: nobody reads pane yet)', () => {
-    createNode(node('n', { pane: '%7' }));
-    assert.equal(getNode('n')?.pane, '%7');
-    // A presence write that omits pane resets it to null — fine for Step 2 because
-    // no reader depends on pane until the placement layer lands (Steps 3+).
-    setPresence('n', { tmux_session: 'crtr', window: '@3' });
-    assert.equal(getNode('n')?.pane, null, 'omitted pane → null (no half-written LOCATION)');
-});
-test('pane is a RUNTIME field — it never leaks into meta.json identity', () => {
-    createNode(node('n', { pane: '%5' }));
-    setPresence('n', { pane: '%9', window: '@1', tmux_session: 'crtr' });
-    // meta.json is durable identity only; the runtime pane lives in the row.
-    const onDisk = openDb().prepare('SELECT pane FROM nodes WHERE node_id = ?').get('n');
-    assert.equal(onDisk.pane, '%9', 'pane is authoritative in the row');
-});

package/dist/core/__tests__/persona-compose.test.js

@@ -1,53 +0,0 @@
-// Run: node --import tsx/esm --test src/core/__tests__/persona-compose.test.ts
-//
-// The static system-prompt composer (core/personas/resolve.ts) varies the
-// runtime protocol on TWO axes beyond kind×mode:
-//   • lifecycle (terminal | resident) — the "how you end" contract.
-//   • spine position (hasManager) — whether the push-up family is taught AT ALL.
-// These assert the four corners, especially the resident+no-manager root that
-// must never hear about `push` (final OR update).
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { resolve } from '../personas/index.js';
-// The lifecycle fragment is identified by its signature contract phrase, not by
-// the raw "push final" substring — the resident fragment legitimately NAMES
-// `push final` only to forbid it. The kind body is now lifecycle-neutral, so the
-// only finish contract in the prompt is whichever fragment composed.
-const TERMINAL_CONTRACT = /owe a final result and you reap when done/i;
-const RESIDENT_CONTRACT = /never forced to submit a final result/i;
-const PUSH_UP = /crtr push (update|urgent)/i;
-test('terminal + has-manager (the default child worker): terminal finish + push up', () => {
-    const p = resolve('general', 'base', { lifecycle: 'terminal', hasManager: true });
-    assert.match(p.systemPrompt, TERMINAL_CONTRACT, 'a terminal node owes a final and finishes via push final');
-    assert.doesNotMatch(p.systemPrompt, RESIDENT_CONTRACT);
-    assert.match(p.systemPrompt, PUSH_UP, 'a managed node reports up via push update/urgent');
-    assert.equal(p.lifecycle, 'terminal');
-});
-test('resident + no-manager (the user-facing root): resident finish, and NO push-up family at all', () => {
-    const p = resolve('general', 'base', { lifecycle: 'resident', hasManager: false });
-    assert.match(p.systemPrompt, RESIDENT_CONTRACT, 'a resident root is never forced to submit');
-    assert.doesNotMatch(p.systemPrompt, TERMINAL_CONTRACT, 'it does not get the terminal finish contract');
-    assert.doesNotMatch(p.systemPrompt, PUSH_UP, 'a top-of-spine root has nobody to push up to');
-    assert.match(p.systemPrompt, /top of your spine/i, 'oriented as top-of-spine');
-    assert.match(p.systemPrompt, /dormant/i, 'told it goes dormant and wakes');
-});
-test('resident + has-manager (interactable sub-orchestrator): resident finish, but still push up', () => {
-    const p = resolve('general', 'base', { lifecycle: 'resident', hasManager: true });
-    assert.match(p.systemPrompt, RESIDENT_CONTRACT, 'resident is never forced to submit a final');
-    assert.doesNotMatch(p.systemPrompt, TERMINAL_CONTRACT);
-    assert.match(p.systemPrompt, PUSH_UP, 'still reports progress up to its manager');
-});
-test('terminal + no-manager (a terminal root): terminal finish, but no push up', () => {
-    const p = resolve('general', 'base', { lifecycle: 'terminal', hasManager: false });
-    assert.match(p.systemPrompt, TERMINAL_CONTRACT, 'terminal still finishes via push final (self-completes)');
-    assert.doesNotMatch(p.systemPrompt, PUSH_UP, 'nobody subscribes, so no report-up family');
-});
-test('the lifecycle-neutral base survives in every corner (delegate + human ask)', () => {
-    for (const hasManager of [true, false]) {
-        for (const lifecycle of ['terminal', 'resident']) {
-            const p = resolve('general', 'base', { lifecycle, hasManager });
-            assert.match(p.systemPrompt, /crtr node new/, `delegate verb present (${lifecycle}/${hasManager})`);
-            assert.match(p.systemPrompt, /crtr human ask/, `human-ask present (${lifecycle}/${hasManager})`);
-        }
-    }
-});