klyro 1.0.18 → 1.0.21

package/dist/tui/app.js

@@ -10,6 +10,7 @@ import { execFileSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import * as path from 'node:path';
 import { TuiApprovalBridge, ApprovalModal } from './approval.js';
+import { approvalChoiceForKey } from '../policy/approval.js';
 import { parse as parseSlash, suggestCommands } from '../cli/slash/parser.js';
 import { loadCustomCommands, listCompletableFiles } from '../cli/slash/custom.js';
 import { loadMcpServers } from '../mcp/config.js';
@@ -136,10 +137,10 @@ function InputWithCursor({ input, cursor }) {
     if (cursor === null) {
         return _jsxs(Text, { wrap: "wrap", children: [safe, "|"] });
     }
-    const pos = Math.max(0, Math.min(cursor, safe.length));
-    const before = safe.slice(0, pos);
-    const ch = safe.slice(pos, pos + 1) || ' ';
-    const after = safe.slice(pos + 1);
+    const pos = Math.max(0, Math.min(cursor, gLength(safe)));
+    const before = gSlice(safe, 0, pos);
+    const ch = gSlice(safe, pos, pos + 1) || ' ';
+    const after = gSlice(safe, pos + 1);
     return (_jsxs(Text, { wrap: "wrap", children: [before, _jsx(Text, { inverse: true, children: ch }), after] }));
 }
 // design.md §23/§24 — terminal Markdown via tui/markdown.ts: headings,
@@ -181,6 +182,53 @@ function MarkdownText({ text, dim, width }) {
 // Position is an Anchor ({itemId, lineInItem}), never a raw row index (I4),
 // resolved per frame against measured *display lines* (I3, see measure.ts).
 // While anchored to 'bottom', new output follows; scrolling up pins to an
+// Display-state bound: the transcript array never grows without limit.
+// Beyond MAX_TRANSCRIPT_ITEMS the oldest non-user items go first (tool
+// rows, thinking, policy), then oldest-first. Pinned scroll anchors
+// survive via PRUNE re-stick (scroll-model); persistence is unaffected.
+const MAX_TRANSCRIPT_ITEMS = 500;
+export { MAX_TRANSCRIPT_ITEMS as TRANSCRIPT_ITEM_CAP };
+export function capTranscript(prev) {
+    const over = prev.length - MAX_TRANSCRIPT_ITEMS;
+    if (over <= 0)
+        return prev;
+    const isUser = (x) => x.kind === 'text' && x.role === 'user';
+    // Shed the oldest non-user items wherever they sit (a contiguous splice
+    // from the first drop point would also eat the user rows between them).
+    let toDrop = over;
+    const next = prev.filter((x) => {
+        if (toDrop > 0 && !isUser(x)) {
+            toDrop--;
+            return false;
+        }
+        return true;
+    });
+    // All-user transcript: oldest-first.
+    return next.length > MAX_TRANSCRIPT_ITEMS ? next.slice(next.length - MAX_TRANSCRIPT_ITEMS) : next;
+}
+// Grapheme-cluster cursor math: vimCursor/input positions are GRAPHEME
+// indices, never UTF-16 offsets — slicing a surrogate pair or ZWJ cluster
+// renders lone surrogates and corrupts emoji/CJK on h/l/x. Intl.Segmenter
+// with an Array.from fallback (splits pairs correctly, not clusters).
+let segmenterCache;
+function graphemes(s) {
+    try {
+        if (segmenterCache === undefined) {
+            const Seg = Intl.Segmenter;
+            segmenterCache = Seg ? new Seg(undefined, { granularity: 'grapheme' }) : null;
+        }
+        if (segmenterCache)
+            return [...segmenterCache.segment(s)].map((x) => x.segment);
+    }
+    catch { /* fall through to code points */ }
+    return Array.from(s);
+}
+function gLength(s) {
+    return graphemes(s).length;
+}
+function gSlice(s, start, end) {
+    return graphemes(s).slice(start, end).join('');
+}
 // item and freezes, accumulating newSinceUnstick lines for the `↓ N new` pill.
 //
 // Deviation from §7.1: Ink cannot overlay rows, so the badge renders as a
@@ -201,6 +249,8 @@ function useChatScroll(opts) {
     ctxRef.current = ctx;
     // Auto-follow wiring (§6): measured total deltas → CONTENT_GREW;
     // width change → REFLOW (§12). Initial anchor is 'bottom' → follow-tail.
+    // A pinned anchor whose item vanished (transcript pruning) re-sticks via
+    // PRUNE with a zeroed badge counter instead of inheriting stale counts.
     const prevTotalRef = useRef(index.total);
     const prevWidthRef = useRef(width);
     useEffect(() => {
@@ -208,6 +258,11 @@ function useChatScroll(opts) {
         const prevWidth = prevWidthRef.current;
         prevTotalRef.current = index.total;
         prevWidthRef.current = width;
+        const st = stateRef.current;
+        if (st.anchor.mode === 'pinned' && !keys.includes(st.anchor.itemId)) {
+            setState((s) => scrollReducer(s, { type: 'PRUNE' }, ctxRef.current));
+            return;
+        }
         if (width !== prevWidth) {
             setState((s) => scrollReducer(s, { type: 'REFLOW' }, ctxRef.current));
             return;
@@ -330,16 +385,17 @@ export function App(props) {
     const vimCursorRef = useRef(null);
     useEffect(() => { inputRef.current = input; }, [input]);
     useEffect(() => { vimCursorRef.current = vimCursor; }, [vimCursor]);
-    const clampCursor = (v, c) => c === null ? v.length : Math.max(0, Math.min(c, v.length));
+    const clampCursor = (v, c) => c === null ? gLength(v) : Math.max(0, Math.min(c, gLength(v)));
     const insertAtCursor = useCallback((text) => {
         const t = text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
         if (!t)
             return;
         const v = inputRef.current;
         const pos = clampCursor(v, vimCursorRef.current);
-        const nv = v.slice(0, pos) + t + v.slice(pos);
+        const nv = gSlice(v, 0, pos) + t + gSlice(v, pos);
         setInput(nv);
-        setVimCursor(pos + t.length >= nv.length ? null : pos + t.length);
+        const npos = pos + gLength(t);
+        setVimCursor(npos >= gLength(nv) ? null : npos);
         setHistIdx(null);
     }, []);
     const deleteBeforeCursor = useCallback(() => {
@@ -347,9 +403,9 @@ export function App(props) {
         const pos = clampCursor(v, vimCursorRef.current);
         if (pos === 0)
             return;
-        const nv = v.slice(0, pos - 1) + v.slice(pos);
+        const nv = gSlice(v, 0, pos - 1) + gSlice(v, pos);
         setInput(nv);
-        setVimCursor(pos - 1 >= nv.length ? null : pos - 1);
+        setVimCursor(pos - 1 >= gLength(nv) ? null : pos - 1);
         setHistIdx(null);
     }, []);
     // Shift+Enter intent: explicit shift+return, kitty/CSI-u sequence, legacy
@@ -603,7 +659,7 @@ export function App(props) {
         if (queuedInputs.length > 0 && status.status !== 'running' && !awaitingApproval) {
             const toSend = queuedInputs[0];
             setQueuedInputs((prev) => prev.slice(1));
-            setTranscript((prev) => [...prev, { id: nextId('user'), kind: 'text', text: toSend, role: 'user' }]);
+            setTranscript((prev) => [...capTranscript(prev), { id: nextId('user'), kind: 'text', text: toSend, role: 'user' }]);
             resetStream();
             const cmd = parseSlash(toSend.trim());
             if (cmd.kind === 'prompt')
@@ -619,7 +675,7 @@ export function App(props) {
             flushStream();
             resetStream();
         }
-        setTranscript((prev) => [...prev, item]);
+        setTranscript((prev) => [...capTranscript(prev), item]);
     }, [flushStream, resetStream]);
     const appendDelta = useCallback((text) => {
         if (!text)
@@ -797,7 +853,7 @@ export function App(props) {
             // preserving the message prefix (`look at @ut` → `look at @util.ts`).
             const m = /(?:^|\s)@(\S*)$/.exec(input);
             if (m && m[1] !== undefined) {
-                setInput(input.slice(0, input.length - m[1].length) + top.name.slice(1) + ' ');
+                setInput(gSlice(input, 0, gLength(input) - gLength(m[1])) + top.name.slice(1) + ' ');
             }
             else {
                 setInput(`${top.name} `);
@@ -898,8 +954,26 @@ export function App(props) {
                 return;
             }
         }
-        if (awaitingApproval)
+        // Approval gate: keys must never leak into the input while a prompt is
+        // pending. Decisive keys are routed straight through the bridge instead
+        // of being swallowed: the modal subscribes async, so a fast y/n landing
+        // between ask() and the modal's first render used to vanish and hang
+        // the run on a visibly-pending modal. bridge.resolve() is a no-op when
+        // nothing is pending, and the modal's own handler ignores the duplicate
+        // via the same guard — either order is safe. 'e' is deliberately NOT
+        // routed (it enters the modal's inline edit mode, not a decision).
+        if (awaitingApproval) {
+            if (key.return) {
+                bridge.resolve('deny');
+                return;
+            }
+            const choice = approvalChoiceForKey(inputStr);
+            if ((choice === 'allow' || choice === 'always' || choice === 'always-persist' || choice === 'deny') &&
+                inputStr !== 'e') {
+                bridge.resolve(choice);
+            }
             return;
+        }
         if (key.ctrl && inputStr === 'o') {
             const groups = grouped.filter((x) => typeof x.verb === 'string');
             const last = groups[groups.length - 1];
@@ -932,46 +1006,67 @@ export function App(props) {
                 setVimMode('insert');
                 return;
             }
-            const cur = vimCursor === null ? input.length : Math.max(0, Math.min(vimCursor, input.length));
-            const move = (d) => { setVimCursor(Math.max(0, Math.min(cur + d, input.length))); return true; };
+            // All positions below are grapheme indices (see graphemes()): cursor
+            // math, word motions, and deletions never split a cluster.
+            const gs = graphemes(input);
+            const cur = vimCursor === null ? gs.length : Math.max(0, Math.min(vimCursor, gs.length));
+            const move = (d) => { setVimCursor(Math.max(0, Math.min(cur + d, gs.length))); return true; };
             const isWord = (c) => /[A-Za-z0-9_]/.test(c);
             const wordFwd = (pos, n) => {
                 let p = pos;
-                for (let k = 0; k < n && p < input.length; k++) {
-                    while (p < input.length && isWord(input[p]))
+                for (let k = 0; k < n && p < gs.length; k++) {
+                    while (p < gs.length && isWord(gs[p]))
                         p++;
-                    while (p < input.length && !isWord(input[p]))
+                    while (p < gs.length && !isWord(gs[p]))
                         p++;
                 }
-                return Math.min(p, input.length);
+                return Math.min(p, gs.length);
             };
             const wordBack = (pos, n) => {
                 let p = pos;
                 for (let k = 0; k < n && p > 0; k++) {
-                    while (p > 0 && !isWord(input[p - 1]))
+                    while (p > 0 && !isWord(gs[p - 1]))
                         p--;
-                    while (p > 0 && isWord(input[p - 1]))
+                    while (p > 0 && isWord(gs[p - 1]))
                         p--;
                 }
                 return Math.max(0, p);
             };
+            const lineStart = (pos) => {
+                for (let i = pos - 1; i >= 0; i--) {
+                    if (gs[i] === '\n')
+                        return i + 1;
+                }
+                return 0;
+            };
+            const endOfNthLine = (from, n, keepNewline) => {
+                let seen = 0;
+                for (let i = from; i < gs.length; i++) {
+                    if (gs[i] === '\n') {
+                        seen++;
+                        if (seen === n)
+                            return keepNewline ? i : i + 1;
+                    }
+                }
+                return gs.length;
+            };
             const takeCount = () => {
                 const n = vimCountRef.current <= 1 ? 1 : vimCountRef.current;
                 vimCountRef.current = 0;
                 return n;
             };
             if (!key.ctrl && !key.meta && !key.return && !key.tab && !key.upArrow && !key.downArrow && !key.leftArrow && !key.rightArrow) {
-                // Pending `d` operator: second `d` deletes the current line.
+                // Pending `d` operator: second `d` deletes whole lines (count-aware).
                 if (vimPendingOp.current === 'd') {
                     vimPendingOp.current = null;
                     if (inputStr === 'd') {
-                        const start = input.lastIndexOf('\n', cur - 1) + 1;
-                        const nl = input.indexOf('\n', cur);
-                        const end = nl === -1 ? input.length : nl + 1;
-                        setInput(input.slice(0, start) + input.slice(end));
-                        setVimCursor(Math.min(start, Math.max(0, input.slice(0, start).length)));
+                        const n = takeCount();
+                        const start = lineStart(cur);
+                        const end = endOfNthLine(start, n, false);
+                        const nv = gs.slice(0, start).join('') + gs.slice(end).join('');
+                        setInput(nv);
+                        setVimCursor(Math.min(start, gLength(nv)) >= gLength(nv) ? null : Math.min(start, gLength(nv)));
                         setHistIdx(null);
-                        vimCountRef.current = 0;
                         return;
                     }
                     // Only dd is supported — anything else cancels the operator.
@@ -984,7 +1079,7 @@ export function App(props) {
                     return;
                 }
                 if (inputStr === 'a') {
-                    setVimCursor(Math.min(cur + 1, input.length));
+                    setVimCursor(Math.min(cur + 1, gs.length));
                     setVimMode('insert');
                     vimCountRef.current = 0;
                     return;
@@ -1003,24 +1098,24 @@ export function App(props) {
                     move(n);
                     return;
                 }
-                if (inputStr === '0' && vimCountRef.current === 0) {
-                    setVimCursor(0);
-                    return;
-                }
+                // `0` alone goes to line start; after digits it extends the count
+                // (`10` + `0` = 100, matching vim — the old code moved left by N).
                 if (inputStr === '0') {
-                    const n = takeCount();
-                    move(-n);
+                    if (vimCountRef.current === 0)
+                        setVimCursor(lineStart(cur));
+                    else
+                        vimCountRef.current = vimCountRef.current * 10;
                     return;
                 }
                 if (inputStr === '$') {
                     takeCount();
-                    setVimCursor(input.length);
+                    setVimCursor(gs.length);
                     return;
                 }
                 if (inputStr === 'x') {
                     const n = takeCount();
-                    if (cur < input.length)
-                        setInput(input.slice(0, cur) + input.slice(cur + n));
+                    if (cur < gs.length)
+                        setInput(gSlice(input, 0, cur) + gSlice(input, cur + n));
                     setHistIdx(null);
                     return;
                 }
@@ -1040,24 +1135,25 @@ export function App(props) {
                     return;
                 }
                 if (inputStr === 'D') {
-                    // Delete to end of current line (keep the newline).
-                    const nl = input.indexOf('\n', cur);
-                    const end = nl === -1 ? input.length : nl;
-                    setInput(input.slice(0, cur) + input.slice(end));
+                    // Delete to end of line, count-aware (2D spans two lines).
+                    const n = takeCount();
+                    const end = endOfNthLine(cur, n, true);
+                    setInput(gSlice(input, 0, cur) + gSlice(input, end));
                     setHistIdx(null);
-                    vimCountRef.current = 0;
                     return;
                 }
                 if (inputStr === 'j') {
+                    const n = takeCount();
                     if (isFullscreen && maxTop > 0)
-                        commands.lineDown();
-                    vimCountRef.current = 0;
+                        for (let i = 0; i < n; i++)
+                            commands.lineDown();
                     return;
                 }
                 if (inputStr === 'k') {
+                    const n = takeCount();
                     if (isFullscreen && maxTop > 0)
-                        commands.lineUp();
-                    vimCountRef.current = 0;
+                        for (let i = 0; i < n; i++)
+                            commands.lineUp();
                     return;
                 }
                 if (key.backspace || key.delete) {
@@ -1114,6 +1210,11 @@ export function App(props) {
                     disarmEsc();
                     return;
                 }
+                // This Esc is a cancel gesture, not half of an ESC+CR newline pair:
+                // disarm the 75ms Esc→Return heuristic so a fast follow-up Return
+                // submits instead of inserting a newline. (The vim-normal-mode
+                // partner below is intentionally untouched — it owns that meaning.)
+                escReturnAt.current = 0;
                 const t = Date.now();
                 if (t - escArmedAt.current < 1500) {
                     disarmEsc();
@@ -1201,7 +1302,7 @@ export function App(props) {
             setVimCursor(null);
             setHistIdx(null);
             pushHistory(v);
-            setTranscript((prev) => [...prev, { id: nextId('user'), kind: 'text', text: v, role: 'user' }]);
+            setTranscript((prev) => [...capTranscript(prev), { id: nextId('user'), kind: 'text', text: v, role: 'user' }]);
             resetStream();
             setSubmitKey((k) => k + 1);
             const cmd = parseSlash(v);
@@ -1221,15 +1322,19 @@ export function App(props) {
         // Idle Esc enters vim normal mode (vimLive parity for keyboard-only users).
         if (key.escape && vimMode === 'insert') {
             setVimMode('normal');
-            setVimCursor(inputRef.current.length);
+            setVimCursor(gLength(inputRef.current));
             return;
         }
     });
     // Single source of truth: package.json via version.ts — never hardcoded.
     const ver = props.version ?? readVersion();
     // Single cost/context source: model-aware registry rates + window.
-    const cost = estimateCost(status.model, status.usageInput, status.usageOutput);
-    const totalTokens = status.usageInput + status.usageOutput;
+    // Cache counters included: Anthropic bills them and they consume context.
+    const cost = estimateCost(status.model, status.usageInput, status.usageOutput, {
+        read: status.usageCacheRead,
+        write: status.usageCacheWrite,
+    });
+    const totalTokens = status.usageInput + status.usageOutput + (status.usageCacheRead ?? 0) + (status.usageCacheWrite ?? 0);
     const ctxWindow = getModelInfo(status.model).contextWindow;
     const ctxPct = totalTokens > 0 ? Math.round((totalTokens / ctxWindow) * 100) : 0;
     // Narrow terminals: compact hints so the status bar never wraps mid-word.

package/dist/tui/app.test.js

@@ -676,6 +676,27 @@ describe('App', () => {
         stdin.write('d');
         await waitForMatch(lastFrame, /Message Klyro/);
     });
+    it('vim motions never split emoji graphemes', async () => {
+        let hooks = null;
+        const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, isFullscreen: false, onMounted: (h) => {
+                hooks = { setVimMode: h.setVimMode };
+            } }));
+        await new Promise((r) => setTimeout(r, 50));
+        stdin.write('a🎉b');
+        await waitForMatch(lastFrame, /a🎉b/);
+        hooks.setVimMode('normal');
+        await waitForMatch(lastFrame, /--NORMAL--/);
+        // h/l move whole graphemes; x deletes the whole emoji, never a half.
+        stdin.write('0');
+        await new Promise((r) => setTimeout(r, 30));
+        stdin.write('l');
+        await new Promise((r) => setTimeout(r, 30));
+        stdin.write('x');
+        await waitForMatch(lastFrame, /ab/);
+        const frame = lastFrame() ?? '';
+        expect(frame).not.toMatch(/🎉/);
+        expect(frame).not.toMatch(/\uFFFD/); // no replacement char from split surrogates
+    });
     it('vim normal mode swallows typing, shows mode, i returns to insert', async () => {
         let hooks = null;
         const { stdin, lastFrame } = render(_jsx(App, { initialModel: "m", maxSteps: 10, cwd: "/test", onPrompt: async () => { }, onSlash: async () => { }, isFullscreen: false, onMounted: (h) => {

package/dist/tui/diff-parser.js

@@ -17,22 +17,45 @@
 export function parseUnifiedDiff(raw) {
     const out = [];
     let current = null;
+    // Candidate path from the `--- ` side: used when the `+++ ` side is
+    // /dev/null (deleted file) and therefore names no real path.
+    let fromPath = null;
     for (const line of raw.split('\n')) {
         if (line.startsWith('diff --git ')) {
             if (current)
                 out.push(current);
             current = null;
+            fromPath = null;
             continue;
         }
         if (line.startsWith('+++ ')) {
-            const path = stripDiffPrefix(line.slice(4));
-            if (path)
-                current = { path, lines: [] };
+            const toRaw = line.slice(4).trim();
+            // A new file section without a `diff --git` header must not swallow
+            // the previous file's lines — flush first.
+            if (current && current.lines.length > 0) {
+                out.push(current);
+                current = null;
+            }
+            const toPath = stripDiffPrefix(toRaw);
+            if (toPath && toPath !== '/dev/null') {
+                current = { path: toPath, lines: [] };
+            }
+            else if (fromPath && fromPath !== '/dev/null') {
+                // Deleted file: `--- a/f` / `+++ /dev/null` — keep the real path,
+                // not `/dev/null`.
+                current = { path: fromPath, lines: [] };
+            }
+            else {
+                current = null;
+            }
+            fromPath = null;
             continue;
         }
         if (line.startsWith('--- ')) {
-            // Path on the "from" side — we prefer the "to" path so the
-            // heading matches the file the user is editing.
+            // Stash the "from" path (see `+++ ` handling above) — we still
+            // prefer the "to" path so the heading matches the edited file.
+            const cand = stripDiffPrefix(line.slice(4).trim());
+            fromPath = cand || null;
             continue;
         }
         if (line.startsWith('@@')) {

package/dist/tui/markdown.js

@@ -146,7 +146,7 @@ export function highlightCodeLine(line, lang) {
     return parts;
 }
 /** Detect `file:line` / `file:line:col` references and attach OSC-8 hrefs. */
-export const FILE_LINE_RE = /((?:\.{0,2}\/)?[\w./-]+\.[a-zA-Z]+\w*):(\d+)(?::(\d+))?/g;
+export const FILE_LINE_RE = /(?<![:/\w])((?:\.{0,2}\/)?[\w./-]+\.[a-zA-Z]+\w*):(\d+)(?::(\d+))?/g;
 export function annotateFileLinks(parts) {
     const out = [];
     for (const p of parts) {

package/dist/tui/measure.js

@@ -85,8 +85,11 @@ export function blockHeight(b, termWidth) {
             return 1 + 1;
         case 'diff': {
             let n = 1; // summary
+            // Render prepends a 2-col `+ `/`- `/`  ` prefix per line (app.tsx),
+            // so measure against cw-2 — a bare-text wrap at full cw under-counts
+            // borderline lines by a row each and drifts the scroll anchor.
             for (const h of b.hunks)
-                n += 1 + h.lines.reduce((s, l) => s + wrapCount(l, cw), 0);
+                n += 1 + h.lines.reduce((s, l) => s + wrapCount(l, cw - 2), 0);
             return n + 1;
         }
         case 'plan':

package/dist/tui/scroll-model.d.ts

@@ -38,6 +38,8 @@ export type ScrollAction = {
 } | {
     type: 'CONTENT_GREW';
     lines: number;
+} | {
+    type: 'PRUNE';
 } | {
     type: 'REFLOW';
 };

package/dist/tui/scroll-model.js

@@ -65,6 +65,11 @@ export function scrollReducer(s, a, ctx) {
             }
             void maxTop;
             return { ...s, newSinceUnstick: s.newSinceUnstick + a.lines };
+        case 'PRUNE':
+            // Anchored item was compacted away: re-stick to bottom with a clean
+            // counter. Without the reset, a stale newSinceUnstick inflates the
+            // `↓ N new` badge after the re-stick.
+            return stickBottom();
         case 'REFLOW':
             return { ...s };
     }

package/dist/tui/status.d.ts

@@ -11,6 +11,9 @@ export interface StatusSnapshot {
     maxSteps: number;
     usageInput: number;
     usageOutput: number;
+    /** Prompt-cache counters (Anthropic-family): billed and context-consuming. */
+    usageCacheRead?: number;
+    usageCacheWrite?: number;
     repairs: number;
     status: 'idle' | 'running' | 'done' | 'error' | 'aborted';
     errorMessage?: string;

package/dist/verification/engine.js

@@ -7,7 +7,7 @@
  * On failure: returns { ok: false, failure } with the most recent
  * structured Failure (and the model has had up to N attempts to fix).
  */
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { detect, summarize } from './detect.js';
 import { filteredVerifyEnv } from './registry.js';
 import { redact } from '../policy/secret-redactor.js';
@@ -84,10 +84,26 @@ export async function verify(opts) {
         const outCap = cappedOutput(MAX_VERIFY_BYTES);
         const errCap = cappedOutput(MAX_VERIFY_BYTES);
         let done = false;
+        const killTree = () => {
+            // Match run_verify/shell_exec: tree-kill so grandchildren die too.
+            // child.kill() alone only takes the /bin/sh (or cmd) wrapper.
+            if (process.platform === 'win32') {
+                try {
+                    spawnSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { windowsHide: true });
+                }
+                catch { /* already gone */ }
+            }
+            else {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch { /* noop */ }
+            }
+        };
         const timer = setTimeout(() => {
             if (done)
                 return;
-            child.kill();
+            killTree();
             done = true;
             const so = outCap.text();
             const se = errCap.text();
@@ -103,6 +119,23 @@ export async function verify(opts) {
         }, timeout);
         child.stdout.on('data', (b) => outCap.push(b));
         child.stderr.on('data', (b) => errCap.push(b));
+        // A bad cwd (or missing shell) emits 'error' with no 'close' — without
+        // this the promise never settles and the run hangs to its own timeout.
+        child.on('error', (err) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            const raw = `verify spawn failed: ${err instanceof Error ? err.message : String(err)}`;
+            emitFailed('runtime');
+            resolve({
+                ok: false,
+                exitCode: -1,
+                stdout: outCap.text(),
+                stderr: raw,
+                failure: { type: 'runtime', files: [], raw, exitCode: -1 },
+            });
+        });
         child.on('close', (code) => {
             if (done)
                 return;

package/dist/verification/scoped.js

@@ -39,13 +39,25 @@ export function findRelatedTests(cwd, editedFiles) {
         const dir = path.dirname(edited);
         for (const t of allTests) {
             const tb = path.basename(t);
+            const stripped = path.basename(t, path.extname(t)).replace(/\.test|\.spec|test_/g, '');
             // name match: foo.ts -> foo.test.ts, test_foo.py, foo_spec.ts, etc.
-            if (tb.includes(base) || base.includes(path.basename(t, path.extname(t)).replace(/\.test|\.spec|test_/g, ''))) {
+            // Substring arms need a substantive core (>=4 chars): without the
+            // floor, `a.ts` matches nearly every test basename globally, and
+            // `catalog.ts` matches unrelated `cat.test.ts`. Exact stem equality
+            // always counts (covers single-char stems like `a.ts` -> `a.test.ts`).
+            if (stripped === base ||
+                (base.length >= 4 && tb.includes(base)) ||
+                (stripped.length >= 4 && base.includes(stripped))) {
                 related.add(path.relative(cwd, t));
             }
-            // same directory prefix also counts
-            if (t.startsWith(dir) && tb.includes(base.slice(0, 4)))
+            // same-directory similarity (not a raw string prefix: `/repo/foo2/…`
+            // must not match edited dir `/repo/foo`). The 4-char slice needs a
+            // real core name behind it, same floor as above.
+            const rel = path.relative(dir, t);
+            const inDir = rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+            if (inDir && base.length >= 4 && tb.toLowerCase().includes(base.slice(0, 4).toLowerCase())) {
                 related.add(path.relative(cwd, t));
+            }
         }
     }
     return [...related];
@@ -222,6 +234,7 @@ export async function syntaxCheck(cwd, file) {
         }
     }
     if (ext === '.py') {
+        let spawnFailed = false;
         const ok = await new Promise((resolve) => {
             // S2: verify commands run with filtered env; servers needing keys must use explicit config.
             const child = spawn('python', ['-m', 'py_compile', full], { cwd, shell: false, env: filteredVerifyEnv() });
@@ -236,11 +249,13 @@ export async function syntaxCheck(cwd, file) {
             } }, 5000);
             child.on('close', (code) => { if (done)
                 return; done = true; clearTimeout(t); resolve(code === 0); });
+            // A missing interpreter must not read as "syntax OK" — that false
+            // negative lets broken files pass scoped verification.
             child.on('error', () => { if (done)
-                return; done = true; clearTimeout(t); resolve(true); });
+                return; done = true; clearTimeout(t); spawnFailed = true; resolve(false); });
         });
         if (!ok)
-            return { ok: false, error: `syntax error in ${file} (py_compile)` };
+            return { ok: false, error: spawnFailed ? `python unavailable for py_compile (${file})` : `syntax error in ${file} (py_compile)` };
     }
     return { ok: true };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klyro",
-  "version": "1.0.18",
+  "version": "1.0.21",
   "description": "Klyro — autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
   "type": "module",
   "main": "dist/index.js",