klyro 1.0.16 → 1.0.18

package/dist/tui/app.js

@@ -7,6 +7,8 @@ import React, { useState, useEffect, useRef, useCallback, useMemo } from 'react'
 import { Box, Text, useInput, useStdout } from 'ink';
 import Spinner from 'ink-spinner';
 import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import * as path from 'node:path';
 import { TuiApprovalBridge, ApprovalModal } from './approval.js';
 import { parse as parseSlash, suggestCommands } from '../cli/slash/parser.js';
 import { loadCustomCommands, listCompletableFiles } from '../cli/slash/custom.js';
@@ -33,6 +35,40 @@ function Header({ cwd, model, version, width }) {
     const showLinks = width >= 120;
     return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, flexShrink: 0, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { bold: true, color: tokens.colors.accent, children: ["KLYRO  v", version] }), showLinks ? _jsx(Text, { color: tokens.colors.dim, children: "\u2502  /help   /config   /clear   /exit" }) : null] }), _jsxs(Text, { color: tokens.colors.dim, children: [model, "  \u00B7  ", cwd] }), branch ? _jsxs(Text, { color: tokens.colors.dim, children: ["\u2387  ", branch] }) : null] }));
 }
+/**
+ * 5.5c — compact todo checklist. Live `plan` state (`todo_write` →
+ * `plan_update` events → `updatePlan`) wins; when it is empty, best-effort
+ * read of `.klyro/plans/todos.json` so a reloaded TUI still shows the list.
+ */
+const TODO_STATUSES = ['pending', 'in_progress', 'done', 'failed', 'skipped'];
+function loadTodosFromDisk(cwd) {
+    try {
+        const raw = readFileSync(path.join(cwd, '.klyro', 'plans', 'todos.json'), 'utf-8');
+        const arr = JSON.parse(raw);
+        if (!Array.isArray(arr))
+            return [];
+        return arr
+            .filter((t) => typeof t.title === 'string' && t.title.length > 0)
+            .map((t, i) => ({
+            id: typeof t.id === 'string' ? t.id : `disk-${i}`,
+            title: t.title,
+            status: TODO_STATUSES.includes(t.status)
+                ? t.status
+                : 'pending',
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function TodoChecklist({ plan, cwd }) {
+    // Disk fallback only when live state is empty (never masks live updates).
+    const disk = useMemo(() => (plan.length > 0 ? [] : loadTodosFromDisk(cwd)), [plan.length, cwd]);
+    const items = plan.length > 0 ? plan : disk;
+    if (items.length === 0)
+        return null;
+    return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginTop: 0, marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { bold: true, children: [g('todoPlan'), " Plan  ", items.filter((p) => p.status === 'done').length, "/", items.length] })] }), items.slice(0, 8).map((p, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: p.status === 'done' ? tokens.colors.ok : p.status === 'in_progress' ? tokens.colors.accent : tokens.colors.dim, children: [p.status === 'done' ? g('todoDone') : p.status === 'in_progress' ? g('todoActive') : g('todoPending'), " ", i + 1, ". ", redact(p.title)] })] }, p.id)))] }));
+}
 function verbForTool(name) {
     if (name === 'read_file')
         return 'Read';
@@ -229,6 +265,14 @@ export function App(props) {
         setHistory((prev) => (prev[prev.length - 1] === v ? prev : [...prev.slice(-99), v]));
         setHistIdx(null);
     }, []);
+    // Ctrl+R reverse-i-search over input history (1.4): {query, saved, idx}
+    // with idx into newest-first matches (-1 = query only, nothing chosen).
+    const [histSearch, setHistSearch] = useState(null);
+    const searchMatches = useCallback((q) => {
+        const query = q.toLowerCase();
+        const matches = (query === '' ? history : history.filter((h) => h.toLowerCase().includes(query)));
+        return matches.slice().reverse();
+    }, [history]);
     // design.md §18: Ctrl+C cancels the run first, exits on second press.
     const ctrlCArmed = useRef(false);
     useEffect(() => {
@@ -484,7 +528,6 @@ export function App(props) {
             out.push({ key: 'tail:queued', desc: { kind: 'queued', count: queuedInputs.length }, groupIndex: null, tail: 'queued' });
         }
         return out;
-        // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [grouped, plan, status.status, queuedInputs.length, expandedGroups, width]);
     const blockKeys = useMemo(() => blocks.map((b) => b.key), [blocks]);
     const blockHeights = useMemo(() => blocks.map((b) => cache.heightFor(b.key, b.desc, width)), [blocks, width, cache]);
@@ -762,6 +805,56 @@ export function App(props) {
             setVimCursor(null);
             return;
         }
+        // Ctrl+R reverse-i-search over input history (1.4). While active, typing
+        // filters newest-first, ↑/↓ (or repeated Ctrl+R) cycle matches, Enter
+        // accepts into the buffer, Esc/Ctrl+C restores the saved input.
+        if (histSearch && !awaitingApproval) {
+            // idx into newest-first matches; -1 shows the raw query text.
+            const applyQuery = (query, idx) => {
+                const m = searchMatches(query);
+                const i = m.length === 0 ? -1 : Math.max(-1, Math.min(idx, m.length - 1));
+                setHistSearch({ query, saved: histSearch.saved, idx: i });
+                setInput(i === -1 ? query : (m[i] ?? query));
+                setVimCursor(null);
+            };
+            if (key.escape || (key.ctrl && inputStr === 'c')) {
+                setInput(histSearch.saved);
+                setHistIdx(null);
+                setHistSearch(null);
+                setVimCursor(null);
+                return;
+            }
+            if (key.return) {
+                setHistSearch(null);
+                setHistIdx(null);
+                setVimCursor(null);
+                return;
+            }
+            if ((key.upArrow && !key.shift && !key.ctrl) || (key.ctrl && (inputStr === 'p' || inputStr === 'r'))) {
+                applyQuery(histSearch.query, histSearch.idx + 1); // older (clamped)
+                return;
+            }
+            if ((key.downArrow && !key.shift && !key.ctrl) || (key.ctrl && inputStr === 'n')) {
+                applyQuery(histSearch.query, histSearch.idx - 1); // newer, -1 → query
+                return;
+            }
+            if (key.backspace || key.delete) {
+                applyQuery(histSearch.query.slice(0, -1), 0);
+                return;
+            }
+            if (!key.ctrl && !key.meta && inputStr) {
+                applyQuery(histSearch.query + inputStr, 0);
+                return;
+            }
+            return;
+        }
+        if (key.ctrl && inputStr === 'r' && !awaitingApproval && vimMode === 'insert') {
+            setHistSearch({ query: '', saved: input, idx: -1 });
+            setInput('');
+            setHistIdx(null);
+            setVimCursor(null);
+            return;
+        }
         // Scroll keys (work in any mode, including while running).
         // scroll.md §6 flow: Keyboard → getTranscriptCommand → handle.
         // design.md §11: PageUp/Ctrl+U half-up, PageDown/Ctrl+D half-down,
@@ -988,6 +1081,19 @@ export function App(props) {
                 return;
             }
         }
+        // Ctrl+L (1.4): clear the input buffer if typing, else jump to the live
+        // tail. Never touches the transcript — use /clear for that.
+        if (key.ctrl && inputStr === 'l') {
+            if (input.trim() !== '') {
+                setInput('');
+                setVimCursor(null);
+                setHistIdx(null);
+            }
+            else if (isFullscreen && maxTop > 0) {
+                commands.jumpBottom();
+            }
+            return;
+        }
         if (status.status === 'running') {
             // design.md §18: first Ctrl+C cancels the run, second quits.
             if (key.ctrl && inputStr === 'c') {
@@ -1055,7 +1161,7 @@ export function App(props) {
         // ↑/↓ are history keys, always (§8.3): ↑ browses older prompts
         // newest-first (empty history → no-op), ↓ browses back newer. Neither
         // ever scrolls the transcript — scrolling is PgUp/PgDn, Ctrl+U/D/B/F,
-        // Shift+↑/↓, Home/End, Space, or the wheel (KLYRO_MOUSE=1). Ctrl+P /
+        // Shift+↑/↓, Home/End, Space, or the wheel. Ctrl+P /
         // Ctrl+N are escape-free aliases for the same history moves.
         const wantHistPrev = (key.upArrow && !key.shift && !key.ctrl) || (key.ctrl && inputStr === 'p');
         const wantHistNext = (key.downArrow && !key.shift && !key.ctrl) || (key.ctrl && inputStr === 'n');
@@ -1121,7 +1227,6 @@ export function App(props) {
     });
     // Single source of truth: package.json via version.ts — never hardcoded.
     const ver = props.version ?? readVersion();
-    const rule = g('rule').repeat(Math.max(10, width - 2));
     // Single cost/context source: model-aware registry rates + window.
     const cost = estimateCost(status.model, status.usageInput, status.usageOutput);
     const totalTokens = status.usageInput + status.usageOutput;
@@ -1129,12 +1234,14 @@ export function App(props) {
     const ctxPct = totalTokens > 0 ? Math.round((totalTokens / ctxWindow) * 100) : 0;
     // Narrow terminals: compact hints so the status bar never wraps mid-word.
     // An armed first-Esc surfaces here so the operator knows the second cancels.
-    const baseHints = escArmed && status.status === 'running'
-        ? 'press esc again to cancel'
-        : width < 90
-            ? status.status === 'running' ? 'ctrl+c stop · enter queue' : 'enter send · / commands'
-            : status.status === 'running' ? 'ctrl+c to stop  ·  enter to queue  ·  ctrl+o expand' : transcript.length === 0 ? 'shift+tab to cycle  ·  ↑/↓ for history  ·  / for commands' : 'enter to send  ·  shift+enter newline  ·  @ to attach';
-    const hints = maxTop > 0 && isFullscreen ? `${baseHints}  ·  PgUp/Dn scroll` : baseHints;
+    const baseHints = histSearch !== null
+        ? `reverse-i-search \`${histSearch.query}\` · type to filter · ↑/↓ cycle · enter accept · esc cancel`
+        : escArmed && status.status === 'running'
+            ? 'press esc again to cancel'
+            : width < 90
+                ? status.status === 'running' ? 'ctrl+c stop · enter queue' : 'enter send · / commands'
+                : status.status === 'running' ? 'ctrl+c to stop  ·  enter to queue  ·  ctrl+o expand' : transcript.length === 0 ? 'shift+tab to cycle  ·  ↑/↓ for history  ·  / for commands' : 'enter to send  ·  shift+enter newline  ·  @ to attach';
+    // I1 structural guard:
     // I1 structural guard: the frame can never exceed terminal rows. Even if a
     // child mis-measures, the root clips — the input/status stay on screen and
     // Ink's cursor math can't corrupt into overlapping text.
@@ -1216,5 +1323,5 @@ export function App(props) {
                                 if (it.kind === 'diff')
                                     return (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: [_jsx(Text, { bold: true, color: tokens.colors.soft, children: it.summary ?? 'Diff' }), it.hunks.map((h, i) => (_jsxs(Box, { flexDirection: "column", marginTop: 0, children: [_jsx(Text, { color: tokens.colors.soft, children: h.path }), h.lines.map((l, j) => (_jsxs(Text, { wrap: "wrap", color: l.kind === 'add' ? tokens.colors.ok : l.kind === 'remove' ? tokens.colors.err : tokens.colors.dim, children: [l.kind === 'add' ? '+ ' : l.kind === 'remove' ? '- ' : '  ', redact(l.text)] }, j)))] }, i)))] }, it.id));
                                 return null;
-                            }) : null, showThinking && status.status === 'running' && !streamingIdRef.current ? (_jsxs(Box, { paddingLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: tokens.colors.accent, children: [_jsx(Spinner, { type: "dots" }), " "] }), _jsx(Text, { color: tokens.colors.dim, children: "Thinking... (esc \u00D72 to cancel)" }), _jsxs(Text, { color: tokens.colors.dim, children: ["  ", (elapsed / 1000).toFixed(1), "s"] })] })) : null, showPlan && plan.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, marginTop: 0, marginBottom: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { bold: true, children: [g('todoPlan'), " Plan  ", plan.filter((p) => p.status === 'done').length, "/", plan.length] })] }), plan.slice(0, 8).map((p, i) => (_jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: p.status === 'done' ? tokens.colors.ok : p.status === 'in_progress' ? tokens.colors.accent : tokens.colors.dim, children: [p.status === 'done' ? g('todoDone') : p.status === 'in_progress' ? g('todoActive') : g('todoPending'), " ", i + 1, ". ", redact(p.title)] })] }, p.id)))] })) : null, showQueued && queuedInputs.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: queuedInputs.map((q, i) => (_jsxs(Text, { color: tokens.colors.dim, children: ["queued: ", redact(q.slice(0, 60)), i === 0 ? '  esc to drop' : ''] }, i))) })) : null] }), isFullscreen && !atBottom ? (_jsx(Box, { flexDirection: "column", width: 1, marginLeft: 1, children: Array.from({ length: trackH }).map((_, i) => (_jsx(Text, { color: i === thumbPos ? tokens.colors.accent : tokens.colors.guide, children: i === thumbPos ? '●' : '│' }, i))) })) : null] }), pinned && badgeLabel(atBottom, pendingNew, status.status !== 'running') ? (_jsx(Box, { justifyContent: "center", flexShrink: 0, children: _jsxs(Text, { backgroundColor: tokens.colors.accentSoft, color: tokens.colors.accent, bold: true, children: [' ', badgeLabel(atBottom, pendingNew, status.status !== 'running'), ' '] }) })) : null, slashSuggest.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, flexShrink: 0, children: [slashSuggest.map((s, i) => (_jsxs(Text, { color: i === 0 ? tokens.colors.accent : tokens.colors.dim, children: [i === 0 ? '▸' : ' ', " /", s.name, "  \u2014 ", s.hint] }, s.name))), _jsx(Text, { color: tokens.colors.dim, children: "  tab to complete" })] })) : null, slashSuggest.length === 0 && pathSuggest.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, flexShrink: 0, children: [pathSuggest.map((s, i) => (_jsxs(Text, { color: i === 0 ? tokens.colors.accent : tokens.colors.dim, children: [i === 0 ? '▸' : ' ', " ", s.name] }, s.name))), _jsx(Text, { color: tokens.colors.dim, children: "  tab to complete" })] })) : null, _jsx(ApprovalModal, { bridge: bridge }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) }), _jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.accent, bold: true, children: [g('prompt'), " "] }), vimMode === 'normal' ? _jsx(Text, { color: tokens.colors.warn, bold: true, children: "--NORMAL-- " }) : null, _jsx(InputWithCursor, { input: input, cursor: vimCursor })] }), _jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) })] }), _jsxs(Box, { justifyContent: "space-between", flexShrink: 0, children: [_jsxs(Text, { color: tokens.colors.dim, children: [status.status === 'running' ? (_jsxs(Text, { color: tokens.colors.accent, children: [_jsx(Spinner, { type: "dots" }), " working  \u00B7  "] })) : null, baseHints, maxTop > 0 && isFullscreen ? '  ·  PgUp/Dn scroll' : ''] }), _jsxs(Text, { color: tokens.colors.dim, children: [maxTop > 0 && isFullscreen ? `⇅ ${topRow}/${maxTop} · ` : '', cost > 0 ? `$${cost.toFixed(2)} · ` : '', ctxPct, "% ctx \u00B7 ", status.model, status.status === 'running' ? ' ●' : ''] })] })] }));
+                            }) : null, showThinking && status.status === 'running' && !streamingIdRef.current ? (_jsxs(Box, { paddingLeft: 2, marginBottom: 1, children: [_jsxs(Text, { color: tokens.colors.guide, children: ["  ", g('guide'), "   "] }), _jsxs(Text, { color: tokens.colors.accent, children: [_jsx(Spinner, { type: "dots" }), " "] }), _jsx(Text, { color: tokens.colors.dim, children: "Thinking... (esc \u00D72 to cancel)" }), _jsxs(Text, { color: tokens.colors.dim, children: ["  ", (elapsed / 1000).toFixed(1), "s"] })] })) : null, showPlan ? _jsx(TodoChecklist, { plan: plan, cwd: props.cwd }) : null, showQueued && queuedInputs.length > 0 ? (_jsx(Box, { flexDirection: "column", paddingLeft: 2, marginBottom: 1, children: queuedInputs.map((q, i) => (_jsxs(Text, { color: tokens.colors.dim, children: ["queued: ", redact(q.slice(0, 60)), i === 0 ? '  esc to drop' : ''] }, i))) })) : null] }), isFullscreen && !atBottom ? (_jsx(Box, { flexDirection: "column", width: 1, marginLeft: 1, children: Array.from({ length: trackH }).map((_, i) => (_jsx(Text, { color: i === thumbPos ? tokens.colors.accent : tokens.colors.guide, children: i === thumbPos ? '●' : '│' }, i))) })) : null] }), pinned && badgeLabel(atBottom, pendingNew, status.status !== 'running') ? (_jsx(Box, { justifyContent: "center", flexShrink: 0, children: _jsxs(Text, { backgroundColor: tokens.colors.accentSoft, color: tokens.colors.accent, bold: true, children: [' ', badgeLabel(atBottom, pendingNew, status.status !== 'running'), ' '] }) })) : null, slashSuggest.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, flexShrink: 0, children: [slashSuggest.map((s, i) => (_jsxs(Text, { color: i === 0 ? tokens.colors.accent : tokens.colors.dim, children: [i === 0 ? '▸' : ' ', " /", s.name, "  \u2014 ", s.hint] }, s.name))), _jsx(Text, { color: tokens.colors.dim, children: "  tab to complete" })] })) : null, slashSuggest.length === 0 && pathSuggest.length > 0 ? (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, flexShrink: 0, children: [pathSuggest.map((s, i) => (_jsxs(Text, { color: i === 0 ? tokens.colors.accent : tokens.colors.dim, children: [i === 0 ? '▸' : ' ', " ", s.name] }, s.name))), _jsx(Text, { color: tokens.colors.dim, children: "  tab to complete" })] })) : null, _jsx(ApprovalModal, { bridge: bridge }), _jsxs(Box, { flexDirection: "column", flexShrink: 0, children: [_jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) }), _jsxs(Box, { children: [_jsxs(Text, { color: tokens.colors.accent, bold: true, children: [g('prompt'), " "] }), vimMode === 'normal' ? _jsx(Text, { color: tokens.colors.warn, bold: true, children: "--NORMAL-- " }) : null, _jsx(InputWithCursor, { input: input, cursor: vimCursor })] }), _jsx(Text, { color: tokens.colors.guide, children: g('rule').repeat(Math.max(10, width - 2)) })] }), _jsxs(Box, { justifyContent: "space-between", flexShrink: 0, children: [_jsxs(Text, { color: tokens.colors.dim, children: [status.status === 'running' ? (_jsxs(Text, { color: tokens.colors.accent, children: [_jsx(Spinner, { type: "dots" }), " working  \u00B7  "] })) : null, baseHints, maxTop > 0 && isFullscreen ? '  ·  PgUp/Dn scroll' : ''] }), _jsxs(Text, { color: tokens.colors.dim, children: [maxTop > 0 && isFullscreen ? `⇅ ${topRow}/${maxTop} · ` : '', cost > 0 ? `$${cost.toFixed(2)} · ` : '', ctxPct, "% ctx \u00B7 ", status.model, status.status === 'running' ? ' ●' : ''] })] })] }));
 }

package/dist/tui/app.test.js

@@ -215,9 +215,9 @@ describe('App', () => {
     });
     it('pressing End re-engages follow-tail and reveals new content', async () => {
         const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, isFullscreen: true, initialTranscript: makeInitialTranscript(25) }));
-        await new Promise((r) => setTimeout(r, 100));
+        await new Promise((r) => setTimeout(r, 200));
         stdin.write(KEY_HOME);
-        await new Promise((r) => setTimeout(r, 100));
+        await new Promise((r) => setTimeout(r, 200));
         const g = globalThis;
         g.__klyroAppAppend({
             id: 'late-1',
@@ -229,7 +229,7 @@ describe('App', () => {
         expect(lastFrame() ?? '').not.toMatch(/LATE-1-tag/);
         // End re-engages follow-tail and shows the new content.
         stdin.write(KEY_END);
-        await new Promise((r) => setTimeout(r, 100));
+        await new Promise((r) => setTimeout(r, 200));
         const frame = lastFrame() ?? '';
         expect(frame).toMatch(/LATE-1-tag/);
     });
@@ -321,6 +321,53 @@ describe('App', () => {
         await new Promise((r) => setTimeout(r, 30));
         expect(lastFrame() ?? '').toContain('zzsecond#');
     });
+    it('Ctrl+R reverse-searches history; Enter accepts, Esc restores (1.4)', async () => {
+        const onPrompt = vi.fn(async () => { });
+        const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: onPrompt, onSlash: async () => { } }));
+        stdin.write('fix login bug');
+        await new Promise((r) => setTimeout(r, 20));
+        stdin.write('\x0d');
+        await new Promise((r) => setTimeout(r, 50));
+        stdin.write('add logout button');
+        await new Promise((r) => setTimeout(r, 20));
+        stdin.write('\x0d');
+        await new Promise((r) => setTimeout(r, 50));
+        expect(onPrompt).toHaveBeenCalledTimes(2);
+        // Search for 'logout' + Enter accepts the match into the buffer
+        // (no submit); typing '!' must extend it in the input line only.
+        stdin.write('\x12');
+        await new Promise((r) => setTimeout(r, 30));
+        stdin.write('logout');
+        await new Promise((r) => setTimeout(r, 30));
+        stdin.write('\x0d');
+        await new Promise((r) => setTimeout(r, 30));
+        stdin.write('!');
+        await new Promise((r) => setTimeout(r, 30));
+        expect(lastFrame() ?? '').toContain('add logout button!');
+        // Esc cancels a fresh search and restores the pre-search buffer.
+        stdin.write('\x12');
+        await new Promise((r) => setTimeout(r, 30));
+        stdin.write('zzz');
+        await new Promise((r) => setTimeout(r, 30));
+        stdin.write('\x1b');
+        await new Promise((r) => setTimeout(r, 30));
+        stdin.write('?');
+        await new Promise((r) => setTimeout(r, 30));
+        expect(lastFrame() ?? '').not.toContain('zzz?');
+        expect(onPrompt).toHaveBeenCalledTimes(2); // searching never submits
+    });
+    it('Ctrl+L clears a non-empty input without submitting (1.4)', async () => {
+        const onPrompt = vi.fn(async () => { });
+        const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: onPrompt, onSlash: async () => { } }));
+        stdin.write('scratch that');
+        await new Promise((r) => setTimeout(r, 20));
+        stdin.write('\x0c');
+        await new Promise((r) => setTimeout(r, 30));
+        stdin.write('?');
+        await new Promise((r) => setTimeout(r, 30));
+        expect(lastFrame() ?? '').not.toContain('scratch that');
+        expect(onPrompt).not.toHaveBeenCalled();
+    });
     it('/c shows top-6 suggestions and Tab completes', async () => {
         const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { } }));
         stdin.write('/c');
@@ -448,7 +495,7 @@ describe('App', () => {
         await waitForAbsent(lastFrame, /MSG-24-tag/);
         await waitForMatch(lastFrame, /MSG-14-tag/);
         handle.runTranscriptCommand('messages_first');
-        let frame = await waitForMatch(lastFrame, /MSG-00-tag/);
+        const frame = await waitForMatch(lastFrame, /MSG-00-tag/);
         expect(frame).not.toMatch(/MSG-24-tag/);
         handle.runTranscriptCommand('messages_last');
         await waitForMatch(lastFrame, /MSG-24-tag/);
@@ -710,6 +757,20 @@ describe('App', () => {
         expect(f2() ?? '').toContain(readVersion());
         expect(f2() ?? '').not.toContain('0.1.27');
     });
+    it('shows the todo checklist when plan updates arrive (5.5c)', async () => {
+        const { lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { } }));
+        const g = globalThis;
+        for (let i = 0; i < 40 && !g.__klyroAppPlan; i++)
+            await new Promise((r) => setTimeout(r, 25));
+        expect(g.__klyroAppPlan).toBeDefined();
+        g.__klyroAppPlan?.([
+            { id: '1', title: 'Read files', status: 'done' },
+            { id: '2', title: 'Edit code', status: 'in_progress' },
+        ]);
+        const frame = await waitForMatch(lastFrame, /Read files/);
+        expect(frame).toMatch(/Plan/);
+        expect(frame).toMatch(/Edit code/);
+    });
     it('Shift+Up / Shift+Down scroll by one line', async () => {
         const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, isFullscreen: true, initialTranscript: makeInitialTranscript(25) }));
         await new Promise((r) => setTimeout(r, 50));

package/dist/tui/measure.js

@@ -17,6 +17,7 @@
  *   plan block     = 1 + min(8, steps) + 1 margin
  *   thinking/queue = content lines + 1 margin
  */
+// eslint-disable-next-line no-control-regex -- intentional: measuring visible width requires skipping SGR sequences
 const ANSI_RE = /\x1b\[[0-9;]*m/g;
 function isWide(cp) {
     return ((cp >= 0x1100 && cp <= 0x115f) ||

package/dist/tui/mouse.d.ts

@@ -37,11 +37,13 @@ export declare const MOUSE_DISABLE = "\u001B[?1000l\u001B[?1006l";
 /**
  * Whether the TUI may request terminal mouse reporting (wheel scrolling).
  *
- * Default OFF: with button reporting enabled the terminal routes
- * selection clicks and right-click paste to the app (which swallows them),
- * so native select-to-copy and right-click-paste break. Native selection
- * works out of the box; set `KLYRO_MOUSE=1` to opt into wheel scrolling
- * (Shift+drag still selects natively in most terminals).
+ * Default ON (opencode parity): the wheel scrolls the chat out of the box.
+ * Trade-off, stated plainly: with button reporting enabled the terminal
+ * routes plain selection clicks and right-clicks to the app (which drops
+ * them), so select-to-copy and right-click paste need Shift+drag /
+ * Shift+right-click in most terminals instead. Set `KLYRO_MOUSE=0` to opt
+ * out (fully native selection) and scroll with PgUp/PgDn, Ctrl+U/D,
+ * Shift+↑/↓, Home/End, or Space instead.
  */
 export declare function isMouseReportingEnabled(env?: Readonly<Record<string, string | undefined>>): boolean;
 export declare const PASTE_START = "\u001B[200~";

package/dist/tui/mouse.js

@@ -76,6 +76,7 @@ export class MouseFilter {
             const tail = n - i;
             if (tail <= 5) {
                 const rest = buf.subarray(i).toString('latin1');
+                // eslint-disable-next-line no-control-regex -- intentional: detecting split SGR/X10 mouse-sequence prefixes
                 if (/^\x1b\[<$/.test(rest) || /^\x1b\[<[\d;]+$/.test(rest) || /^\x1b\[M.{0,2}$/.test(rest)) {
                     this.pending = buf.subarray(i);
                     break;
@@ -95,14 +96,16 @@ export const MOUSE_DISABLE = '\x1b[?1000l\x1b[?1006l';
 /**
  * Whether the TUI may request terminal mouse reporting (wheel scrolling).
  *
- * Default OFF: with button reporting enabled the terminal routes
- * selection clicks and right-click paste to the app (which swallows them),
- * so native select-to-copy and right-click-paste break. Native selection
- * works out of the box; set `KLYRO_MOUSE=1` to opt into wheel scrolling
- * (Shift+drag still selects natively in most terminals).
+ * Default ON (opencode parity): the wheel scrolls the chat out of the box.
+ * Trade-off, stated plainly: with button reporting enabled the terminal
+ * routes plain selection clicks and right-clicks to the app (which drops
+ * them), so select-to-copy and right-click paste need Shift+drag /
+ * Shift+right-click in most terminals instead. Set `KLYRO_MOUSE=0` to opt
+ * out (fully native selection) and scroll with PgUp/PgDn, Ctrl+U/D,
+ * Shift+↑/↓, Home/End, or Space instead.
  */
 export function isMouseReportingEnabled(env = process.env) {
-    return env.KLYRO_MOUSE === '1';
+    return env.KLYRO_MOUSE !== '0';
 }
 export const PASTE_START = '\x1b[200~';
 export const PASTE_END = '\x1b[201~';

package/dist/tui/scroll-flow.test.js

@@ -34,7 +34,6 @@ describe('scroll flow diagnostics', () => {
         const { lastFrame } = render(_jsx(App, { ...PROPS, isFullscreen: true }));
         await tick(50);
         const frame = lastFrame() ?? '';
-        // eslint-disable-next-line no-console
         console.log(`[diag] frame rows=${rowsOf(frame)} cols~${(frame.split('\n')[0] ?? '').length}`);
         expect(rowsOf(frame)).toBeLessThanOrEqual(32);
     });

package/dist/tui/transcript-commands.d.ts

@@ -32,3 +32,17 @@ export interface TranscriptKey {
  *   Ctrl+Home → first · Ctrl+End → last · anything else → undefined.
  */
 export declare function getTranscriptCommand(input: string, key: TranscriptKey): TranscriptCommand | undefined;
+/**
+ * 4.4c — `# note` command: a line starting with `# ` (hash + space) is a
+ * session note, not a prompt. Returns the note text, or undefined when the
+ * line is not a note (a lone `#` or `#nospace` stays a regular prompt).
+ */
+export declare function parseSessionNote(line: string): string | undefined;
+/**
+ * Handle one input line as a potential `# note`. When it is a note, the
+ * text is appended as session-note feedback through `append` (the same
+ * channel as other command feedback — the caller's queuedAppend) and
+ * persisted via `persist` when the caller has a session-file hook.
+ * Returns true when the line was consumed as a note.
+ */
+export declare function handleHashNoteLine(line: string, append: (text: string) => void, persist?: (note: string) => void | Promise<void>): boolean;

package/dist/tui/transcript-commands.js

@@ -30,3 +30,34 @@ export function getTranscriptCommand(input, key) {
         return 'messages_last';
     return undefined;
 }
+/**
+ * 4.4c — `# note` command: a line starting with `# ` (hash + space) is a
+ * session note, not a prompt. Returns the note text, or undefined when the
+ * line is not a note (a lone `#` or `#nospace` stays a regular prompt).
+ */
+export function parseSessionNote(line) {
+    if (!line.startsWith('# '))
+        return undefined;
+    const note = line.slice(2).trim();
+    if (!note)
+        return undefined;
+    return note;
+}
+/**
+ * Handle one input line as a potential `# note`. When it is a note, the
+ * text is appended as session-note feedback through `append` (the same
+ * channel as other command feedback — the caller's queuedAppend) and
+ * persisted via `persist` when the caller has a session-file hook.
+ * Returns true when the line was consumed as a note.
+ */
+export function handleHashNoteLine(line, append, persist) {
+    const note = parseSessionNote(line);
+    if (note === undefined)
+        return false;
+    append(`[note] ${note}`);
+    try {
+        void persist?.(note);
+    }
+    catch { /* best-effort only */ }
+    return true;
+}

package/dist/util/log.d.ts

@@ -1,12 +1,21 @@
 /**
- * 1.5 — Logging (pino JSON to ~/.klyro/logs/klyro-YYYY-MM-DD.log, 14-day rotation, secret redaction)
- * Minimal implementation: JSONL append, redaction via secret-redactor, --debug pretty tee.
+ * Structured logging (1.5): pino JSON logs with secret redaction.
+ *
+ * - Destination: `KLYRO_LOG_DIR/klyro.log` (falls back to `~/.klyro`), with
+ *   the same 2 MiB rotate-to-`.1` cap as the TUI debug log.
+ * - Level from `KLYRO_LOG_LEVEL` (or `DEBUG`→debug); unknown values fall
+ *   back to `info` instead of throwing.
+ * - Every string is passed through the secret redactor first, and pino's
+ *   own `redact` paths cover common credential object shapes.
+ * - Under VITEST the logger is silent (level `silent`) so tests never touch
+ *   the real log file.
+ * - The logger never throws: an unwritable destination degrades to silent.
  */
-export interface LogEntry {
-    ts: string;
-    level: 'debug' | 'info' | 'warn' | 'error';
-    msg: string;
-    data?: unknown;
-}
-export declare function log(entry: LogEntry): Promise<void>;
-export declare function logSync(entry: LogEntry): void;
+import { type Logger } from 'pino';
+/** Shared process logger. Never throws; silent when logging is unavailable. */
+export declare function getLogger(): Logger;
+/** For tests: drop the cached instance so env changes take effect. */
+export declare function resetLoggerForTests(): void;
+/** Log helpers that redact string payloads before they reach pino. */
+export declare function logInfo(msg: string, data?: unknown): void;
+export declare function logDebug(msg: string, data?: unknown): void;

package/dist/util/log.js

@@ -1,75 +1,110 @@
 /**
- * 1.5 — Logging (pino JSON to ~/.klyro/logs/klyro-YYYY-MM-DD.log, 14-day rotation, secret redaction)
- * Minimal implementation: JSONL append, redaction via secret-redactor, --debug pretty tee.
+ * Structured logging (1.5): pino JSON logs with secret redaction.
+ *
+ * - Destination: `KLYRO_LOG_DIR/klyro.log` (falls back to `~/.klyro`), with
+ *   the same 2 MiB rotate-to-`.1` cap as the TUI debug log.
+ * - Level from `KLYRO_LOG_LEVEL` (or `DEBUG`→debug); unknown values fall
+ *   back to `info` instead of throwing.
+ * - Every string is passed through the secret redactor first, and pino's
+ *   own `redact` paths cover common credential object shapes.
+ * - Under VITEST the logger is silent (level `silent`) so tests never touch
+ *   the real log file.
+ * - The logger never throws: an unwritable destination degrades to silent.
  */
-import * as fs from 'node:fs/promises';
-import * as fsSync from 'node:fs';
-import * as path from 'node:path';
+import * as fs from 'node:fs';
 import * as os from 'node:os';
+import * as path from 'node:path';
+import pino from 'pino';
 import { redact } from '../policy/secret-redactor.js';
-function getLogDir() {
-    if (process.env.KLYRO_LOG_DIR)
-        return process.env.KLYRO_LOG_DIR;
-    const home = os.homedir() || process.cwd();
-    return path.join(home, '.klyro', 'logs');
+const ROTATE_BYTES = 2 * 1024 * 1024;
+const LEVELS = new Set(['fatal', 'error', 'warn', 'info', 'debug', 'trace', 'silent']);
+function level() {
+    if (process.env.VITEST)
+        return 'silent';
+    const raw = (process.env.KLYRO_LOG_LEVEL ?? (process.env.DEBUG ? 'debug' : 'info')).toLowerCase();
+    return (LEVELS.has(raw) ? raw : 'info');
 }
-function getLogFile() {
-    const dir = getLogDir();
-    const date = new Date().toISOString().slice(0, 10);
-    return path.join(dir, `klyro-${date}.log`);
+function logFile() {
+    const dir = process.env.KLYRO_LOG_DIR ?? path.join(os.homedir() || process.cwd(), '.klyro');
+    return path.join(dir, 'klyro.log');
 }
-async function rotateLogs() {
-    const dir = getLogDir();
+function rotateBestEffort(file) {
     try {
-        const files = await fs.readdir(dir);
-        const cutoff = Date.now() - 14 * 24 * 60 * 60 * 1000;
-        for (const f of files) {
-            if (!f.startsWith('klyro-') || !f.endsWith('.log'))
-                continue;
-            const fp = path.join(dir, f);
+        if (fs.statSync(file).size > ROTATE_BYTES) {
             try {
-                const st = await fs.stat(fp);
-                if (st.mtimeMs < cutoff)
-                    await fs.unlink(fp);
+                fs.rmSync(`${file}.1`, { force: true });
             }
             catch { /* ignore */ }
+            fs.renameSync(file, `${file}.1`);
         }
     }
-    catch { /* ignore dir not exists */ }
+    catch { /* missing — fine */ }
 }
-let _rotateDone = false;
-export async function log(entry) {
-    if (!_rotateDone) {
-        _rotateDone = true;
-        rotateLogs().catch(() => undefined);
+let cached = null;
+/** Shared process logger. Never throws; silent when logging is unavailable. */
+export function getLogger() {
+    if (cached)
+        return cached;
+    try {
+        // Tests must never touch the real log file: silent logger, no destination.
+        if (process.env.VITEST) {
+            cached = pino({ level: 'silent' });
+            return cached;
+        }
+        const file = logFile();
+        try {
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+        }
+        catch { /* ignore */ }
+        rotateBestEffort(file);
+        cached = pino({
+            level: level(),
+            redact: {
+                paths: ['apiKey', 'api_key', '*.apiKey', '*.api_key', '*.token', '*.password', '*.secret', 'headers.authorization', '*.authorization'],
+                censor: '[REDACTED]',
+            },
+        }, pino.destination({ dest: file, sync: true }));
     }
-    const redactedMsg = redact(entry.msg);
-    const redactedData = entry.data ? JSON.parse(redact(JSON.stringify(entry.data))) : undefined;
-    const line = JSON.stringify({ ...entry, msg: redactedMsg, data: redactedData }) + '\n';
-    const file = getLogFile();
+    catch {
+        try {
+            cached = pino({ level: 'silent' });
+        }
+        catch {
+            cached = { info: () => undefined, debug: () => undefined, error: () => undefined, warn: () => undefined };
+        }
+    }
+    return cached;
+}
+/** For tests: drop the cached instance so env changes take effect. */
+export function resetLoggerForTests() {
+    cached = null;
+}
+/** Log helpers that redact string payloads before they reach pino. */
+export function logInfo(msg, data) {
     try {
-        await fs.mkdir(path.dirname(file), { recursive: true });
-        await fs.appendFile(file, line, 'utf-8');
+        if (data === undefined)
+            getLogger().info(redact(msg));
+        else
+            getLogger().info(redactStructured(data), redact(msg));
     }
-    catch { /* ignore */ }
-    if (process.env.KLYRO_LOG_LEVEL === 'debug' || process.env.DEBUG) {
-        const pretty = `[${entry.level}] ${entry.msg}${entry.data ? ' ' + JSON.stringify(entry.data) : ''}`;
-        if (entry.level === 'error')
-            process.stderr.write(pretty + '\n');
+    catch { /* logging never breaks the run */ }
+}
+export function logDebug(msg, data) {
+    try {
+        if (data === undefined)
+            getLogger().debug(redact(msg));
         else
-            process.stdout.write(pretty + '\n');
+            getLogger().debug(redactStructured(data), redact(msg));
     }
+    catch { /* logging never breaks the run */ }
 }
-export function logSync(entry) {
-    const redactedMsg = redact(entry.msg);
-    const line = JSON.stringify({ ...entry, msg: redactedMsg, ts: entry.ts }) + '\n';
-    const file = getLogFile();
+function redactStructured(data) {
+    if (typeof data === 'string')
+        return redact(data);
     try {
-        fsSync.mkdirSync(path.dirname(file), { recursive: true });
-        fsSync.appendFileSync(file, line, 'utf-8');
+        return JSON.parse(redact(JSON.stringify(data)));
     }
-    catch { /* ignore */ }
-    if (process.env.KLYRO_LOG_LEVEL === 'debug') {
-        process.stderr.write(`[${entry.level}] ${redactedMsg}\n`);
+    catch {
+        return '[unserializable]';
     }
 }