@crouton-kit/crouter 0.3.28 → 0.3.30

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

@@ -1,335 +0,0 @@
-// Run with: node --import tsx/esm --test src/core/__tests__/relaunch.test.ts
-//
-// Covers the `/new`-in-a-root relaunch (option C) + clean-exit termination
-// semantics. tmux/respawn is unavailable in CI, so the respawn is an INJECTED
-// test double (RelaunchDeps.relaunchRootInPane) and every assertion is on the
-// DB / edge / disk effects.
-import { test, before, after, beforeEach } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, existsSync, writeFileSync, readdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createNode, getNode, subscribe, subscriptionsOf, view, listNodes, } from '../canvas/canvas.js';
-import { closeDb } from '../canvas/db.js';
-import { getFocusByNode, openFocusRow } from '../canvas/focuses.js';
-import { reportsDir, inboxPath, contextDir } from '../canvas/paths.js';
-import { roadmapPath } from '../runtime/roadmap.js';
-import { relaunchRoot, handleNewSession, markCleanExitDone, reapDescendants, } from '../runtime/reset.js';
-import { renderForest } from '../canvas/render.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,
-    };
-}
-/** A respawn double that records its calls and never throws (dispatch ok). */
-function okRespawn() {
-    const calls = [];
-    return {
-        calls,
-        fn: (nodeId, pane) => { calls.push({ nodeId, pane }); },
-    };
-}
-/** A respawn double that simulates a dispatch failure (throws). */
-function throwingRespawn() {
-    const calls = [];
-    return {
-        calls,
-        fn: (nodeId, pane) => {
-            calls.push({ nodeId, pane });
-            throw new Error('respawn-pane dispatch failed');
-        },
-    };
-}
-before(() => {
-    home = mkdtempSync(join(tmpdir(), 'crtr-relaunch-'));
-    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 — relaunchRoot parks the old root, keeps edges, creates a fresh root
-// ---------------------------------------------------------------------------
-test('relaunchRoot parks the old root (canceled, edges intact, no wipe) and mints a fresh root', () => {
-    createNode(node('root', {
-        parent: null,
-        lifecycle: 'resident',
-        mode: 'orchestrator',
-        pi_session_id: 'root-sess',
-        pi_session_file: '/abs/root-sess.jsonl',
-        tmux_session: 'crtr',
-        window: '@7',
-    }));
-    createNode(node('child', { parent: 'root' }));
-    createNode(node('grand', { parent: 'child' }));
-    subscribe('root', 'child', true);
-    subscribe('child', 'grand', true);
-    openFocusRow('fRoot', '%root', 'crtr', 'root'); // the old root occupies focus #1
-    // Working state on the old root that parking must PRESERVE (no wipe).
-    writeFileSync(roadmapPath('root'), '# Roadmap\nold goal\n');
-    writeFileSync(inboxPath('root'), '{"ts":"x","from":"child","tier":"normal","kind":"update","label":"hi"}\n');
-    writeFileSync(join(reportsDir('root'), '20260101T000000-update.md'), 'a report');
-    const respawn = okRespawn();
-    const res = relaunchRoot('root', 'test-pane', { relaunchRootInPane: respawn.fn });
-    assert.ok(res !== null, 'relaunchRoot returns the new node id');
-    const newId = res.newNodeId;
-    assert.notEqual(newId, 'root', 'a FRESH id, not the old one');
-    // Respawn was dispatched against the NEW node in the given pane.
-    assert.deepEqual(respawn.calls, [{ nodeId: newId, pane: 'test-pane' }]);
-    // Old root: parked canceled, window detached, pi_session_id UNCHANGED (resumable).
-    const old = getNode('root');
-    assert.equal(old?.status, 'canceled', 'old root parked canceled');
-    assert.equal(old?.window, null, 'old root window detached');
-    assert.equal(old?.tmux_session, null, 'old root tmux_session detached');
-    assert.equal(old?.intent, null, 'old root intent cleared');
-    assert.equal(old?.pi_session_id, 'root-sess', 'pi_session_id preserved (resumable)');
-    assert.equal(old?.pi_session_file, '/abs/root-sess.jsonl', 'pi_session_file preserved (resumable by path)');
-    assert.equal(old?.parent, null, 'old root stays a root');
-    // Descendants: CANCELED (not dead), but edges intact.
-    assert.equal(getNode('child')?.status, 'canceled', 'child marked canceled (not a fault)');
-    assert.equal(getNode('grand')?.status, 'canceled', 'grand marked canceled (not a fault)');
-    assert.deepEqual(subscriptionsOf('root').map((s) => s.node_id), ['child'], 'root→child edge intact');
-    assert.deepEqual(subscriptionsOf('child').map((s) => s.node_id), ['grand'], 'child→grand edge intact');
-    // Old root working state PRESERVED (history, no wipe).
-    assert.equal(existsSync(roadmapPath('root')), true, 'roadmap preserved');
-    assert.equal(existsSync(inboxPath('root')), true, 'inbox preserved');
-    assert.equal(existsSync(join(reportsDir('root'), '20260101T000000-update.md')), true, 'report preserved');
-    // New root: fresh base resident, active, intent=refresh, a clean-slate context
-    // dir (only the born-with memory store, nothing inherited), spawned_by=old,
-    // focused.
-    const fresh = getNode(newId);
-    assert.equal(fresh?.parent, null, 'new node is a root');
-    assert.equal(fresh?.mode, 'base');
-    assert.equal(fresh?.lifecycle, 'resident');
-    assert.equal(fresh?.status, 'active');
-    assert.equal(fresh?.intent, 'refresh', 'safety-net intent until boot');
-    assert.equal(fresh?.spawned_by, 'root', 'audit-only successor link to old root');
-    assert.equal(fresh?.pi_pid, null, 'no pi yet');
-    assert.equal(fresh?.tmux_session, 'crtr', 'adopted the old root window location');
-    assert.equal(fresh?.window, '@7');
-    assert.ok(fresh?.launch, 'a fresh base launch spec was written');
-    assert.deepEqual(readdirSync(contextDir(newId)).sort(), ['memory'], 'fresh context dir holds only the born-with node-local memory store — nothing inherited from the old root');
-    // Focus follows content: the focus row the old root held now shows the new root.
-    assert.equal(getFocusByNode(newId)?.focus_id, 'fRoot', 'focus row repointed to the new root');
-    assert.equal(getFocusByNode('root'), null, 'old root no longer occupies the focus');
-});
-// ---------------------------------------------------------------------------
-// #1b — handleNewSession success branch: root WITH a pane routes to relaunch
-// ---------------------------------------------------------------------------
-test('handleNewSession on a root with a pane returns path:relaunch + parks old, mints fresh', () => {
-    createNode(node('root', {
-        parent: null,
-        lifecycle: 'resident',
-        mode: 'orchestrator',
-        pi_session_id: 'root-sess',
-        tmux_session: 'crtr',
-        window: '@7',
-    }));
-    createNode(node('child', { parent: 'root' }));
-    subscribe('root', 'child', true);
-    openFocusRow('fRoot', '%root', 'crtr', 'root'); // the old root occupies focus #1
-    const respawn = okRespawn();
-    const res = handleNewSession('root', 'newsess', 'test-pane', { relaunchRootInPane: respawn.fn });
-    // The policy router's success return shape: relaunch + a fresh new node id.
-    assert.equal(res.path, 'relaunch', 'root + pane routes to option C relaunch');
-    assert.ok(res.newNodeId, 'newNodeId set on the relaunch path');
-    assert.notEqual(res.newNodeId, 'root', 'a FRESH id, not the old root');
-    // Respawn dispatched against the new node in the pane.
-    assert.deepEqual(respawn.calls, [{ nodeId: res.newNodeId, pane: 'test-pane' }]);
-    // Parked-old + fresh-new end state.
-    const old = getNode('root');
-    assert.equal(old?.status, 'canceled', 'old root parked canceled');
-    assert.equal(old?.window, null, 'old root window detached');
-    assert.equal(old?.pi_session_id, 'root-sess', 'pi_session_id preserved (resumable)');
-    assert.equal(getNode('child')?.status, 'canceled', 'descendant reaped canceled');
-    const fresh = getNode(res.newNodeId);
-    assert.equal(fresh?.parent, null, 'new node is a root');
-    assert.equal(fresh?.status, 'active', 'fresh root active');
-    assert.equal(fresh?.spawned_by, 'root', 'audit-only successor link to old root');
-    assert.equal(getFocusByNode(res.newNodeId)?.focus_id, 'fRoot', 'focus row repointed to the fresh root');
-});
-// ---------------------------------------------------------------------------
-// #2 — handleNewSession on a non-root → session-id refresh only
-// ---------------------------------------------------------------------------
-test('handleNewSession on a non-root child only refreshes its session id', () => {
-    createNode(node('root', { parent: null }));
-    createNode(node('child', { parent: 'root', pi_session_id: 'old', pi_session_file: '/abs/old.jsonl' }));
-    subscribe('root', 'child', true);
-    const before = listNodes().length;
-    const res = handleNewSession('child', 'fresh', 'test-pane', {}, '/abs/fresh.jsonl');
-    assert.equal(res.path, 'reset-child');
-    assert.equal(res.newNodeId, undefined, 'no new node minted');
-    assert.equal(getNode('child')?.pi_session_id, 'fresh', 'session id refreshed');
-    assert.equal(getNode('child')?.pi_session_file, '/abs/fresh.jsonl', 'session FILE refreshed (path-based resume)');
-    assert.equal(getNode('child')?.status, 'active', 'child not reaped');
-    assert.equal(listNodes().length, before, 'no node added');
-});
-// ---------------------------------------------------------------------------
-// #3 — handleNewSession on a root with no pane → in-place reset fallback
-// ---------------------------------------------------------------------------
-test('handleNewSession on a root with no pane falls back to in-place resetRoot', () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident', mode: 'orchestrator' }));
-    createNode(node('child', { parent: 'root' }));
-    subscribe('root', 'child', true);
-    writeFileSync(roadmapPath('root'), '# Roadmap\n');
-    const before = listNodes().length;
-    const res = handleNewSession('root', 'newsess', undefined);
-    assert.equal(res.path, 'reset-root', 'documented degradation: in-place reset');
-    assert.equal(res.newNodeId, undefined, 'NO new node created');
-    assert.equal(listNodes().length, before, 'no node added (same id re-pointed)');
-    // Same id re-pointed to a pristine base resident.
-    const root = getNode('root');
-    assert.equal(root?.status, 'active');
-    assert.equal(root?.mode, 'base');
-    assert.equal(root?.lifecycle, 'resident');
-    assert.equal(root?.pi_session_id, 'newsess');
-    assert.equal(view('root').length, 0, 'root view emptied');
-    assert.equal(getNode('child')?.status, 'canceled', 'descendant marked canceled');
-    assert.equal(existsSync(roadmapPath('root')), false, 'working state wiped');
-});
-// ---------------------------------------------------------------------------
-// #4 — rapid double /new guard
-// ---------------------------------------------------------------------------
-test('a second relaunchRoot on an already-parked root is a no-op', () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident' }));
-    const respawn = okRespawn();
-    const first = relaunchRoot('root', 'test-pane', { relaunchRootInPane: respawn.fn });
-    assert.ok(first !== null, 'first /new parks + relaunches');
-    const afterFirst = listNodes().length;
-    // Old root is now `canceled`; a second session_start in the dying old pi must
-    // no-op (no second parked node, no zombie new node).
-    const second = relaunchRoot('root', 'test-pane', { relaunchRootInPane: respawn.fn });
-    assert.equal(second, null, 'second relaunch is a no-op');
-    assert.equal(listNodes().length, afterFirst, 'no second new node minted');
-    assert.equal(respawn.calls.length, 1, 'respawn dispatched only once');
-    assert.equal(getNode('root')?.status, 'canceled', 'old root unchanged (still parked)');
-});
-// ---------------------------------------------------------------------------
-// #5 — /new before the root ever spawned children
-// ---------------------------------------------------------------------------
-test('relaunchRoot on a childless root: reap is a no-op, new node minted', () => {
-    createNode(node('root', { parent: null, lifecycle: 'resident', tmux_session: 'crtr', window: '@1' }));
-    assert.deepEqual(reapDescendants('root'), [], 'no descendants to reap');
-    const respawn = okRespawn();
-    const res = relaunchRoot('root', 'test-pane', { relaunchRootInPane: respawn.fn });
-    assert.ok(res !== null, 'new node minted without throwing');
-    assert.equal(getNode('root')?.status, 'canceled', 'old root parked');
-    assert.equal(getNode(res.newNodeId)?.status, 'active', 'fresh root active');
-});
-// ---------------------------------------------------------------------------
-// #6 — respawn dispatch failure → rollback + resetRoot
-// ---------------------------------------------------------------------------
-test('a respawn dispatch failure rolls the whole transaction back and degrades to resetRoot', () => {
-    createNode(node('root', {
-        parent: null,
-        lifecycle: 'resident',
-        mode: 'orchestrator',
-        pi_session_id: 'root-sess',
-        tmux_session: 'crtr',
-        window: '@3',
-    }));
-    openFocusRow('fRoot', '%root', 'crtr', 'root'); // the old root occupies focus #1
-    const respawn = throwingRespawn();
-    const res = handleNewSession('root', 'newsess', 'test-pane', { relaunchRootInPane: respawn.fn });
-    assert.equal(res.path, 'reset-root', 'degraded to in-place reset');
-    // Old root: FULLY restored by the transaction rollback (active, with its
-    // window/session intact), then re-pointed by the resetRoot degrade path.
-    const old = getNode('root');
-    assert.equal(old?.status, 'active', 'old root back to active');
-    assert.equal(old?.window, '@3', 'window restored');
-    assert.equal(old?.tmux_session, 'crtr', 'session restored');
-    assert.equal(old?.mode, 'base', 'resetRoot re-pointed to base');
-    assert.equal(old?.pi_session_id, 'newsess', 'resetRoot rebound the new session id');
-    // No partial state: the half-built new node's ROW was rolled back WITH the
-    // transaction — no zombie active node, and (unlike the old hand-rolled
-    // compensation, which left a leaked `dead` row) no leftover row at all.
-    const actives = listNodes({ status: ['active'] }).map((r) => r.node_id);
-    assert.deepEqual(actives, ['root'], 'only the old root is active — no zombie');
-    assert.equal(listNodes({ status: ['dead'] }).length, 0, 'no dead zombie — new node row rolled back');
-    assert.equal(listNodes().length, 1, 'only the old root row exists — the mint was fully undone');
-    // The focus repoint was INSIDE the txn, so ROLLBACK restored the old occupant.
-    assert.equal(getFocusByNode('root')?.focus_id, 'fRoot', 'focus row restored to the old root (rollback undid the repoint)');
-});
-// ---------------------------------------------------------------------------
-// #7 — markCleanExitDone guard table (termination rule)
-// ---------------------------------------------------------------------------
-test('markCleanExitDone: quit on an active/intent-null node marks it done', () => {
-    createNode(node('n', { status: 'active', intent: null }));
-    assert.equal(markCleanExitDone('n', 'quit'), true);
-    assert.equal(getNode('n')?.status, 'done');
-});
-test('markCleanExitDone does NOT clobber an idle-released node', () => {
-    createNode(node('n', { status: 'idle', intent: 'idle-release' }));
-    assert.equal(markCleanExitDone('n', 'quit'), false);
-    assert.equal(getNode('n')?.status, 'idle', 'unchanged');
-    assert.equal(getNode('n')?.intent, 'idle-release', 'intent unchanged');
-});
-test('markCleanExitDone does NOT clobber a node mid-refresh-yield', () => {
-    createNode(node('n', { status: 'active', intent: 'refresh' }));
-    assert.equal(markCleanExitDone('n', 'quit'), false);
-    assert.equal(getNode('n')?.status, 'active', 'unchanged');
-    assert.equal(getNode('n')?.intent, 'refresh', 'intent unchanged');
-});
-test('markCleanExitDone does NOT re-mark an already-done node', () => {
-    createNode(node('n', { status: 'done', intent: null }));
-    assert.equal(markCleanExitDone('n', 'quit'), false);
-    assert.equal(getNode('n')?.status, 'done', 'unchanged');
-});
-test('markCleanExitDone is a no-op for every non-quit reason', () => {
-    for (const reason of ['new', 'reload', 'resume', 'fork']) {
-        closeDb();
-        rmSync(home, { recursive: true, force: true });
-        createNode(node('n', { status: 'active', intent: null }));
-        assert.equal(markCleanExitDone('n', reason), false, `${reason} → no-op`);
-        assert.equal(getNode('n')?.status, 'active', `${reason} leaves node unchanged`);
-    }
-});
-test('markCleanExitDone is a no-op for an unknown node', () => {
-    assert.equal(markCleanExitDone('ghost', 'quit'), false);
-});
-// ---------------------------------------------------------------------------
-// #8 — a parked / quit (done) node is invisible to the daemon's supervised set
-// ---------------------------------------------------------------------------
-test('a done node (parked or cleanly quit) is not in the supervised set', () => {
-    // A done node with a live-LOOKING window — the daemon never sees it because
-    // it only ever supervises listNodes({status:['active','idle']}).
-    createNode(node('parked', { parent: null, status: 'done', tmux_session: 'crtr', window: '@9' }));
-    createNode(node('live', { parent: null, status: 'active', tmux_session: 'crtr', window: '@1' }));
-    const supervised = listNodes({ status: ['active', 'idle'] }).map((r) => r.node_id);
-    assert.ok(!supervised.includes('parked'), 'parked done node excluded from supervision');
-    assert.ok(supervised.includes('live'), 'live root still supervised');
-});
-// ---------------------------------------------------------------------------
-// #9 — renderForest excludes parked / dead / canceled roots
-// ---------------------------------------------------------------------------
-test('renderForest renders only LIVE (active|idle) roots', () => {
-    const mk = (id, status) => {
-        createNode(node(id, { parent: null, status, name: id, kind: 'general' }));
-    };
-    mk('liveroot', 'active');
-    mk('idleroot', 'idle');
-    mk('parkedroot', 'done');
-    mk('deadroot', 'dead');
-    mk('cancelroot', 'canceled');
-    const out = renderForest();
-    assert.ok(out.includes('liveroot'), 'active root rendered');
-    assert.ok(out.includes('idleroot'), 'idle root rendered');
-    assert.ok(!out.includes('parkedroot'), 'parked (done) root hidden');
-    assert.ok(!out.includes('deadroot'), 'dead root hidden');
-    assert.ok(!out.includes('cancelroot'), 'canceled root hidden');
-});

package/dist/core/bridge-map.d.ts

@@ -1,19 +0,0 @@
-export interface BridgeSkillInput {
-    /** Source skill `name` frontmatter (identity only; not emitted as a field). */
-    name: string;
-    /** Source skill `description` frontmatter — the text we reshape + carry. */
-    description: string;
-    /** The skill body, copied verbatim below the generated frontmatter. */
-    body: string;
-}
-/** Reshape a Claude `description` into a read-routing sentence per
- *  taste/why-field-means-why-to-read: "When <situation>, this skill should be
- *  read [because <gist>]." Claude descriptions are typically
- *  "<gist>. Use when <situation>." — we lift the use-when clause into the
- *  situation and the preceding text into the payoff. With no explicit clause,
- *  the whole description becomes the situation. */
-export declare function reshapeWhenAndWhy(description: string): string;
-/** Map a parsed Claude SKILL.md to a crouter substrate-doc string: full
- *  frontmatter (kind/when-and-why/short-form/visibility/generator) + the copied
- *  body. Deterministic and pure. */
-export declare function buildBridgeDoc(input: BridgeSkillInput): string;

package/dist/core/bridge-map.js

@@ -1,73 +0,0 @@
-// Claude SKILL.md → crouter substrate-doc mapping (design §2.3).
-// Pure, unit-testable. The bridge command (`crtr pkg bridge sync`) runs this
-// unattended every session, so the description→read-routing reshape is a
-// deterministic, conservative string rewrite — NOT a content paraphrase. An
-// author who wants durable tuning uses an INDEX (which the bridge never
-// touches), because a generator-stamped leaf is overwritten on the next sync.
-// "Use when …" / "Use this when …" / "This skill should be used when …" / "Used when …"
-const USE_WHEN_RE = /\b(?:use\s+this\s+skill\s+when|use\s+this\s+when|this\s+skill\s+should\s+be\s+used\s+when|used\s+when|use\s+when)\b\s*/i;
-/** Collapse whitespace, strip surrounding connective punctuation, and lowercase
- *  a leading Capitalized word (but never an ACRONYM) so the clause reads inline
- *  after "When " / "because ". */
-function cleanClause(s) {
-    let c = s.replace(/\s+/g, ' ').trim();
-    c = c.replace(/^[,;:.\s]+/, '').replace(/[,;:.\s]+$/, '');
-    if (/^[A-Z][a-z]/.test(c))
-        c = c.charAt(0).toLowerCase() + c.slice(1);
-    return c;
-}
-/** Reshape a Claude `description` into a read-routing sentence per
- *  taste/why-field-means-why-to-read: "When <situation>, this skill should be
- *  read [because <gist>]." Claude descriptions are typically
- *  "<gist>. Use when <situation>." — we lift the use-when clause into the
- *  situation and the preceding text into the payoff. With no explicit clause,
- *  the whole description becomes the situation. */
-export function reshapeWhenAndWhy(description) {
-    const desc = description.replace(/\s+/g, ' ').trim();
-    if (desc === '')
-        return 'When this skill applies, this skill should be read.';
-    const m = desc.match(USE_WHEN_RE);
-    if (m && m.index !== undefined) {
-        const gist = cleanClause(desc.slice(0, m.index));
-        const situation = cleanClause(desc.slice(m.index + m[0].length));
-        if (situation !== '') {
-            let out = `When ${situation}, this skill should be read`;
-            if (gist !== '')
-                out += ` because ${gist}`;
-            return out + '.';
-        }
-    }
-    return `When ${cleanClause(desc)}, this skill should be read.`;
-}
-/** One-line short-form for the human inventory (never loaded into agent
- *  context): the source description collapsed to a single line. */
-function toShortForm(description) {
-    return description.replace(/\s+/g, ' ').trim();
-}
-/** Always-double-quote a YAML scalar, escaping backslashes and quotes. The two
- *  generated fields are single-line, so this is safe regardless of colons,
- *  commas, or other YAML-significant characters. */
-function yamlQuote(s) {
-    return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
-}
-/** Map a parsed Claude SKILL.md to a crouter substrate-doc string: full
- *  frontmatter (kind/when-and-why/short-form/visibility/generator) + the copied
- *  body. Deterministic and pure. */
-export function buildBridgeDoc(input) {
-    const whenAndWhy = reshapeWhenAndWhy(input.description);
-    const shortForm = toShortForm(input.description);
-    const fm = [
-        '---',
-        'kind: skill',
-        `when-and-why-to-read: ${yamlQuote(whenAndWhy)}`,
-        `short-form: ${yamlQuote(shortForm)}`,
-        'system-prompt-visibility: name',
-        'file-read-visibility: none',
-        'generator: claude-bridge',
-        '---',
-        '',
-    ].join('\n');
-    const body = input.body.replace(/^\n+/, '');
-    const trailing = body.endsWith('\n') ? '' : '\n';
-    return fm + '\n' + body + trailing;
-}

package/dist/core/tui/contract.d.ts

@@ -1,83 +0,0 @@
-import type { Key } from './terminal.js';
-import type { Draw, Rect } from './draw.js';
-export interface ViewManifest {
-    id: string;
-    title: string;
-    subtitle?: string;
-    description: string;
-    refreshMs?: number;
-    keymap?: KeyHint[];
-}
-export interface KeyHint {
-    keys: string;
-    label: string;
-}
-/** Severity of a {@link ViewHost.setBanner} banner — drives glyph + hue + the
- *  derived state chip (error→blocked/red, action→attention/yellow, info→neutral). */
-export type BannerLevel = 'info' | 'action' | 'error';
-/** The current host banner, threaded into {@link ViewModule.dump} so the static
- *  (non-TTY) path can surface guidance without the view mirroring it into state. */
-export interface Banner {
-    msg: string;
-    level: BannerLevel;
-}
-/** Optional host context passed to {@link ViewModule.dump} on the piped path. */
-export interface DumpContext {
-    banner: Banner | null;
-}
-export interface ViewHost {
-    /** CLI flags forwarded verbatim, e.g. { port: '9222', target: '...' }. */
-    readonly options: Readonly<Record<string, string>>;
-    /** Transient status line (left of the footer): "Loading…", "Sent". */
-    setStatus(msg: string | null): void;
-    /** Severity-coded guidance banner above the footer (info/action/error). The
-     *  level drives the banner glyph + hue AND the derived title state chip. */
-    setBanner(msg: string, level: BannerLevel): void;
-    /** Sticky error banner above the footer; null clears. Back-compat shorthand
-     *  for setBanner(msg, 'error'). */
-    setError(msg: string | null): void;
-    /** Dynamic title subtitle: a dim ` · <s>` after the bold title (e.g. the live
-     *  unread count "3 unread"). A non-null value OVERRIDES the static
-     *  {@link ViewManifest.subtitle}; `null` clears back to the manifest default
-     *  (or nothing). The title still leads — the subtitle is muted. */
-    setSubtitle(s: string | null): void;
-    /** Explicit interaction-mode chip override (compose/react). When set it WINS
-     *  the title state chip over the derived state, rendering the mode word in the
-     *  compose accent (yellow `33` bold) with the `✎` glyph (`react` → `☺`), so
-     *  entering an input mode is unmistakable. `null` returns to derived behavior. */
-    setMode(mode: string | null): void;
-}
-export type ViewAction = {
-    type: 'render';
-} | {
-    type: 'refresh';
-} | {
-    type: 'quit';
-} | {
-    type: 'none';
-};
-export interface ViewKey {
-    input: string;
-    key: Key;
-}
-export interface ViewModule<S = unknown> {
-    manifest: ViewManifest;
-    /** Build initial state. CHEAP + synchronous-ish — no screen, no slow fetch.
-     *  Slow data loads on the first refresh() so the host can paint a loading state. */
-    init(host: ViewHost): S | Promise<S>;
-    /** Fetch/poll. Mutates state in place. Host calls it on launch, on `refreshMs`,
-     *  and whenever a hook returns { type:'refresh' }. The host runs it in the
-     *  single-flight lane (busy indicator; never re-entrant). */
-    refresh?(state: S, host: ViewHost): Promise<void>;
-    /** Paint the view into `content` (the body rect, host chrome excluded).
-     *  Pure: reads state, calls draw.*; returns nothing. NEVER writes ANSI. */
-    render(state: S, draw: Draw, content: Rect): void;
-    /** Handle one keystroke. Mutates state; returns the next action. May be async
-     *  (open thread / send) — the host serializes async hooks in the single lane. */
-    onKey?(k: ViewKey, state: S, host: ViewHost): ViewAction | Promise<ViewAction>;
-    /** Static text for the non-TTY / piped path (exit 0). Snapshot of current
-     *  state. The host threads its current banner via the optional `ctx` so a view
-     *  can surface guidance without mirroring it into state (older views ignore the
-     *  arg and read their own state). */
-    dump(state: S, ctx?: DumpContext): string;
-}

package/dist/core/tui/contract.js

@@ -1,8 +0,0 @@
-// contract.ts — the view contract every `crtr view` module implements.
-//
-// A view is a self-contained ESM module whose DEFAULT export is a `ViewModule`.
-// State is a single mutable object the view owns (mirrors browse/app.ts's
-// BrowseState); hooks mutate it in place and return a `ViewAction` telling the
-// host what to do next. The host injects `Draw` (from ./draw) + `ViewHost`; a
-// view imports NOTHING from crtr internals.
-export {};

package/dist/core/tui/loader.d.ts

@@ -1,16 +0,0 @@
-import type { ViewModule } from './contract.js';
-export interface ResolvedView {
-    id: string;
-    dir: string;
-    entry: string;
-    scope: 'project' | 'user' | 'builtin';
-}
-/** Scope search project→user→builtin; first hit wins. null if no view dir holds
- *  a `<name>/view.mjs`. */
-export declare function resolveView(name: string): ResolvedView | null;
-/** Enumerate every resolvable view across scopes (first scope wins per id) —
- *  backs `view list` / `view pick`. */
-export declare function listViews(): ResolvedView[];
-/** Dynamic-import a resolved view and validate it's a usable ViewModule. Throws
- *  a guided error (with the entry path) if the module is malformed. */
-export declare function loadView(r: ResolvedView): Promise<ViewModule>;

package/dist/core/tui/loader.js

@@ -1,94 +0,0 @@
-// loader.ts — resolve + dynamically import view modules across scopes.
-//
-// A view = a directory containing `view.mjs` (the entry). Resolution order in
-// resolveView, first hit wins: project → user → builtin (see scope.ts viewsDir).
-// loadView does a plain `import(pathToFileURL(entry).href)` — no transpile, no
-// bundle (the published binary is `node dist/cli.js` with no esbuild/tsx) — then
-// validates the module is a usable ViewModule, throwing a guided error if not.
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { viewsDir } from '../scope.js';
-const SCOPE_ORDER = ['project', 'user', 'builtin'];
-/** Scope search project→user→builtin; first hit wins. null if no view dir holds
- *  a `<name>/view.mjs`. */
-export function resolveView(name) {
-    for (const scope of SCOPE_ORDER) {
-        const root = viewsDir(scope);
-        if (!root)
-            continue;
-        const dir = join(root, name);
-        const entry = join(dir, 'view.mjs');
-        if (existsSync(entry))
-            return { id: name, dir, entry, scope };
-    }
-    return null;
-}
-/** Enumerate every resolvable view across scopes (first scope wins per id) —
- *  backs `view list` / `view pick`. */
-export function listViews() {
-    const seen = new Set();
-    const out = [];
-    for (const scope of SCOPE_ORDER) {
-        const root = viewsDir(scope);
-        if (!root || !existsSync(root))
-            continue;
-        let names;
-        try {
-            names = readdirSync(root);
-        }
-        catch {
-            continue;
-        }
-        for (const name of names.sort()) {
-            if (seen.has(name))
-                continue; // first scope wins
-            const dir = join(root, name);
-            let isDir = false;
-            try {
-                isDir = statSync(dir).isDirectory();
-            }
-            catch {
-                isDir = false;
-            }
-            if (!isDir)
-                continue;
-            const entry = join(dir, 'view.mjs');
-            if (!existsSync(entry))
-                continue;
-            seen.add(name);
-            out.push({ id: name, dir, entry, scope });
-        }
-    }
-    return out;
-}
-/** Dynamic-import a resolved view and validate it's a usable ViewModule. Throws
- *  a guided error (with the entry path) if the module is malformed. */
-export async function loadView(r) {
-    let mod;
-    try {
-        mod = (await import(pathToFileURL(r.entry).href));
-    }
-    catch (e) {
-        throw guided(r, `failed to import the module: ${e instanceof Error ? e.message : String(e)}`);
-    }
-    const candidate = (mod['default'] ?? mod['view']);
-    if (!candidate || typeof candidate !== 'object') {
-        throw guided(r, 'no default export (or named `view`) that is a ViewModule object');
-    }
-    const m = candidate.manifest;
-    if (!m || typeof m.id !== 'string' || typeof m.title !== 'string') {
-        throw guided(r, 'manifest.id and manifest.title must be strings');
-    }
-    if (typeof candidate.init !== 'function')
-        throw guided(r, 'init() is required');
-    if (typeof candidate.render !== 'function')
-        throw guided(r, 'render() is required');
-    if (typeof candidate.dump !== 'function')
-        throw guided(r, 'dump() is required');
-    return candidate;
-}
-function guided(r, problem) {
-    return new Error(`invalid view "${r.id}" (${r.scope}) at ${r.entry}: ${problem}.\n` +
-        'A view.mjs must `export default` a ViewModule with { manifest: { id, title }, init(), render(), dump() }.');
-}

package/dist/prompts/skill.d.ts

@@ -1,2 +0,0 @@
-export declare function skillCreatePrompt(topic: string): string;
-export declare function skillTemplatePrompt(type: string, topic: string): string;