@scira/cli 0.1.8 → 0.1.9

package/dist/cli/commands/watch.js

@@ -0,0 +1,196 @@
+import { readFile, rm } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { loadConfig } from "../../config/load-config.js";
+import { requireLlmKeys } from "../../providers/llm/registry.js";
+import { watchLoop } from "../../watch/runner.js";
+import { loadWatches, addWatch, removeWatch, findWatch, nextWatchId } from "../../watch/store.js";
+import { isDue, nextRunAt } from "../../watch/scheduler.js";
+import { DAEMON_LOG_FILE, DAEMON_PID_FILE, isProcessRunning, readLock } from "../../watch/daemon-lock.js";
+const FREQUENCIES = ["day", "weekday", "week"];
+const INTERVALS = { hourly: 60 * 60 * 1000, daily: 24 * 60 * 60 * 1000, weekly: 7 * 24 * 60 * 60 * 1000 };
+/** Entry point for `scira watch <goal>`: foreground loop, or persisted schedule with -b. */
+export async function watchCommand(goal, opts) {
+    if (opts.background || opts.b) {
+        await watchBackground(goal, opts);
+    }
+    else {
+        await watchForeground(goal, opts);
+    }
+}
+// --- Foreground: interval loop tied to this terminal ---------------------
+async function watchForeground(goal, opts) {
+    const config = await loadConfig();
+    requireLlmKeys(config);
+    const intervalMs = opts.interval
+        ? Number.parseInt(String(opts.interval), 10)
+        : opts.hourly ? INTERVALS.hourly
+            : opts.weekly ? INTERVALS.weekly
+                : INTERVALS.daily;
+    if (Number.isNaN(intervalMs) || intervalMs < 1000) {
+        throw new Error("Interval must be at least 1000 ms.");
+    }
+    const maxRuns = opts.runs != null ? Number.parseInt(String(opts.runs), 10) : undefined;
+    const controller = new AbortController();
+    process.on("SIGINT", () => { console.log("\nStopping watch…"); controller.abort(); });
+    process.on("SIGTERM", () => controller.abort());
+    console.log(`Watching: "${goal}"`);
+    console.log(`Interval: ${intervalMs / 1000}s${maxRuns ? ` · max ${maxRuns} runs` : ""}`);
+    console.log("Press Ctrl-C to stop.  (Tip: -b runs this in the background instead.)\n");
+    await watchLoop({
+        goal, intervalMs, maxRuns, config,
+        onRunStart: (runPath, tick) => { console.log(`\n[run ${tick + 1}] Starting → ${runPath}`); },
+        onRunComplete: (_runPath, diff, tick) => { console.log(`[run ${tick + 1}] Done.\n${diff.text}`); },
+        onError: (err, tick) => { console.error(`[run ${tick + 1}] Error: ${err.message}`); }
+    }, controller.signal);
+    console.log("Watch finished.");
+}
+// --- Background: persist a scheduled watch, run by the daemon -------------
+async function watchBackground(goal, opts) {
+    const at = opts.at ?? "09:00";
+    const every = opts.every ?? "day";
+    // Reject impossible times: a bare \d{2}:\d{2} would accept 25:61, which
+    // Date.setHours silently rolls over into the wrong day.
+    if (!/^([01]\d|2[0-3]):[0-5]\d$/u.test(at)) {
+        throw new Error(`--at must be a valid HH:MM 24h time, 00:00–23:59 (got: ${at})`);
+    }
+    if (!FREQUENCIES.includes(every)) {
+        throw new Error(`--every must be one of: ${FREQUENCIES.join(", ")} (got: ${every})`);
+    }
+    const config = await loadConfig();
+    requireLlmKeys(config); // fail now, not on the first silent background run
+    const projectRoot = process.cwd();
+    const existing = await loadWatches();
+    // Don't create duplicates: an identical goal+schedule+project already covers it.
+    const duplicate = existing.find((w) => w.goal === goal && w.projectRoot === projectRoot && w.frequency === every && w.atHHMM === at);
+    if (duplicate) {
+        console.log(`Already scheduled as "${duplicate.name}" (${duplicate.id}) — runs ${every} at ${at}.`);
+        await printSchedulerHint();
+        return;
+    }
+    const id = nextWatchId(existing);
+    const name = opts.name ?? id;
+    const watch = {
+        id,
+        name,
+        goal,
+        projectRoot,
+        frequency: every,
+        atHHMM: at,
+        createdAt: new Date().toISOString(),
+        lastRunAt: null,
+        enabled: true
+    };
+    await addWatch(watch);
+    console.log(`Scheduled watch "${name}" (${id}) — runs ${every} at ${at}`);
+    console.log(`Goal: ${goal}`);
+    console.log("");
+    await printSchedulerHint();
+}
+/** Tell the user whether the scheduler is up (without starting it — that's an explicit action). */
+async function printSchedulerHint() {
+    const lock = await readLock();
+    if (lock && isProcessRunning(lock.pid)) {
+        console.log(`Scheduler is running (pid ${lock.pid}); it will pick this up on the next tick.`);
+    }
+    else {
+        console.log(`Start the scheduler to run it: scira watch start`);
+    }
+}
+// --- Management ----------------------------------------------------------
+export async function watchList() {
+    const watches = await loadWatches();
+    if (watches.length === 0) {
+        console.log("No scheduled watches. Create one with: scira watch <goal> --background");
+        return;
+    }
+    const now = new Date();
+    for (const w of watches) {
+        const when = isDue(w, now) ? "due now" : `next: ${nextRunAt(w, now).toLocaleString()}`;
+        const status = w.enabled ? "enabled" : "disabled";
+        console.log(`${w.id}  "${w.name}"  ${w.frequency}@${w.atHHMM}  [${status}]  ${when}`);
+        console.log(`  goal: ${w.goal.slice(0, 80)}`);
+    }
+}
+export async function watchRemove(idOrName) {
+    const w = await findWatch(idOrName);
+    if (!w)
+        throw new Error(`Watch not found: ${idOrName}`);
+    await removeWatch(w.id);
+    console.log(`Removed watch "${w.name}" (${w.id})`);
+}
+// --- Daemon control ------------------------------------------------------
+export async function daemonStart() {
+    const lock = await readLock();
+    if (lock && isProcessRunning(lock.pid)) {
+        console.log(`Scheduler already running (pid ${lock.pid})`);
+        return;
+    }
+    // Resolve the daemon script next to this command's compiled output. tsc emits
+    // per-file, so dist/cli/commands/watch.js → dist/watch/daemon.js; in dev
+    // (bun src/...) the .ts mirror resolves the same way.
+    const thisFile = fileURLToPath(import.meta.url);
+    const ext = thisFile.endsWith(".ts") ? ".ts" : ".js";
+    const daemonScript = join(dirname(thisFile), "..", "..", "watch", `daemon${ext}`);
+    const bunExe = Bun.which("bun") ?? "bun";
+    const child = spawn(bunExe, [daemonScript], { detached: true, stdio: "ignore" });
+    child.unref();
+    // Give the daemon a beat to claim its PID lock before we report status.
+    await Bun.sleep(600);
+    const fresh = await readLock();
+    if (fresh && isProcessRunning(fresh.pid)) {
+        console.log(`Scheduler started (pid ${fresh.pid})`);
+        console.log(`Log: ${DAEMON_LOG_FILE}`);
+    }
+    else {
+        console.log(`Scheduler may have failed to start. Check: ${DAEMON_LOG_FILE}`);
+    }
+}
+export async function daemonStop() {
+    const lock = await readLock();
+    if (!lock) {
+        console.log("Scheduler not running.");
+        return;
+    }
+    if (!isProcessRunning(lock.pid)) {
+        await rm(DAEMON_PID_FILE, { force: true });
+        console.log("Scheduler not running (cleared stale pid file).");
+        return;
+    }
+    process.kill(lock.pid, "SIGTERM");
+    console.log(`Sent SIGTERM to scheduler (pid ${lock.pid})`);
+}
+export async function daemonStatus() {
+    const lock = await readLock();
+    if (!lock || !isProcessRunning(lock.pid)) {
+        console.log("Scheduler: not running");
+        console.log("Start with: scira watch start");
+        return;
+    }
+    const upSecs = Math.floor((Date.now() - new Date(lock.startedAt).getTime()) / 1000);
+    console.log(`Scheduler: running (pid ${lock.pid}, uptime ${upSecs}s)`);
+    console.log(`Log: ${DAEMON_LOG_FILE}`);
+    try {
+        const tail = (await readFile(DAEMON_LOG_FILE, "utf8")).trim().split("\n").filter(Boolean).slice(-10);
+        if (tail.length > 0) {
+            console.log("\nLast log lines:");
+            for (const line of tail)
+                console.log(`  ${line}`);
+        }
+    }
+    catch {
+        /* no log yet */
+    }
+    const enabled = (await loadWatches()).filter((w) => w.enabled);
+    if (enabled.length === 0) {
+        console.log("\nNo scheduled watches. Use: scira watch <goal> --background");
+        return;
+    }
+    console.log("\nScheduled watches:");
+    const now = new Date();
+    for (const w of enabled) {
+        const when = isDue(w, now) ? "due now" : nextRunAt(w, now).toLocaleString();
+        console.log(`  ${w.name}  ${w.frequency}@${w.atHHMM}  next: ${when}`);
+    }
+}

package/dist/cli/index.js

@@ -30,6 +30,7 @@ import { saveGlobalMcpConfig } from "../config/load-config.js";
 import { runOAuthFlow } from "../tools/mcp-oauth.js";
 import { initCommand } from "./commands/init.js";
 import { checkForUpdate, formatUpdateNotice } from "../utils/update-check.js";
+import { checkWatchNotices, commitWatchNotices, formatWatchNotice } from "../utils/watch-notice.js";
 // Once per invocation (throttled to a real npm check at most daily): surface an
 // available update. The TUI shows it as an in-app notice; CLI commands print it.
 // Skip for --version/--help so those stay instant (the daily check can spend up
@@ -38,6 +39,12 @@ const argv = process.argv.slice(2);
 const wantsUpdateCheck = !argv.some((a) => ["-v", "--version", "-h", "--help"].includes(a));
 const update = wantsUpdateCheck ? await checkForUpdate(pkgVersion) : null;
 const updateNotice = update ? formatUpdateNotice(update) : undefined;
+// Unread results from background (--background) watches, surfaced as a banner
+// after the command finishes (mirrors the update-notice pattern above). We only
+// advance the read cursor once the banner has actually been printed (in the
+// finally block), so a crash mid-command can't silently mark results read.
+const watch = wantsUpdateCheck ? await checkWatchNotices() : { results: [], nextOffset: 0 };
+const watchNotice = watch.results.length > 0 ? formatWatchNotice(watch.results) : undefined;
 // The TUI renders the notice in-app, so the finally banner would double it up.
 let noticeShownInApp = false;
 const prog = sade("scira");
@@ -284,43 +291,57 @@ prog
     await saveGlobalMcpConfig(nextMcp);
     console.log(`Removed MCP server "${name}" from ~/.scira/config.json`);
 });
+// `watch` has two modes from one command:
+//   foreground (default) — interval loop tied to this terminal, prints diffs.
+//   --background          — persist the watch; the daemon re-runs it on a
+//                           day/weekday/week schedule at --at, even after the
+//                           terminal closes, with a desktop notification and a
+//                           banner on the next CLI invocation.
+// The management subcommands (list/remove/start/stop/status) drive the daemon.
 prog
-    .command("watch <goal>", "monitor a topic by running research on a schedule and diffing reports")
-    .option("--daily", "run once per day (default)")
-    .option("--hourly", "run once per hour")
-    .option("--weekly", "run once per week")
-    .option("--interval", "custom interval in milliseconds")
-    .option("--runs", "stop after N runs (default: run forever)")
+    .command("watch <goal>", "re-run research on a schedule and diff each report (add -b to run in the background)")
+    .option("--hourly", "foreground: run once per hour")
+    .option("--daily", "foreground: run once per day (default)")
+    .option("--weekly", "foreground: run once per week")
+    .option("--interval", "foreground: custom interval in milliseconds")
+    .option("--runs", "foreground: stop after N runs (default: run forever)")
+    .option("-b, --background", "persist as a scheduled watch run by the daemon")
+    .option("--every", "background: frequency — day | weekday | week", "day")
+    .option("--at", "background: time of day to run, HH:MM 24h", "09:00")
+    .option("--name", "background: human-readable label")
     .action(async (goal, opts) => {
-    const config = await loadConfig();
-    const INTERVALS = {
-        hourly: 60 * 60 * 1000,
-        daily: 24 * 60 * 60 * 1000,
-        weekly: 7 * 24 * 60 * 60 * 1000,
-    };
-    const intervalMs = opts.interval
-        ? parseInt(String(opts.interval), 10)
-        : opts.hourly ? INTERVALS.hourly
-            : opts.weekly ? INTERVALS.weekly
-                : INTERVALS.daily;
-    if (Number.isNaN(intervalMs) || intervalMs < 1000) {
-        throw new Error("Interval must be at least 1000 ms.");
-    }
-    const maxRuns = opts.runs != null ? parseInt(String(opts.runs), 10) : undefined;
-    const { watchLoop } = await import("../watch/runner.js");
-    const controller = new AbortController();
-    process.on("SIGINT", () => { console.log("\nStopping watch…"); controller.abort(); });
-    process.on("SIGTERM", () => { controller.abort(); });
-    console.log(`Watching: "${goal}"`);
-    console.log(`Interval: ${intervalMs / 1000}s${maxRuns ? ` · max ${maxRuns} runs` : ""}`);
-    console.log("Press Ctrl-C to stop.\n");
-    await watchLoop({
-        goal, intervalMs, maxRuns, config,
-        onRunStart: (runPath, tick) => { console.log(`\n[tick ${tick + 1}] Starting run → ${runPath}`); },
-        onRunComplete: (runPath, diffText, tick) => { console.log(`[tick ${tick + 1}] Done. Diff:\n${diffText}`); },
-        onError: (err, tick) => { console.error(`[tick ${tick + 1}] Error: ${err.message}`); },
-    }, controller.signal);
-    console.log("Watch finished.");
+    const { watchCommand } = await import("./commands/watch.js");
+    await watchCommand(goal, opts);
+});
+prog
+    .command("watch list", "list scheduled (background) watches and their next run times")
+    .action(async () => {
+    const { watchList } = await import("./commands/watch.js");
+    await watchList();
+});
+prog
+    .command("watch remove <id>", "remove a scheduled watch by id or name")
+    .action(async (id) => {
+    const { watchRemove } = await import("./commands/watch.js");
+    await watchRemove(id);
+});
+prog
+    .command("watch start", "start the background watch scheduler")
+    .action(async () => {
+    const { daemonStart } = await import("./commands/watch.js");
+    await daemonStart();
+});
+prog
+    .command("watch stop", "stop the background watch scheduler")
+    .action(async () => {
+    const { daemonStop } = await import("./commands/watch.js");
+    await daemonStop();
+});
+prog
+    .command("watch status", "show scheduler status and upcoming scheduled watches")
+    .action(async () => {
+    const { daemonStatus } = await import("./commands/watch.js");
+    await daemonStatus();
 });
 prog
     .command("models", "list models for the configured LLM provider")
@@ -512,4 +533,8 @@ finally {
     // rendered the notice in-app, so we don't show it twice.
     if (updateNotice && !noticeShownInApp)
         process.stderr.write(`\n\x1b[2m${updateNotice}\x1b[0m\n`);
+    if (watchNotice) {
+        process.stderr.write(`\n\x1b[36m${watchNotice}\x1b[0m\n`);
+        await commitWatchNotices(watch.nextOffset);
+    }
 }

package/dist/tools/background-tasks.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { mkdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import { isProcessRunning } from "../utils/process.js";
 const MAX_OUTPUT_LINES = 500;
 const MAX_TAIL_CHARS = 4000;
 function nextTaskId(existing) {
@@ -17,18 +18,6 @@ function tailText(lines, maxChars = MAX_TAIL_CHARS) {
         return joined;
     return `…[truncated]\n${joined.slice(-maxChars)}`;
 }
-/** Returns true if a process with this pid is still running. */
-function isProcessRunning(pid) {
-    if (pid <= 0)
-        return false;
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 function isValidRecord(t) {
     if (typeof t !== "object" || t === null)
         return false;

package/dist/types/index.js

@@ -104,3 +104,33 @@ export const ClaimSchema = z.object({
     reason: z.string().default(""),
     createdAt: z.string()
 });
+// A scheduled (background) watch: a research goal the daemon re-runs on a
+// schedule. `frequency` selects which days fire — weekly fires on the weekday
+// the watch was created (derived from createdAt) — and `atHHMM` is the
+// local-time trigger. Foreground watches are ephemeral and never persisted here.
+export const SavedWatchSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    goal: z.string(),
+    projectRoot: z.string(), // run context — config + prior reports resolve from here
+    frequency: z.enum(["day", "weekday", "week"]),
+    atHHMM: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/u),
+    createdAt: z.string(),
+    lastRunAt: z.string().nullable().default(null),
+    enabled: z.boolean().default(true)
+});
+// One execution record per background run, appended to results.jsonl. We store
+// the diff as section counts (not the full text) — the full report lives at
+// runPath — so the unread-results banner needs no string re-parsing.
+export const WatchResultSchema = z.object({
+    id: z.string(),
+    watchId: z.string(),
+    watchName: z.string(),
+    runPath: z.string(),
+    goal: z.string(),
+    added: z.number().int().default(0),
+    removed: z.number().int().default(0),
+    ranAt: z.string(),
+    status: z.enum(["ok", "error"]),
+    errorMessage: z.string().optional()
+});

package/dist/ui/ink/SciraApp.js

@@ -56,7 +56,6 @@ export function SciraApp({ runPath: initialRunPath, config: initialConfig, updat
     const planModeRef = useRef(false);
     const [planMode, setPlanModeState] = useState(false);
     const setPlanMode = useCallback((active) => { planModeRef.current = active; setPlanModeState(active); }, []);
-    // Plan-mode preference armed from the home screen, applied when the next run opens.
     const pendingPlanModeRef = useRef(false);
     const [pendingPlanMode, setPendingPlanModeState] = useState(false);
     const setPendingPlanMode = useCallback((active) => { pendingPlanModeRef.current = active; setPendingPlanModeState(active); }, []);
@@ -136,7 +135,6 @@ export function SciraApp({ runPath: initialRunPath, config: initialConfig, updat
                 setPendingCollapse(new Set());
                 return new Set();
             }
-            // Mark done groups for pending collapse, but don't collapse active ones
             setPendingCollapse(new Set(doneGroupKeys));
             return new Set(doneGroupKeys.filter((k) => {
                 const group = computeGroups(feed).groups.get(k);
@@ -159,7 +157,6 @@ export function SciraApp({ runPath: initialRunPath, config: initialConfig, updat
             return;
         toggleGroup(focusedGroupKey);
     }, [focusedGroupKey, toggleGroup]);
-    // Auto-collapse groups when they become inactive if they're in pendingCollapse
     React.useEffect(() => {
         if (pendingCollapse.size === 0)
             return;
@@ -354,10 +351,6 @@ export function SciraApp({ runPath: initialRunPath, config: initialConfig, updat
     const contentRows = Math.max(1, feedRows);
     const maxScrollOffset = Math.max(0, feedLines.length - contentRows);
     wheelStateRef.current = { screen, maxScrollOffset };
-    // scrollOffset < 0 is a sentinel meaning "pin the most recent user message to
-    // the top of the viewport" (with empty space below for the incoming reply).
-    // Once the reply grows past the viewport we fall back to bottom-anchoring so
-    // the streaming output stays visible. Any manual scroll clears the sentinel.
     const pinUserToTop = scrollOffset < 0 && lastUserLineStart >= 0;
     let startIdx;
     if (pinUserToTop) {
@@ -402,16 +395,7 @@ export function SciraApp({ runPath: initialRunPath, config: initialConfig, updat
         hoverMapRef.current = hoverMap;
     }
     const slicedLines = feedLines.slice(startIdx, startIdx + contentRows);
-    // The feed box is bottom-aligned (justifyContent="flex-end"). When pinning the
-    // user message to the top, pad blank lines below it so short content is pushed
-    // up — the user message sits at the top with empty room below for the reply.
     const blankLine = (k) => _jsx(Text, { children: " " }, k);
-    // Show an animated loading line whenever the agent is still doing non-text
-    // work (reasoning, tool calls, status) — i.e. the latest feed item isn't the
-    // streamed answer text. It stays pinned below the latest content for the whole
-    // turn, and the phrase rotates slowly so it doesn't feel frozen. The feed box
-    // is bottom-aligned with overflow hidden, so when the timeline is long the
-    // loader stays visible and the oldest lines scroll off the top instead.
     const lastItem = feed[feed.length - 1];
     const showLoader = busy && lastItem !== undefined && lastItem.kind !== "text";
     const phrase = LOADING_PHRASES[Math.floor(frame / 24) % LOADING_PHRASES.length];

package/dist/ui/ink/components/effects.js

@@ -1,11 +1,8 @@
 import React from "react";
 import { HOME_TIPS } from "../constants.js";
-/** Stable mount-only effect: makes intent explicit, prevents accidental dep-driven re-runs. */
 export function useMountEffect(effect) {
-    /* eslint-disable-next-line react-hooks/exhaustive-deps */
     React.useEffect(effect, []);
 }
-/** Cycles the tip index every 6 s while mounted (rendered only on the home screen). */
 export function TipCycler({ setTipIndex }) {
     useMountEffect(() => {
         const id = setInterval(() => setTipIndex((i) => (i + 1) % HOME_TIPS.length), 6000);
@@ -13,13 +10,9 @@ export function TipCycler({ setTipIndex }) {
     });
     return null;
 }
-/** Drives the spinner, caret-blink, and reasoning-clock animations while mounted (rendered only when busy). */
 export function AnimationTick({ setBlink, setFrame, setReasoningTick, }) {
     useMountEffect(() => {
         const blinkId = setInterval(() => setBlink((v) => !v), 400);
-        // frame increments monotonically; consumers take `% SPINNER_FRAMES.length` for the
-        // spinner glyph and `Math.floor(frame / 24)` for the slow phrase rotation. Wrapping it
-        // here would pin the phrase to index 0 forever (frame would never exceed the frame count).
         const frameId = setInterval(() => setFrame((f) => f + 1), 80);
         const tickId = setInterval(() => setReasoningTick((t) => t + 1), 500);
         return () => {
@@ -32,7 +25,6 @@ export function AnimationTick({ setBlink, setFrame, setReasoningTick, }) {
     });
     return null;
 }
-/** Enables SGR mouse-click/hover tracking while mounted (rendered only on the home screen). */
 export function MouseTracker({ stdout, stdin, onData, onUnmount, }) {
     useMountEffect(() => {
         stdout.write("\x1b[?1003h\x1b[?1006h");

package/dist/ui/ink/components/home-screen.js

@@ -48,8 +48,6 @@ function computeHeroLayout(bodyRows, bodyCols, hasNotice) {
         newResearchRowOffset,
     };
 }
-/** Home screen body: branding card, browse modal, notice, and tip line.
- *  Also (re)builds the mouse click/hover row maps as a render side-effect. */
 export function HomeScreen({ cols, rows, sessions, selectedIdx, hoveredIdx, heroHidden, notice, tipIndex, commandMenuHeight, mcpOpen, sessionsModalOpen, sessionsModalIdx, inputText, config, modelName, clickMapRef, hoverMapRef, setSelectedIdx, setSessionsModalOpen, setSessionsModalIdx, setNotice, openRun, submitHome, exit, }) {
     const theme = useTheme();
     const bodyCols = Math.max(32, cols - 4);

package/dist/ui/ink/components/overlays.js

@@ -10,7 +10,6 @@ export function TopBar({ screen, runState, fullMode, planMode, activeUsage, busy
 }
 export function InputBar({ inputLines, cursorLine, cursorCol, showCursor, approvalPending, busy, frame, boxWidth, modelName, planMode, config }) {
     const theme = useTheme();
-    // Plan mode tints the whole input box (unless an approval/busy state takes precedence).
     const borderColor = approvalPending ? theme.warning : busy ? theme.accentDim : planMode ? "cyan" : theme.textDim;
     const promptColor = approvalPending ? theme.warning : busy ? theme.accentDim : planMode ? "cyan" : theme.accent;
     const inputColor = approvalPending ? theme.textDim : theme.inputText;
@@ -113,13 +112,8 @@ export function MenuDialog({ menu, cols, rows, config }) {
     const dialogH = 5 + (menu.loading ? 1 : Math.min(DIALOG_ITEMS, menuFiltered.length) + (menuStart > 0 ? 1 : 0) + (menuFiltered.length - (menuStart + DIALOG_ITEMS) > 0 ? 1 : 0));
     const dialogTop = Math.max(1, Math.floor((rows - dialogH) / 2));
     const bg = theme.userBandBackground ? { backgroundColor: theme.userBandBackground } : {};
-    const innerW = DIALOG_W - 2; // cells between the two border columns
-    // Draw the border as characters inside full-width background lines (like
-    // InputBar). Ink's box border + backgroundColor leaves unfilled gaps, so we
-    // compose each line ourselves: every line is one solid Text spanning DIALOG_W.
+    const innerW = DIALOG_W - 2;
     const line = (key, visibleLen, content) => (_jsxs(Text, { ...bg, wrap: "truncate", children: [_jsx(Text, { color: theme.accent, children: "\u2502" }), _jsx(Text, { children: " " }), content, _jsx(Text, { children: " ".repeat(Math.max(0, innerW - 1 - visibleLen)) }), _jsx(Text, { color: theme.accent, children: "\u2502" })] }, key));
-    // Clip a string to at most `max` display columns (so a row never overruns the
-    // border on narrow terminals — wrap="truncate" would eat the closing │).
     const clip = (s, max) => {
         if (max <= 0)
             return "";
@@ -129,17 +123,16 @@ export function MenuDialog({ menu, cols, rows, config }) {
         for (const ch of s) {
             const cw = displayWidth(ch);
             if (w + cw > max - 1)
-                break; // leave a column for the ellipsis
+                break;
             out += ch;
             w += cw;
         }
         return out + "…";
     };
-    const avail = innerW - 1; // usable columns after the leading space
+    const avail = innerW - 1;
     const title = menu.type === "model" ? "Select model" : menu.type === "llm" ? "Select LLM provider" : "Select search provider";
     const hint = "↑↓ navigate · ⏎ apply · esc close";
     const dialogLines = [];
-    // Title + hint, dropping/clipping the (secondary) hint when space is tight.
     const titleC = clip(title, avail);
     const hintRoom = avail - displayWidth(titleC) - 2;
     const hintC = hintRoom >= 6 ? clip(hint, hintRoom) : "";

package/dist/ui/ink/constants.js

@@ -4,14 +4,12 @@ export const FILE_MENTION_MAX_CHARS = 20000;
 export const FILE_MENTION_SKIP = new Set([".git", "node_modules", "dist", ".scira"]);
 export const PROVIDERS = ["parallel", "exa", "firecrawl"];
 export const CHAT_COMMANDS = ["/help", "/home", "/new", "/plan", "/rerun", "/report", "/sources", "/claims", "/why", "/mcp", "/copy", "/usage", "/rename", "/model", "/llm", "/provider", "/thinking", "/reasoning", "/theme", "/links", "/key", "/keys", "/stop", "/back", "/quit"];
-/** Commands grouped by purpose, for the /help reference. */
 export const COMMAND_GROUPS = [
     { label: "Model", commands: ["/llm", "/model", "/provider", "/plan", "/thinking", "/reasoning"] },
     { label: "Session", commands: ["/new", "/rerun", "/rename", "/report", "/sources", "/claims", "/why", "/copy", "/usage"] },
     { label: "Setup", commands: ["/key", "/keys", "/mcp", "/theme", "/links"] },
     { label: "Go", commands: ["/home", "/back", "/stop", "/quit"] },
 ];
-/** Keyboard shortcuts shown in /help (not discoverable via the `/` autocomplete). */
 export const KEY_HINTS = [
     { keys: "↑↓ jk u/d pgup/dn", action: "scroll" },
     { keys: "^C ^C / ^D", action: "quit" },
@@ -19,7 +17,6 @@ export const KEY_HINTS = [
     { keys: "/ @ #", action: "commands · files · sessions" },
     { keys: "[ ] C", action: "navigate / toggle tool groups" },
 ];
-/** Slash commands that take an argument; ⏎ from the menu appends a space instead of running. */
 export const COMMANDS_NEEDING_ARGS = new Set(["/theme", "/key", "/rename", "/why", "/links"]);
 export const COMMAND_DESCRIPTIONS = {
     "/help": "Show command and keyboard shortcuts.",

package/dist/ui/ink/hooks/use-agent-turn.js

@@ -20,13 +20,10 @@ export function useAgentTurn({ config, currentRunPath, queuedPromptRef, fullMode
         if (existing?.busy)
             return;
         const session = createSession(runPath);
-        // Always re-attach subscriber so follow-up turns have a live listener.
         attachSubscriber(runPath, getSubscriber());
         const controller = new AbortController();
         session.abort = controller;
         setBusy(true);
-        // Pin the just-sent user message to the top of the viewport, leaving room
-        // below for the incoming assistant reply (-1 sentinel; see SciraApp).
         setScrollOffset(-1);
         sessionSetBusy(runPath, true);
         const modelId = config.model;
@@ -43,7 +40,7 @@ export function useAgentTurn({ config, currentRunPath, queuedPromptRef, fullMode
                         if (cleanTitle)
                             await setRunTitle(runPath, cleanTitle);
                     }
-                    catch { /* non-fatal */ }
+                    catch { }
                 })();
             }
             const onApprovalRequired = (toolName, description) => new Promise((resolve) => sessionSetApproval(runPath, { toolName, description, resolve }));
@@ -62,8 +59,6 @@ export function useAgentTurn({ config, currentRunPath, queuedPromptRef, fullMode
                             sessionFinishReasoning(runPath);
                             break;
                         case "tool-call": {
-                            // Stash the raw input (capped) so dedicated tool renderers (diffs,
-                            // checklists, …) can reconstruct it from the feed.
                             let inputJson;
                             try {
                                 inputJson = JSON.stringify(part.input)?.slice(0, 32_000);
@@ -117,7 +112,7 @@ export function useAgentTurn({ config, currentRunPath, queuedPromptRef, fullMode
                     turnUsage.output += u.outputTokens ?? 0;
                     turnUsage.total += u.totalTokens ?? (u.inputTokens ?? 0) + (u.outputTokens ?? 0);
                 }
-                catch { /* usage is best-effort */ }
+                catch { }
                 return result.text;
             };
             const mentioned = await promptWithFileMentions(prompt);
@@ -217,7 +212,7 @@ export function useAgentTurn({ config, currentRunPath, queuedPromptRef, fullMode
             try {
                 await Bun.write(join(runPath, "convo.json"), JSON.stringify({ feed: snapshot, messages: conversationRef.current, usage: aggregateTurns(turnsRef.current) }, null, 2));
             }
-            catch { /* non-fatal */ }
+            catch { }
             removeSession(runPath);
             const queued = queuedPromptRef.current;
             if (queued && !controller.signal.aborted) {