kritya 0.8.26-beta → 0.8.28-beta

package/dist/mcp/client.js

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { writeStderr } from "../stderr.js";
 import { VERSION } from "../version.js";
 import { NOOP_TRACER } from "../telemetry/tracer.js";
 import { McpAuthRequiredError } from "./oauth.js";
@@ -644,14 +645,14 @@ function exposedToolName(server, toolName) {
  * is registered on the transport so `tools/call` can mirror argument values
  * into `Mcp-Param-{Name}` headers later — see `ModernHttpTransport.
  * setToolHeaderMap`/`send`. Logged the same way other "skip with a warning"
- * MCP failures are (`process.stderr.write("kritya: ...")`).
+ * MCP failures are (`writeStderr("kritya: ...")`).
  */
 function filterHeaderAnnotatedTools(server, specs, transport) {
     const kept = [];
     for (const spec of specs) {
         const result = validateToolHeaders(spec.inputSchema);
         if (!result.ok) {
-            process.stderr.write(`kritya: MCP server "${server}" tool "${spec.name}" excluded — invalid x-mcp-header ` +
+            writeStderr(`kritya: MCP server "${server}" tool "${spec.name}" excluded — invalid x-mcp-header ` +
                 `annotation: ${result.reason}\n`);
             continue;
         }
@@ -675,7 +676,7 @@ function filterSchemaSafeTools(server, specs) {
     for (const spec of specs) {
         const result = checkSchemaSafety(spec.inputSchema);
         if (!result.ok) {
-            process.stderr.write(`kritya: MCP server "${server}" tool "${spec.name}" excluded — unsafe inputSchema: ` +
+            writeStderr(`kritya: MCP server "${server}" tool "${spec.name}" excluded — unsafe inputSchema: ` +
                 `${result.reason}\n`);
             continue;
         }
@@ -852,7 +853,7 @@ export async function connectServer(name, cfg, trace) {
         }
         else {
             status.error = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`kritya: MCP server "${name}" failed to start: ${status.error}\n`);
+            writeStderr(`kritya: MCP server "${name}" failed to start: ${status.error}\n`);
             span.setStatus("ERROR", status.error);
             // status.error comes from the (untrusted) server process's own error
             // output, which could echo back an env var or header value it was

package/dist/net/urlSafety.js

@@ -1,5 +1,5 @@
 import { lookup as dnsLookup } from "node:dns/promises";
-import { Agent } from "undici";
+import { Agent, Dispatcher1Wrapper } from "undici";
 /**
  * Shared "is this host on a private/internal network" check, used by both
  * fetch_url (src/tools/fetchUrl.ts) and the MCP HTTP transport guard
@@ -210,7 +210,7 @@ export function assertSafeUrl(label, url) {
  * it's safe to share across every call site that uses the same policy.
  */
 function createPinnedDispatcher(isBlockedAddress) {
-    return new Agent({
+    return new Dispatcher1Wrapper(new Agent({
         connect: {
             lookup(hostname, options, callback) {
                 dnsLookup(hostname, { all: true })
@@ -235,7 +235,7 @@ function createPinnedDispatcher(isBlockedAddress) {
                     .catch((err) => callback(err, []));
             },
         },
-    });
+    }));
 }
 /** For callers that never allow loopback either (fetch_url). */
 export const pinnedDispatcher = createPinnedDispatcher(isPrivateOrLoopbackHost);

package/dist/plugins/discover.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { writeStderr } from "../stderr.js";
 /**
  * Scans each root for `<name>/plugin.json` folders, in name order, and reports
  * both what loaded and why anything didn't. Roots that don't exist are
@@ -73,7 +74,7 @@ export function scanPluginsDetailed(roots) {
     return { loaded: [...seen.values()], skipped };
 }
 let warnSink = (message) => {
-    process.stderr.write(`kritya: ${message}\n`);
+    writeStderr(`kritya: ${message}\n`);
 };
 function warn(message) {
     warnSink(message);

package/dist/plugins/mcp.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { writeStderr } from "../stderr.js";
 function isServerConfig(v) {
     if (!v || typeof v !== "object")
         return false;
@@ -65,7 +66,7 @@ export function scanPluginMcpServers(plugins) {
  * map for labeling `/mcp` output. Skips are reported via `warn` (defaults to
  * stderr, like scanPlugins/scanSkills).
  */
-export function loadPluginMcpServers(plugins, warn = (m) => process.stderr.write(`kritya: ${m}\n`)) {
+export function loadPluginMcpServers(plugins, warn = (m) => writeStderr(`kritya: ${m}\n`)) {
     const { loaded, skipped } = scanPluginMcpServers(plugins);
     for (const s of skipped) {
         warn(`skipping mcp server "${s.name}" from plugin "${s.pluginName}": ${s.reason}`);

package/dist/repomap/repoMap.js

@@ -9,7 +9,7 @@
  */
 import fs from "node:fs/promises";
 import path from "node:path";
-import fg from "fast-glob";
+import { glob } from "tinyglobby";
 import { isPathSafe, resolveSafe } from "../tools/common.js";
 import { loadIgnorePatterns } from "../tools/ignore.js";
 import { CODE_EXTENSIONS, extractSymbols } from "./symbols.js";
@@ -88,13 +88,13 @@ export async function buildRepoMap(workspace, subdir = ".", options = {}) {
     const opts = { ...DEFAULTS, ...options };
     const root = resolveSafe(workspace, subdir || ".");
     const scopeLabel = path.relative(workspace, root) || "(workspace root)";
-    const found = await fg("**/*", {
+    const found = await glob("**/*", {
         cwd: root,
         dot: false,
         onlyFiles: true,
         followSymbolicLinks: false,
+        expandDirectories: false,
         ignore: ["**/node_modules/**", "**/.git/**", ...loadIgnorePatterns(workspace)],
-        suppressErrors: true,
     });
     // Keep only source files, then rank by path so the maxFiles cap (which bounds
     // how many files we actually read) retains the most important ones.

package/dist/stderr.js

@@ -0,0 +1,47 @@
+/**
+ * Where a warning goes while someone else owns the terminal.
+ *
+ * Ink owns the terminal for the whole time the UI is up. It keeps its frame in
+ * a known place, and anything that reaches the terminal *through* Ink is
+ * written between clearing that frame and repainting it — so the text lands
+ * above the UI and stays there. A raw `process.stderr.write` bypasses all of
+ * that: the bytes land wherever the cursor happened to be, in the middle of
+ * the frame, and the next repaint erases and redraws against a line count that
+ * no longer matches the screen. The warning comes out garbled and takes the
+ * frame with it.
+ *
+ * Ink patches `console` for exactly this reason, but `console.error` is not
+ * available to the plain module functions that raise these warnings — an agent
+ * loop, an MCP client, a plugin loader — and a hook (`useStderr`) cannot be
+ * called from one. So the UI registers a sink on mount and clears it on
+ * unmount, and everything else goes through `writeStderr`, which uses the sink
+ * when there is one and raw stderr when there is not: CLI subcommands, headless
+ * runs, and anything before the UI mounts or after it is torn down.
+ *
+ * Deliberately not used by `crash.ts`: by the time a crash handler runs, the
+ * UI is being torn down and its frame state is not trustworthy, so the crash
+ * report goes straight to stderr.
+ */
+let sink;
+/** Installed by the mounted UI. Pass `undefined` on unmount. */
+export function setStderrSink(fn) {
+    sink = fn;
+}
+/** Write a warning to stderr, through the UI when one is mounted. */
+export function writeStderr(text) {
+    if (sink) {
+        try {
+            sink(text);
+            return;
+        }
+        catch {
+            // A sink that throws must not cost us the warning itself.
+        }
+    }
+    try {
+        process.stderr.write(text);
+    }
+    catch {
+        // stderr is gone; there is nowhere left to put it.
+    }
+}

package/dist/telemetry/metrics.js

@@ -11,6 +11,17 @@ export const NOOP_METER = {
     stop() { },
 };
 export const DEFAULT_LATENCY_BOUNDS_MS = [10, 50, 100, 250, 500, 1000, 2500, 5000, 10000, 30000];
+/**
+ * Buckets for Ink's per-frame `onRender` timing.
+ *
+ * The default latency bounds are useless here: drawing a frame is a
+ * sub-millisecond to low-single-digit-millisecond affair, so every sample would
+ * land in the first bucket and the histogram would say nothing. These cluster
+ * below the frame budget instead, and 33ms is the edge that matters — Ink caps
+ * rendering at 30fps (1000 / 30 ≈ 33.3ms), so a sample past it is a frame the
+ * UI could not draw on time.
+ */
+export const RENDER_BOUNDS_MS = [0.25, 0.5, 1, 2, 4, 8, 16, 24, 33, 66, 133];
 function nowUnixNano() {
     return (BigInt(Date.now()) * 1000000n).toString();
 }

package/dist/telemetry/tracer.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { CONFIG_DIR } from "../config/config.js";
 import { hardenWindowsDir } from "../config/winAcl.js";
 import { debugLog, warnPersistenceFailure } from "../config/debug.js";
+import { writeStderr } from "../stderr.js";
 import { VERSION } from "../version.js";
 import { encodeSpan, postOtlp } from "./otlp.js";
 function nowUnixNano() {
@@ -164,12 +165,7 @@ function fileSink(file) {
 }
 function consoleSink() {
     return (span) => {
-        try {
-            process.stderr.write(`[otel] ${JSON.stringify(span)}\n`);
-        }
-        catch {
-            // best-effort
-        }
+        writeStderr(`[otel] ${JSON.stringify(span)}\n`);
     };
 }
 function resourceFor(sessionId) {

package/dist/tools/glob.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import fg from "fast-glob";
+import { glob } from "tinyglobby";
 import { isPathSafe, truncateResult, countLines } from "./common.js";
 import { loadIgnorePatterns } from "./ignore.js";
 export const globTool = {
@@ -17,14 +17,14 @@ export const globTool = {
     summarize: (args) => `Glob ${args.pattern}`,
     resultSummary: (output) => countLines(output, "match", "matches"),
     async execute(args, ctx) {
-        // Models on Windows sometimes emit backslash paths; fast-glob needs forward slashes.
-        const files = await fg(String(args.pattern).replaceAll("\\", "/"), {
+        // Models on Windows sometimes emit backslash paths; glob patterns need forward slashes.
+        const files = await glob(String(args.pattern).replaceAll("\\", "/"), {
             cwd: ctx.workspace,
             dot: false,
             onlyFiles: true,
             followSymbolicLinks: false,
+            expandDirectories: false,
             ignore: ["**/node_modules/**", "**/.git/**", ...loadIgnorePatterns(ctx.workspace)],
-            suppressErrors: true,
         });
         const safeFiles = files.filter((f) => isPathSafe(ctx.workspace, path.join(ctx.workspace, f)));
         const capped = safeFiles.sort().slice(0, 200);

package/dist/tools/grep.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import fg from "fast-glob";
+import { glob } from "tinyglobby";
 import { isPathSafe, resolveSafe, safeCompileRegex, truncateResult, meaningfulLines, } from "./common.js";
 import { loadIgnorePatterns } from "./ignore.js";
 const MAX_MATCHES = 200;
@@ -34,14 +34,14 @@ export const grepTool = {
     async execute(args, ctx) {
         const regex = safeCompileRegex(String(args.pattern));
         const searchRoot = resolveSafe(ctx.workspace, String(args.path ?? "."));
-        // Models on Windows sometimes emit backslash paths; fast-glob needs forward slashes.
-        const files = await fg(String(args.include ?? "**/*").replaceAll("\\", "/"), {
+        // Models on Windows sometimes emit backslash paths; glob patterns need forward slashes.
+        const files = await glob(String(args.include ?? "**/*").replaceAll("\\", "/"), {
             cwd: searchRoot,
             dot: false,
             onlyFiles: true,
             followSymbolicLinks: false,
+            expandDirectories: false,
             ignore: ["**/node_modules/**", "**/.git/**", ...loadIgnorePatterns(ctx.workspace)],
-            suppressErrors: true,
         });
         const matches = [];
         for (const file of files) {

package/dist/tools/ignore.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 const IGNORE_FILE = ".krityaignore";
-/** Converts one gitignore-style line into fast-glob ignore pattern(s). */
+/** Converts one gitignore-style line into glob ignore pattern(s). */
 function toGlobPatterns(line) {
     let pattern = line.trim();
     if (!pattern || pattern.startsWith("#") || pattern.startsWith("!"))
@@ -15,7 +15,7 @@ function toGlobPatterns(line) {
     const base = anchored ? pattern : `**/${pattern}`;
     return isDir ? [`${base}/**`] : [base, `${base}/**`];
 }
-/** Reads `<workspace>/.krityaignore` (gitignore-style, one pattern per line) as fast-glob ignore patterns. */
+/** Reads `<workspace>/.krityaignore` (gitignore-style, one pattern per line) as glob ignore patterns. */
 export function loadIgnorePatterns(workspace) {
     let raw;
     try {

package/dist/ui/ApiKeySetupPrompt.js

@@ -1,7 +1,7 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from "react";
 import { Box, Text, useInput } from "ink";
-import TextInput from "ink-text-input";
+import { TextInput } from "./TextInput.js";
 /**
  * Shown once, only when the active provider has no API key resolved, on the
  * interactive TTY path (never from headless — see runHeadless in

package/dist/ui/App.js

@@ -1,12 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Fragment, useCallback, useEffect, useRef, useState } from "react";
-import { Box, Static, Text, useApp, useInput, useStdout } from "ink";
-import TextInput from "ink-text-input";
+import { Box, Static, Text, useApp, useBoxMetrics, useInput, useStderr, useWindowSize, } from "ink";
 import fs from "node:fs";
-import fg from "fast-glob";
+import { glob } from "tinyglobby";
 import stringWidth from "string-width";
 import { gitDiffStat } from "../git/git.js";
 import { modelDisplaySlug } from "../config/models.js";
+import { setStderrSink } from "../stderr.js";
+import { openInEditor } from "./openInEditor.js";
 import { SessionStore } from "../session/store.js";
 import { defaultSandboxMode, sandboxAvailable } from "../shell/sandbox.js";
 import { resolveSafe } from "../tools/common.js";
@@ -18,8 +19,10 @@ import { PermissionPrompt } from "./PermissionPrompt.js";
 import { SelectList } from "./SelectList.js";
 import { Spinner } from "./Spinner.js";
 import { StatusLine } from "./StatusLine.js";
+import { StreamViewport } from "./StreamViewport.js";
+import { TextInput } from "./TextInput.js";
 import { TranscriptItem } from "./TranscriptItem.js";
-import { tailForViewport, terminalColumns, terminalRows } from "./viewport.js";
+import { terminalColumns, terminalRows } from "./viewport.js";
 import { BUILTIN_COMMANDS, runCommand } from "../commands/registry.js";
 import { mcpPrompts, mcpResources } from "../mcp/client.js";
 import { useAgent } from "./useAgent.js";
@@ -27,12 +30,58 @@ const MENTION_RE = /(^|\s)@([^\s@]*)$/;
 const MENTION_ALL_RE = /(?:^|\s)@([^\s@]+)/g;
 const MAX_MENTION_CHARS = 8000;
 const IMAGE_RE = /\.(png|jpe?g|gif|webp|bmp)$/i;
-// Erase screen + scrollback, then home the cursor (same sequence Ink itself
-// uses for its own "content taller than the terminal" clear path).
-const CLEAR_TERMINAL = "\x1b[2J\x1b[3J\x1b[H";
 export function App({ agent, workspace, modelRef, providerRef, config, resumedCount, initialTasks, undoStack, uiBridge, resumeSessions, customCommands = [], mcpToolCount = 0, onSwitchClient, onRequestPermissionReady, onRequestElicitationReady, privacyMode, firstLaunch, }) {
-    const { exit } = useApp();
-    const { stdout } = useStdout();
+    const { exit, suspendTerminal, waitUntilRenderFlush } = useApp();
+    /**
+     * Leave, but not until the screen has caught up.
+     *
+     * Ink's `exit()` tears the tree down in the same tick it is called, so a
+     * state update made in that same tick — the last line of a transcript, a
+     * "goodbye" item — is committed to a tree that is already being unmounted and
+     * never reaches the terminal. Verified: `setState(x); exit();` drops `x`,
+     * while deferring `exit()` by one macrotask draws it. `waitUntilRenderFlush()`
+     * is Ink's own barrier for exactly this — it yields so React can commit, then
+     * settles the throttled frame timer and waits for the write to drain.
+     */
+    const exitAfterFlush = useCallback(async () => {
+        await waitUntilRenderFlush();
+        exit();
+    }, [exit, waitUntilRenderFlush]);
+    /**
+     * Hand warnings raised outside React a way through Ink.
+     *
+     * Agent loops, MCP clients and plugin loaders are plain module functions, so
+     * they cannot call useStderr() themselves and had been writing straight to
+     * process.stderr — which Ink knows nothing about, so the text landed in the
+     * middle of the frame and the next repaint drew against the wrong line count.
+     * Registering Ink's own writer for the lifetime of the UI puts them back
+     * inside the clear-write-repaint sandwich. Cleared on unmount so the fallback
+     * is raw stderr again for anything that outlives the UI. See src/stderr.ts.
+     */
+    const { write: writeStderr } = useStderr();
+    useEffect(() => {
+        setStderrSink(writeStderr);
+        return () => setStderrSink(undefined);
+    }, [writeStderr]);
+    // Ink 8 types `stdout` as a plain Node stream, so the terminal's dimensions
+    // come from useWindowSize() rather than stdout.columns / stdout.rows — and
+    // it drives the re-layout on resize by itself. Kritya used to wipe the screen
+    // and remount <Static> on every column change, because Ink erased its live
+    // region against a stale line count after the terminal reflowed already-
+    // printed lines. Ink 8 fixed that class of bug itself: it redraws the frame
+    // when the terminal loses rows, keeps the content above the frame when rows
+    // shrink, and preserves scrollback — which the old `\x1b[3J` clear threw
+    // away. So the workaround is gone and nothing here watches for resizes.
+    const windowSize = useWindowSize();
+    const columns = terminalColumns(windowSize);
+    const rows = terminalRows(windowSize);
+    // The transcript column's real width, measured rather than assumed. The
+    // wrapped renderers lay out to this, so if the chrome around them ever gains
+    // padding the prose still breaks at the right column. Falls back to the
+    // terminal width for the first frame, before layout has run.
+    const rootRef = useRef(null);
+    const { clientWidth } = useBoxMetrics(rootRef);
+    const contentWidth = clientWidth || columns;
     const [input, setInput] = useState("");
     const [inputKey, setInputKey] = useState(0);
     const [steerInput, setSteerInput] = useState("");
@@ -42,84 +91,21 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
     const [fileList, setFileList] = useState([]);
     const [verbose, setVerbose] = useState(false);
     const [elapsed, setElapsed] = useState(0);
-    const [staticKey, setStaticKey] = useState(0);
     const inputHistory = useRef([]);
     const histIndex = useRef(-1); // -1 means "current, not browsing history"
-    /**
-     * Ctrl-chord bookkeeping for the text inputs.
-     *
-     * Ink delivers a keypress to every `useInput` hook, and ink-text-input
-     * ignores only Ctrl+C — so Ctrl+K and Ctrl+O run their shortcut *and* get
-     * typed into the box as a bare "k"/"o". Hitting the kill switch left junk on
-     * the prompt line, which the next Enter would have sent as a message.
-     *
-     * The two hooks can fire in either order, so both directions are covered:
-     * `ctrlChord` makes onChange drop the echoed letter when the shortcut ran
-     * first, and re-setting the value from `inputRef` undoes it when the input
-     * ran first. `inputRef` tracks committed state, so it always holds the value
-     * from before this keypress.
-     */
-    const ctrlChord = useRef(null);
-    const inputRef = useRef("");
-    const steerInputRef = useRef("");
-    useEffect(() => {
-        inputRef.current = input;
-    }, [input]);
-    useEffect(() => {
-        steerInputRef.current = steerInput;
-    }, [steerInput]);
-    const noteCtrlChord = (letter) => {
-        ctrlChord.current = letter;
-        setInput(inputRef.current);
-        setSteerInput(steerInputRef.current);
-        setTimeout(() => {
-            ctrlChord.current = null;
-        }, 0);
-    };
-    /** The change a Ctrl chord echoed into the box, rather than a real keystroke. */
-    const isCtrlEcho = (prev, next) => ctrlChord.current !== null && next === prev + ctrlChord.current;
-    // Terminals that reflow their buffer on resize (e.g. VS Code's xterm.js)
-    // rewrap already-printed full-width lines (banner art, box borders) to the
-    // new column count on their own, before Ink's next redraw arrives. Ink then
-    // erases based on a stale line count from before that reflow, so it clears
-    // the wrong number of rows and leaves stale copies of boxes/banners behind
-    // — compounding on every resize. There's no way to reflow in place safely,
-    // so once the column count actually settles on a new value (ignoring
-    // height-only resizes, e.g. VS Code adding a split terminal), wipe the
-    // screen ourselves and remount <Static> so Ink reprints everything fresh
-    // onto a blank canvas. The manual clear is safe here specifically because
-    // the forced remount immediately triggers Ink's own static-flush path,
-    // which resyncs its internal line-count bookkeeping — it's only unsafe to
-    // write raw ANSI without following it with something that resets that
-    // bookkeeping.
-    const lastColumns = useRef(stdout?.columns);
-    useEffect(() => {
-        if (!stdout)
-            return;
-        let timer;
-        const onResize = () => {
-            clearTimeout(timer);
-            timer = setTimeout(() => {
-                if (stdout.columns === lastColumns.current)
-                    return;
-                lastColumns.current = stdout.columns;
-                stdout.write(CLEAR_TERMINAL);
-                setStaticKey((k) => k + 1);
-            }, 150);
-        };
-        stdout.on("resize", onResize);
-        return () => {
-            clearTimeout(timer);
-            stdout.off("resize", onResize);
-        };
-    }, [stdout]);
+    // Ctrl-chord bookkeeping used to live here: Ink delivers a keypress to every
+    // `useInput` hook, and ink-text-input swallowed only Ctrl+C, so Ctrl+K and
+    // Ctrl+O ran their shortcut *and* typed a bare "k"/"o" into the prompt — which
+    // the next Enter would have sent as a message. Kritya's own TextInput drops
+    // every ctrl/meta chord before it reaches the buffer, so there is nothing left
+    // to undo and the workaround is gone.
     const refreshFileList = useCallback(() => {
-        fg("**/*", {
+        glob("**/*", {
             cwd: workspace,
             dot: false,
             onlyFiles: true,
+            expandDirectories: false,
             ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", ...loadIgnorePatterns(workspace)],
-            suppressErrors: true,
         })
             .then((files) => setFileList(files.sort().slice(0, 2000)))
             .catch(() => { });
@@ -221,13 +207,37 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
         setInputKey((k) => k + 1);
         setFileIndex(0);
     };
+    // Ctrl+E opens the file the agent touched most recently in the user's
+    // $EDITOR, suspending the UI while the editor owns the terminal. Ink
+    // restores everything and repaints from scratch on resume; a hand-edit is
+    // reported by the undo stack's watcher via onExternalEdit like any other
+    // outside edit. Guarded against double presses — suspending twice throws.
+    const editorBusy = useRef(false);
+    const openInEditorFlow = useCallback(async () => {
+        if (editorBusy.current)
+            return;
+        const target = undoStack.lastTouchedFile();
+        if (!target) {
+            addItem({
+                kind: "info",
+                text: "Ctrl+E: the agent hasn't touched any file yet this session.",
+            });
+            return;
+        }
+        editorBusy.current = true;
+        try {
+            await openInEditor(suspendTerminal, target.absPath);
+        }
+        finally {
+            editorBusy.current = false;
+        }
+    }, [suspendTerminal, undoStack, addItem]);
     useInput((_input, key) => {
         // Ctrl+K is the kill switch, and it comes before every other binding and
         // phase check on purpose: a panic button that only works from the idle
         // input line is not a panic button. It fires mid-stream, mid-tool, and
         // while a permission prompt is on screen.
         if (key.ctrl && _input === "k") {
-            noteCtrlChord(_input);
             if (killed)
                 return; // already stopped; /kill off is the way back
             engageKill("Ctrl+K");
@@ -239,10 +249,20 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
         }
         // Ctrl+O toggles showing full tool output.
         if (key.ctrl && _input === "o") {
-            noteCtrlChord(_input);
             setVerbose((v) => !v);
             return;
         }
+        // Ctrl+E opens the most recently agent-touched file in $EDITOR. Only
+        // from the idle prompt — never mid-turn, so the editor can't race the
+        // agent over the same file.
+        if (key.ctrl && _input === "e") {
+            if (phase !== "input") {
+                setActivity("Ctrl+E works from the idle prompt — stop the current turn first.");
+                return;
+            }
+            void openInEditorFlow();
+            return;
+        }
         // Shift+Tab cycles normal → accept-edits → plan → normal. Only from the
         // plain input state — not mid-permission-prompt, mid-resume-picker, etc.
         if (key.tab && key.shift && phase === "input") {
@@ -360,7 +380,7 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
             costReport,
             statusReport,
             gitDiffStat,
-            exit,
+            exit: exitAfterFlush,
         };
         void runCommand(cmd, ctx);
     };
@@ -455,7 +475,7 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
             addItem({ kind: "info", text: `Attached ${images.length} image(s).` });
         await runAgent(await expandMentions(text), images);
     };
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: items, children: (item) => _jsx(TranscriptItem, { item: item, verbose: verbose, stdout: stdout }, item.id) }, staticKey), firstLaunch && items.length <= 1 && phase === "input" && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 2, children: [_jsx(Text, { dimColor: true, children: "Try asking:" }), _jsx(Text, { dimColor: true, children: " \u00B7 Explain this codebase" }), _jsx(Text, { dimColor: true, children: " \u00B7 Find and fix failing tests" }), _jsx(Text, { dimColor: true, children: " \u00B7 Review my uncommitted changes" }), _jsx(Text, { dimColor: true, children: " \u00B7 Add a new feature" }), _jsx(Text, { dimColor: true, children: " \u00B7 /help for commands" })] })), stream ? (_jsx(Box, { marginBottom: 1, children: _jsx(Markdown, { text: tailForViewport(stream, terminalColumns(stdout), terminalRows(stdout)), streaming: true }) })) : null, tasks.length > 0 && (_jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: "blue", paddingX: 1, width: Math.min(terminalColumns(stdout) - 2, Math.max(...tasks.map((t) => stringWidth(t.text))) + 6), children: tasks.map((t, i) => (_jsxs(Text, { color: t.status === "done" ? "green" : t.status === "in_progress" ? "yellow" : undefined, dimColor: t.status === "pending", children: [t.status === "done" ? "☑" : t.status === "in_progress" ? "◐" : "☐", " ", t.text] }, i))) })), phase === "working" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Spinner, { label: 
+    return (_jsxs(Box, { ref: rootRef, flexDirection: "column", children: [_jsx(Static, { items: items, children: (item) => (_jsx(TranscriptItem, { item: item, verbose: verbose, contentWidth: contentWidth }, item.id)) }), firstLaunch && items.length <= 1 && phase === "input" && (_jsxs(Box, { flexDirection: "column", marginBottom: 1, paddingLeft: 2, children: [_jsx(Text, { dimColor: true, children: "Try asking:" }), _jsx(Text, { dimColor: true, children: " \u00B7 Explain this codebase" }), _jsx(Text, { dimColor: true, children: " \u00B7 Find and fix failing tests" }), _jsx(Text, { dimColor: true, children: " \u00B7 Review my uncommitted changes" }), _jsx(Text, { dimColor: true, children: " \u00B7 Add a new feature" }), _jsx(Text, { dimColor: true, children: " \u00B7 /help for commands" })] })), stream ? (_jsx(StreamViewport, { rows: rows, children: _jsx(Markdown, { text: stream, streaming: true, width: contentWidth }) })) : null, tasks.length > 0 && (_jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: "blue", paddingX: 1, width: Math.min(columns - 2, Math.max(...tasks.map((t) => stringWidth(t.text))) + 6), children: tasks.map((t, i) => (_jsxs(Text, { color: t.status === "done" ? "green" : t.status === "in_progress" ? "yellow" : undefined, dimColor: t.status === "pending", children: [t.status === "done" ? "☑" : t.status === "in_progress" ? "◐" : "☐", " ", t.text] }, i))) })), phase === "working" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Spinner, { label: 
                         // The workflow prefix rides on every branch, not just "thinking":
                         // during a phase you want to know which phase a tool call belongs
                         // to just as much as which phase is being reasoned about.
@@ -468,7 +488,7 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
                                         ? activity
                                         : thinking
                                             ? "thinking… (Esc to cancel)"
-                                            : "working… (Esc to cancel)") }), inFlight.length > 1 && (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: inFlight.map((t) => (_jsxs(Text, { dimColor: true, children: ["\u00B7 ", t.status ? `${t.summary} — ${t.status}` : t.summary] }, t.id))) })), _jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsx(Text, { color: "yellow", children: "\u21B3 " }), _jsx(TextInput, { value: steerInput, onChange: (v) => setSteerInput((prev) => (isCtrlEcho(prev, v) ? prev : v)), onSubmit: (value) => {
+                                            : "working… (Esc to cancel)") }), inFlight.length > 1 && (_jsx(Box, { flexDirection: "column", marginLeft: 2, children: inFlight.map((t) => (_jsxs(Text, { dimColor: true, children: ["\u00B7 ", t.status ? `${t.summary} — ${t.status}` : t.summary] }, t.id))) })), _jsxs(Box, { borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsx(Text, { color: "yellow", children: "\u21B3 " }), _jsx(TextInput, { value: steerInput, onChange: setSteerInput, onSubmit: (value) => {
                                     const text = value.trim();
                                     setSteerInput("");
                                     if (!text)
@@ -493,7 +513,7 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
                             value: s.file,
                             hint: `${s.date} · ${s.count} msgs`,
                         })), onSelect: onResumeSelect, onCancel: () => onResumeSelect("") })] })), phase === "input" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { color: "green", children: "\u276F " }), _jsx(TextInput, { value: input, onChange: (v) => {
-                                    setInput((prev) => (isCtrlEcho(prev, v) ? prev : v.replace(/\t/g, "")));
+                                    setInput(v.replace(/\t/g, ""));
                                     setCmdIndex(0);
                                     setFileIndex(0);
                                 }, onSubmit: handleSubmit }, inputKey)] }), suggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [(() => {

package/dist/ui/ElicitationPrompt.js

@@ -1,7 +1,7 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from "react";
 import { Box, Text, useInput } from "ink";
-import TextInput from "ink-text-input";
+import { TextInput } from "./TextInput.js";
 import { SelectList } from "./SelectList.js";
 /**
  * One field at a time, same reasoning as McpTrustPrompt's one-server-at-a-time

package/dist/ui/Markdown.js

@@ -1,6 +1,6 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from "react";
-import { Box, Text, useStdout } from "ink";
+import { Box, Text, useWindowSize } from "ink";
 import stringWidth from "string-width";
 import { tokenizeLine } from "./highlight.js";
 import { parseInline, tokensWidth, wrapInline } from "./inline.js";
@@ -37,9 +37,9 @@ function Marked({ text, width, marker, indent, ...style }) {
  * bullets, quotes, rules, tables, and inline emphasis. Deliberately
  * lightweight — not a full implementation.
  */
-export function Markdown({ text, streaming = false }) {
-    const { stdout } = useStdout();
-    const width = Math.max(20, terminalColumns(stdout) - 2);
+export function Markdown({ text, streaming = false, width: measuredWidth, }) {
+    const windowSize = useWindowSize();
+    const width = Math.max(20, measuredWidth ?? terminalColumns(windowSize) - 2);
     const blocks = React.useMemo(() => renderBlocks(text, width, streaming), [text, width, streaming]);
     return _jsx(Box, { flexDirection: "column", children: blocks });
 }

package/dist/ui/McpTrustPrompt.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from "react";
 import { Box, Text } from "ink";
 import { SelectList } from "./SelectList.js";

package/dist/ui/PermissionPrompt.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useInput } from "ink";
 import { SelectList } from "./SelectList.js";
 const MAX_DIFF_LINES = 30;

package/dist/ui/SelectList.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from "react";
 import { Box, Text, useInput } from "ink";
 export function SelectList({ items, onSelect, onCancel, }) {