becki 0.5.0

package/dist/commands.js

@@ -0,0 +1,321 @@
+/**
+ * commands.ts — becki subcommands: ask / loops / save / resolve.
+ *
+ * These are one-shot vault operations: `becki ask "..."`, `becki loops`,
+ * `becki save "..."`, `becki resolve <row_id>`. They print plain text and
+ * exit — no Ink, no splash, no CLI handoff. The interactive splash stays the
+ * job of the bare `becki` command.
+ *
+ * Chunk 1a: auth comes from the local Becki.app install (resolveAuth). A Mac
+ * that has never run Becki.app gets a clear "not registered" message rather
+ * than a cryptic failure.
+ */
+import React from 'react';
+import { render } from 'ink';
+import { resolveAuth, query, listLoops, save, resolve, getBriefing, listProjects, SOURCE_TYPES, } from './client.js';
+import { LoopsApp } from './loops.js';
+/** Subcommands that route here instead of the splash/launcher path. */
+export const COMMANDS = [
+    'ask',
+    'loops',
+    'save',
+    'resolve',
+    'brief',
+    'projects',
+];
+export function isCommand(s) {
+    return !!s && COMMANDS.includes(s);
+}
+// --- tiny output helpers ----------------------------------------------
+const useColor = process.stdout.isTTY === true;
+const gold = (s) => (useColor ? `\x1b[38;5;179m${s}\x1b[0m` : s);
+const dim = (s) => (useColor ? `\x1b[2m${s}\x1b[0m` : s);
+const bold = (s) => (useColor ? `\x1b[1m${s}\x1b[0m` : s);
+function errln(s) {
+    process.stderr.write(s + '\n');
+}
+function notRegistered() {
+    errln('becki: not registered on this Mac.');
+    errln("  becki's subcommands use Becki.app's vault credentials");
+    errln('  (~/Library/Application Support/Becki/mcp-user-id).');
+    errln('  Open Becki.app and sign in once, then retry.');
+    return 1;
+}
+function firstLine(s) {
+    const line = (s.split('\n').find((l) => l.trim() !== '') ?? s).trim();
+    return line.length > 88 ? line.slice(0, 87) + '…' : line;
+}
+function clip(s, max) {
+    const t = s.trim();
+    return t.length > max ? t.slice(0, max - 1).trimEnd() + '…' : t;
+}
+function indent(s) {
+    return s
+        .split('\n')
+        .map((l) => '  ' + l)
+        .join('\n');
+}
+function clampInt(v, def, lo, hi) {
+    const n = typeof v === 'string' ? parseInt(v, 10) : NaN;
+    if (!Number.isFinite(n))
+        return def;
+    return Math.min(hi, Math.max(lo, n));
+}
+function ago(iso) {
+    const ms = Date.now() - new Date(iso).getTime();
+    if (!Number.isFinite(ms))
+        return '';
+    const d = Math.floor(ms / 86_400_000);
+    if (d <= 0)
+        return 'today';
+    if (d < 30)
+        return `${d}d ago`;
+    const mo = Math.floor(d / 30);
+    return mo < 12 ? `${mo}mo ago` : `${Math.floor(mo / 12)}y ago`;
+}
+/**
+ * Minimal flag parser. `valueFlags` take the next token as their value;
+ * everything else `--flag` is a boolean; bare tokens are positional.
+ */
+function parseArgs(args, valueFlags) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.startsWith('--')) {
+            const key = a.slice(2);
+            if (valueFlags.includes(key))
+                flags[key] = args[++i] ?? '';
+            else
+                flags[key] = true;
+        }
+        else {
+            positional.push(a);
+        }
+    }
+    return { positional, flags };
+}
+// --- commands ----------------------------------------------------------
+/** becki ask "<query>" [--limit N] [--json] */
+async function cmdAsk(args, auth) {
+    const { positional, flags } = parseArgs(args, ['limit']);
+    const q = positional.join(' ').trim();
+    if (!q) {
+        errln('usage: becki ask "<query>" [--limit N] [--json]');
+        return 2;
+    }
+    if (!auth.userId)
+        return notRegistered();
+    const limit = clampInt(flags.limit, 8, 1, 30);
+    const chunks = await query(auth.userId, q, limit);
+    if (flags.json) {
+        process.stdout.write(JSON.stringify(chunks, null, 2) + '\n');
+        return 0;
+    }
+    if (chunks.length === 0) {
+        console.log(dim('no matches.'));
+        return 0;
+    }
+    for (const c of chunks) {
+        const pct = Math.round(c.similarity * 100);
+        const project = c.metadata?.project_name ? `  ·  ${c.metadata.project_name}` : '';
+        console.log(gold(`◆ ${c.source_type}`) + dim(`   ${pct}% match${project}`));
+        if (c.id)
+            console.log(dim(`  ${c.id}`));
+        console.log(indent(clip(c.content, 600)));
+        console.log('');
+    }
+    return 0;
+}
+/** Render the interactive open-threads manager; resolves with exit code 0. */
+function runLoopsInteractive(userId) {
+    return new Promise((res) => {
+        const app = render(React.createElement(LoopsApp, {
+            userId,
+            onExit: () => app.unmount(),
+        }));
+        app.waitUntilExit().then(() => res(0));
+    });
+}
+/** becki loops [--limit N] [--json] */
+async function cmdLoops(args, auth) {
+    const { flags } = parseArgs(args, ['limit']);
+    if (!auth.userId)
+        return notRegistered();
+    // Interactive manager when attached to a TTY; plain text for --json or
+    // when piped (so `becki loops | …` stays scriptable).
+    if (!flags.json && process.stdout.isTTY === true) {
+        return runLoopsInteractive(auth.userId);
+    }
+    const limit = clampInt(flags.limit, 20, 1, 100);
+    const rows = await listLoops(auth.userId, limit);
+    if (flags.json) {
+        process.stdout.write(JSON.stringify(rows, null, 2) + '\n');
+        return 0;
+    }
+    if (rows.length === 0) {
+        console.log(dim('no open threads — clear slate.'));
+        return 0;
+    }
+    console.log(bold(`${rows.length} open thread${rows.length === 1 ? '' : 's'}`));
+    console.log('');
+    rows.forEach((r, i) => {
+        console.log(`${gold(String(i + 1).padStart(2))}  ${firstLine(r.content)}`);
+        console.log(dim(`    ${r.id}  ·  ${ago(r.created_at)}`));
+    });
+    return 0;
+}
+/** becki save "<text>" [--type T] [--title T] [--project P] */
+async function cmdSave(args, auth) {
+    const { positional, flags } = parseArgs(args, ['type', 'title', 'project']);
+    const content = positional.join(' ').trim();
+    if (!content) {
+        errln('usage: becki save "<text>" [--type decision|commitment|note|open_loop|dead_end] [--title T] [--project P]');
+        return 2;
+    }
+    if (!auth.ingestToken) {
+        errln('becki: no ingest token — open Becki.app and sign in once to enable saving.');
+        return 1;
+    }
+    const type = String(flags.type ?? 'note');
+    if (!SOURCE_TYPES.includes(type)) {
+        errln(`becki: --type must be one of: ${SOURCE_TYPES.join(', ')}`);
+        return 2;
+    }
+    const result = await save(auth.ingestToken, {
+        type: type,
+        content,
+        title: flags.title ? String(flags.title) : undefined,
+        project: flags.project ? String(flags.project) : undefined,
+    });
+    console.log(gold('saved') + ` ${type}` + (result.vault_id ? dim(`  ·  ${result.vault_id}`) : ''));
+    return 0;
+}
+/** becki resolve <row_id> [--note "<reason>"] */
+async function cmdResolve(args, auth) {
+    const { positional, flags } = parseArgs(args, ['note']);
+    const rowId = positional[0];
+    if (!rowId) {
+        errln('usage: becki resolve <row_id> [--note "<reason>"]');
+        return 2;
+    }
+    if (!auth.userId)
+        return notRegistered();
+    await resolve(auth.userId, rowId, flags.note ? String(flags.note) : undefined);
+    console.log(gold('resolved') + ` ${rowId}`);
+    return 0;
+}
+/** Render one briefing item — defensive across the varying section kinds. */
+function renderBriefItem(item) {
+    if (typeof item === 'string') {
+        console.log('  ' + firstLine(item));
+        return;
+    }
+    if (item == null || typeof item !== 'object')
+        return;
+    const o = item;
+    // meeting_context item — a calendar event with related vault chunks.
+    if (typeof o.event_title === 'string') {
+        console.log('  ' + bold(o.event_title));
+        const chunks = Array.isArray(o.chunks) ? o.chunks : [];
+        for (const c of chunks) {
+            const preview = c?.preview;
+            if (typeof preview === 'string') {
+                console.log(dim('    ' + firstLine(preview)));
+            }
+        }
+        return;
+    }
+    // chunk-like item.
+    if (typeof o.preview === 'string') {
+        console.log(dim('  ' + firstLine(o.preview)));
+        return;
+    }
+    // generic fallback — first stringy field.
+    const text = o.title ?? o.content ?? o.text ?? o.summary;
+    if (typeof text === 'string')
+        console.log('  ' + firstLine(text));
+}
+/** becki brief [--json] */
+async function cmdBrief(args, auth) {
+    const { flags } = parseArgs(args, []);
+    if (!auth.userId)
+        return notRegistered();
+    const briefing = await getBriefing(auth.userId);
+    if (flags.json) {
+        process.stdout.write(JSON.stringify(briefing, null, 2) + '\n');
+        return 0;
+    }
+    if (!briefing) {
+        console.log(dim('no briefing computed yet.'));
+        return 0;
+    }
+    console.log(bold('briefing') + dim(`  ${briefing.brief_date}`));
+    for (const section of briefing.sections ?? []) {
+        console.log('');
+        console.log(gold(section.title ?? section.kind));
+        const items = Array.isArray(section.items) ? section.items : [];
+        if (items.length === 0) {
+            console.log(dim('  (nothing)'));
+            continue;
+        }
+        for (const item of items)
+            renderBriefItem(item);
+    }
+    return 0;
+}
+/** becki projects [--json] */
+async function cmdProjects(args, auth) {
+    const { flags } = parseArgs(args, []);
+    if (!auth.userId)
+        return notRegistered();
+    const projects = await listProjects(auth.userId);
+    if (flags.json) {
+        process.stdout.write(JSON.stringify(projects, null, 2) + '\n');
+        return 0;
+    }
+    if (projects.length === 0) {
+        console.log(dim('no projects yet.'));
+        return 0;
+    }
+    const sorted = [...projects].sort((a, b) => (b.atomic_count ?? 0) - (a.atomic_count ?? 0));
+    console.log(bold(`${sorted.length} project${sorted.length === 1 ? '' : 's'}`));
+    console.log('');
+    for (const p of sorted) {
+        const count = (p.atomic_count != null ? String(p.atomic_count) : '·').padStart(4);
+        const recent = p.most_recent_at ? dim(`  ${ago(p.most_recent_at)}`) : '';
+        const dormant = p.is_dormant ? dim('  · dormant') : '';
+        console.log(`  ${gold(count)}  ${p.name}${recent}${dormant}`);
+    }
+    return 0;
+}
+/**
+ * Run a subcommand. Resolves auth once, dispatches, and turns any thrown
+ * error into a clean one-line stderr message + exit code 1.
+ */
+export async function runCommand(name, args) {
+    const auth = resolveAuth();
+    try {
+        switch (name) {
+            case 'ask':
+                return await cmdAsk(args, auth);
+            case 'loops':
+                return await cmdLoops(args, auth);
+            case 'save':
+                return await cmdSave(args, auth);
+            case 'resolve':
+                return await cmdResolve(args, auth);
+            case 'brief':
+                return await cmdBrief(args, auth);
+            case 'projects':
+                return await cmdProjects(args, auth);
+            default:
+                errln(`becki: unknown command "${name}"`);
+                return 2;
+        }
+    }
+    catch (err) {
+        errln(`becki: ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+}

package/dist/config.js

@@ -0,0 +1,138 @@
+/**
+ * config.ts — load / create / validate ~/.becki/config.json
+ *
+ * The config file is auto-created with defaults on first run. Validation is
+ * forgiving by design: a malformed or partial config never blocks the CLI
+ * handoff — bad keys fall back to defaults and a warning is collected.
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { accessSync, constants, existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
+export const DEFAULT_CONFIG = {
+    cli: 'claude',
+    vault_path: '~/Documents/Becki',
+    show_open_threads: true,
+    max_open_threads: 5,
+    skip_prompt: false,
+    pass_focus_to_cli: true,
+};
+/** AI CLIs becki offers on the first-run picker, in display order. */
+export const KNOWN_CLIS = ['claude', 'codex', 'gemini', 'opencode'];
+export const CONFIG_DIR = join(homedir(), '.becki');
+export const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+/** Expand a leading ~ to the user's home directory. */
+export function expandHome(p) {
+    if (p === '~')
+        return homedir();
+    if (p.startsWith('~/'))
+        return join(homedir(), p.slice(2));
+    return p;
+}
+/**
+ * Coerce an unknown parsed JSON object into a valid BeckiConfig.
+ * Any key that is missing or the wrong type falls back to its default and
+ * appends a warning. This is what keeps a hand-edited config from crashing
+ * the launcher.
+ */
+function validate(raw, warnings) {
+    const out = { ...DEFAULT_CONFIG };
+    if (raw === null || typeof raw !== 'object') {
+        warnings.push('config.json is not a JSON object — using defaults');
+        return out;
+    }
+    const obj = raw;
+    const str = (key) => {
+        const v = obj[key];
+        if (v === undefined)
+            return;
+        if (typeof v === 'string' && v.trim() !== '') {
+            out[key] = v;
+        }
+        else {
+            warnings.push(`config: "${key}" must be a non-empty string — using default`);
+        }
+    };
+    const bool = (key) => {
+        const v = obj[key];
+        if (v === undefined)
+            return;
+        if (typeof v === 'boolean') {
+            out[key] = v;
+        }
+        else {
+            warnings.push(`config: "${key}" must be true/false — using default`);
+        }
+    };
+    str('cli');
+    str('vault_path');
+    bool('show_open_threads');
+    bool('skip_prompt');
+    bool('pass_focus_to_cli');
+    const max = obj['max_open_threads'];
+    if (max !== undefined) {
+        if (typeof max === 'number' && Number.isFinite(max) && max > 0) {
+            out.max_open_threads = Math.floor(max);
+        }
+        else {
+            warnings.push('config: "max_open_threads" must be a positive number — using default');
+        }
+    }
+    return out;
+}
+/** True when `cmd` resolves to an executable on the user's PATH. */
+export function isOnPath(cmd) {
+    const dirs = (process.env.PATH ?? '').split(':').filter(Boolean);
+    for (const dir of dirs) {
+        try {
+            accessSync(join(dir, cmd), constants.X_OK);
+            return true;
+        }
+        catch {
+            // not in this dir — keep looking
+        }
+    }
+    return false;
+}
+/** Which of the known AI CLIs are installed on PATH right now. */
+export function detectClis() {
+    return KNOWN_CLIS.filter(isOnPath);
+}
+/**
+ * Write the config to disk. Never throws — returns a warning string on
+ * failure, or null on success. Used by the first-run flow once the CLI
+ * picker has resolved.
+ */
+export function persistConfig(config) {
+    try {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+        writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf8');
+        return null;
+    }
+    catch (err) {
+        return `could not save ${CONFIG_PATH} (${err.message})`;
+    }
+}
+/**
+ * Load the config. Never throws — filesystem failures degrade to in-memory
+ * defaults plus a warning, so the launcher always proceeds.
+ *
+ * On first run the file does NOT exist yet: this returns the defaults flagged
+ * `created: true` WITHOUT writing anything. The caller runs the first-run CLI
+ * picker and then persists via persistConfig() — so a Ctrl-C during setup
+ * leaves no config and the picker shows again next run.
+ */
+export function loadConfig() {
+    const warnings = [];
+    if (!existsSync(CONFIG_PATH)) {
+        return { config: { ...DEFAULT_CONFIG }, created: true, warnings };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(CONFIG_PATH, 'utf8'));
+    }
+    catch (err) {
+        warnings.push(`config.json is unreadable or malformed (${err.message}) — using defaults`);
+        return { config: { ...DEFAULT_CONFIG }, created: false, warnings };
+    }
+    return { config: validate(parsed, warnings), created: false, warnings };
+}

package/dist/entry.js

@@ -0,0 +1,14 @@
+/**
+ * entry.ts — the single-file bundle entry point.
+ *
+ * esbuild bundles this (with all of src/ + node_modules) into one
+ * self-contained bundle/becki.js, which Becki.app embeds in its Resources and
+ * runs with its bundled node binary. The npm-link / dev path is unchanged —
+ * it still goes through bin/becki.js → dist/cli.js.
+ */
+import { main } from './cli.js';
+main().catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`becki: unexpected error — ${msg}\n`);
+    process.exit(1);
+});

package/dist/handoff.js

@@ -0,0 +1,54 @@
+/**
+ * handoff.ts — spawn the configured AI CLI, inherit the TTY, propagate exit.
+ *
+ * This is the launcher's whole reason to exist. It injects nothing into the
+ * CLI's context pipeline — the focus is passed only as the CLI's first
+ * positional prompt arg (Claude Code reads that as its opening prompt).
+ */
+import { spawn } from 'node:child_process';
+/**
+ * Build the argv for the CLI.
+ * Focus goes first (only when typed AND pass_focus_to_cli is on), then any
+ * args the user appended after `becki` (so `becki --resume` flows through).
+ */
+export function buildArgs(config, focus, passthroughArgs) {
+    const focusArgs = focus && focus.trim() !== '' && config.pass_focus_to_cli ? [focus.trim()] : [];
+    return [...focusArgs, ...passthroughArgs];
+}
+/**
+ * Spawn the CLI and resolve once it exits.
+ *
+ * Resolves (never rejects) so the caller controls the process exit. A missing
+ * CLI binary is the one "fail loudly" case in the spec — it resolves with a
+ * spawnError and a non-zero exit code rather than launching nothing silently.
+ */
+export function handoff(config, focus, passthroughArgs) {
+    const args = buildArgs(config, focus, passthroughArgs);
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(config.cli, args, { stdio: 'inherit' });
+        }
+        catch (err) {
+            resolve({ args, exitCode: 127, spawnError: err.message });
+            return;
+        }
+        child.on('error', (err) => {
+            const e = err;
+            const msg = e.code === 'ENOENT'
+                ? `command not found: "${config.cli}" — set "cli" in ~/.becki/config.json`
+                : e.message;
+            resolve({ args, exitCode: 127, spawnError: msg });
+        });
+        child.on('exit', (code, signal) => {
+            // A signal-terminated child has code === null; map to the conventional
+            // 128 + signal-number exit status.
+            if (code === null && signal) {
+                const sigNum = { SIGINT: 2, SIGTERM: 15, SIGKILL: 9 };
+                resolve({ args, exitCode: 128 + (sigNum[signal] ?? 0) });
+                return;
+            }
+            resolve({ args, exitCode: code ?? 0 });
+        });
+    });
+}

package/dist/loops.js

@@ -0,0 +1,127 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * loops.tsx — interactive open-threads manager.
+ *
+ * Opened by `becki loops` in a TTY, or by Ctrl+L from the splash. Shows the
+ * cloud open_loop rows — arrow-navigable, with in-place view + resolve.
+ *
+ * Why this, and not the splash itself: the splash's threads come from the
+ * local _meta/open-loops.md file and carry no row IDs, so they can't be
+ * resolved against the vault. These rows come from list_vault_rows — every
+ * one has its real row_id, so `r` actually closes the loop in the cloud.
+ *
+ * There is no free-text input here, so plain keys (r / v / q) are unambiguous.
+ */
+import { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { theme } from './theme.js';
+import { listLoops, resolve } from './client.js';
+/** First non-empty line of a row's content, capped. */
+function firstLine(s) {
+    const line = (s.split('\n').find((l) => l.trim() !== '') ?? s).trim();
+    return line.length > 64 ? line.slice(0, 63) + '…' : line;
+}
+/** Trim content to a max length for the expanded view. */
+function clip(s, max) {
+    const t = s.trim();
+    return t.length > max ? t.slice(0, max - 1).trimEnd() + '…' : t;
+}
+export function LoopsApp({ userId, onExit }) {
+    const [rows, setRows] = useState(null);
+    const [loadError, setLoadError] = useState(null);
+    const [highlight, setHighlight] = useState(0);
+    const [expanded, setExpanded] = useState(false);
+    const [confirming, setConfirming] = useState(false);
+    const [rowState, setRowState] = useState({});
+    const [rowError, setRowError] = useState({});
+    useEffect(() => {
+        let alive = true;
+        listLoops(userId, 50)
+            .then((r) => {
+            if (alive)
+                setRows(r);
+        })
+            .catch((e) => {
+            if (alive)
+                setLoadError(e instanceof Error ? e.message : String(e));
+        });
+        return () => {
+            alive = false;
+        };
+    }, [userId]);
+    const doResolve = (row) => {
+        setRowState((s) => ({ ...s, [row.id]: 'resolving' }));
+        resolve(userId, row.id)
+            .then(() => setRowState((s) => ({ ...s, [row.id]: 'resolved' })))
+            .catch((e) => {
+            setRowState((s) => ({ ...s, [row.id]: 'error' }));
+            setRowError((m) => ({
+                ...m,
+                [row.id]: e instanceof Error ? e.message : String(e),
+            }));
+        });
+    };
+    useInput((input, key) => {
+        // Resolve confirmation intercepts everything until answered.
+        if (confirming) {
+            if (input === 'y' && rows && rows.length > 0)
+                doResolve(rows[highlight]);
+            setConfirming(false);
+            return;
+        }
+        if (key.escape || input === 'q') {
+            onExit();
+            return;
+        }
+        if (!rows || rows.length === 0)
+            return;
+        if (key.upArrow) {
+            setExpanded(false);
+            setHighlight((h) => (h <= 0 ? rows.length - 1 : h - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setExpanded(false);
+            setHighlight((h) => (h >= rows.length - 1 ? 0 : h + 1));
+            return;
+        }
+        if (/^[1-9]$/.test(input)) {
+            const idx = Number(input) - 1;
+            if (idx < rows.length) {
+                setExpanded(false);
+                setHighlight(idx);
+            }
+            return;
+        }
+        if (input === 'v' || input === ' ' || key.return) {
+            setExpanded((e) => !e);
+            return;
+        }
+        if (input === 'r') {
+            const st = rowState[rows[highlight].id] ?? 'open';
+            if (st === 'open' || st === 'error')
+                setConfirming(true);
+            return;
+        }
+    });
+    // --- render ------------------------------------------------------------
+    if (loadError) {
+        return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Text, { color: theme.gold, bold: true, children: ["\u25C6 becki ", _jsx(Text, { color: theme.gray, bold: false, children: "\u00B7 open threads" })] }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: theme.gray, children: ["could not load loops: ", loadError] }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.gray, children: "q to exit" }) })] }));
+    }
+    if (!rows) {
+        return (_jsx(Box, { paddingX: 2, paddingY: 1, children: _jsx(Text, { color: theme.gray, children: "loading open threads\u2026" }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Text, { color: theme.gold, bold: true, children: ["\u25C6 becki", ' ', _jsxs(Text, { color: theme.gray, bold: false, children: ["\u00B7 open threads (", rows.length, ")"] })] }), rows.length === 0 ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.gray, children: "no open threads \u2014 clear slate." }) })) : (_jsx(Box, { flexDirection: "column", marginTop: 1, children: rows.map((row, i) => {
+                    const hl = i === highlight;
+                    const st = rowState[row.id] ?? 'open';
+                    const tag = st === 'resolved'
+                        ? '  ✓ resolved'
+                        : st === 'resolving'
+                            ? '  resolving…'
+                            : st === 'error'
+                                ? '  ✗ failed'
+                                : '';
+                    const titleColor = st === 'resolved' ? theme.gray : hl ? theme.gold : theme.text;
+                    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: hl ? theme.gold : theme.gray, children: String(i + 1).padStart(2, ' ') }), _jsx(Text, { color: hl ? theme.gold : theme.gray, children: hl ? ' ▸ ' : ' · ' }), _jsx(Box, { width: 62, children: _jsx(Text, { color: titleColor, bold: hl, strikethrough: st === 'resolved', wrap: "truncate-end", children: firstLine(row.content) }) }), _jsx(Text, { color: theme.gray, children: tag })] }), hl && expanded ? (_jsx(Box, { marginLeft: 5, marginTop: 1, marginBottom: 1, width: 74, children: _jsx(Text, { color: theme.gray, children: clip(row.content, 800) }) })) : null, hl && st === 'error' && rowError[row.id] ? (_jsx(Box, { marginLeft: 5, children: _jsx(Text, { color: theme.gold, children: rowError[row.id] }) })) : null] }, row.id));
+                }) })), _jsx(Box, { marginTop: 1, children: confirming && rows.length > 0 ? (_jsxs(Text, { color: theme.gold, children: ["resolve \u201C", firstLine(rows[highlight].content), "\u201D?", '  ', _jsx(Text, { color: theme.gray, children: "y to confirm \u00B7 any key cancels" })] })) : rows.length === 0 ? (_jsx(Text, { color: theme.gray, children: "q to exit" })) : (_jsx(Text, { color: theme.gray, children: "\u2191\u2193 move \u00B7 1-9 jump \u00B7 v view \u00B7 r resolve \u00B7 q back" })) })] }));
+}