@nanhara/hara 0.119.2 → 0.121.0

package/dist/tools/builtin.js

@@ -1,11 +1,14 @@
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { dirname, resolve, isAbsolute } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { resolve, isAbsolute } from "node:path";
 import { stdout as procOut } from "node:process";
 import { registerTool } from "./registry.js";
 import { runShell } from "../sandbox.js";
-import { nearestPaths } from "../fs-walk.js";
+import { isProbablyBinary, nearestPaths } from "../fs-walk.js";
 import { emitDiff } from "../diff.js";
 import { recordEdit } from "../undo.js";
+import { atomicWriteText } from "../fs-write.js";
+import { invalidateFileCandidates } from "../context/mentions.js";
+import { BinaryFileError, streamFileSlice } from "../fs-read.js";
 import { startJob, listJobs, tailJob, killJob } from "../exec/jobs.js";
 import { hostsInCommand, isNetworkGitOp, hostFromConnectError, isConnectFailure, markHostUnreachable, isHostUnreachable, unreachableHostsSnapshot, } from "./net-reachability.js";
 const MAX = 100_000;
@@ -43,8 +46,9 @@ export function capHeadTail(s, max = MAX) {
     const head = Math.floor(max * 0.6);
     return s.slice(0, head) + `\n…[${s.length - max} chars truncated]…\n` + s.slice(s.length - (max - head));
 }
-const READ_LINES = 2000; // default lines per read_file call (a long file is read in slices, not dumped whole)
+const READ_LINES = 300; // sized to stay useful under the global 24k-char tool-result context boundary
 const LINE_CAP = 2000; // chars per line before truncation (minified bundles / data lines)
+const BUFFERED_READ_BYTES = 4 * 1024 * 1024;
 /** Render a line slice of a file, cat -n style. The old read_file dumped the WHOLE file (100K-char cap,
  *  tail simply lost) — on long files that both flooded the context (~25k tokens per read, again on every
  *  re-read) and made everything past the cap unreachable. Now: line numbers (anchor for edits and for
@@ -71,22 +75,31 @@ export function renderFileSlice(text, offset, limit) {
 }
 registerTool({
     name: "read_file",
-    description: "Read a UTF-8 text file; returns cat -n style numbered lines. Reads up to 2000 lines by default — for a longer file pass offset/limit to read the next slice (the output header tells you the total and where to continue). Prefer grep to locate, then read just that region.",
+    description: "Read a UTF-8 text file; returns cat -n style numbered lines. Reads up to 300 lines by default — for a longer file pass offset/limit to read the next slice (the header tells you where to continue). Large files are streamed instead of loaded whole. Prefer grep to locate, then read just that region.",
     input_schema: {
         type: "object",
         properties: {
             path: { type: "string", description: "File path, relative to cwd or absolute" },
             offset: { type: "number", description: "1-based line number to start from (for long files)" },
-            limit: { type: "number", description: "max lines to return (default 2000)" },
+            limit: { type: "number", description: "max lines to return (default 300)" },
         },
         required: ["path"],
     },
     kind: "read",
     async run(input, ctx) {
+        const p = abs(input.path, ctx.cwd);
         try {
-            return cap(renderFileSlice(await readFile(abs(input.path, ctx.cwd), "utf8"), input.offset, input.limit));
+            const info = await stat(p);
+            if (info.size > BUFFERED_READ_BYTES)
+                return cap(await streamFileSlice(p, input.offset, input.limit ?? READ_LINES, { lineCap: LINE_CAP }));
+            const buf = await readFile(p);
+            if (isProbablyBinary(buf))
+                throw new BinaryFileError(p);
+            return cap(renderFileSlice(buf.toString("utf8"), input.offset, input.limit));
         }
         catch (e) {
+            if (e instanceof BinaryFileError)
+                return `Error: cannot read ${input.path}: file appears binary; use an image/media-specific tool or inspect it with \`file\`.`;
             const near = nearestPaths(ctx.cwd, input.path);
             return `Error: cannot read ${input.path}: ${e.code ?? e.message}.` + (near.length ? ` Did you mean: ${near.join(", ")}?` : "");
         }
@@ -106,17 +119,27 @@ registerTool({
     kind: "edit",
     async run(input, ctx) {
         const p = abs(input.path, ctx.cwd);
+        if (typeof input.content !== "string")
+            return "Error: write_file `content` must be a string. No changes written.";
         let prev = null;
         try {
             prev = await readFile(p, "utf8");
         }
-        catch {
-            /* new file */
+        catch (error) {
+            if (error?.code !== "ENOENT")
+                return `Error: cannot inspect ${input.path}: ${error?.code ?? error?.message}. No changes written.`;
+        }
+        if (prev === input.content)
+            return `Unchanged ${p} (${input.content.length} chars already match).`;
+        try {
+            await atomicWriteText(p, input.content, { expected: prev });
+        }
+        catch (error) {
+            return `Error: cannot write ${input.path}: ${error?.message ?? String(error)} No changes written.`;
         }
-        await mkdir(dirname(p), { recursive: true });
-        await writeFile(p, input.content, "utf8");
         emitDiff(input.path, prev ?? "", input.content, ctx.ui);
         recordEdit([{ path: input.path, absPath: p, before: prev }]);
+        invalidateFileCandidates(ctx.cwd);
         return `Wrote ${String(input.content).length} chars to ${p}`;
     },
 });

package/dist/tools/edit.js

@@ -1,10 +1,12 @@
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { isAbsolute, resolve } from "node:path";
 import { registerTool } from "./registry.js";
 import { nearestPaths } from "../fs-walk.js";
 import { emitDiff } from "../diff.js";
 import { applyEdits } from "./apply-core.js";
 import { recordEdit } from "../undo.js";
+import { atomicWriteText } from "../fs-write.js";
+import { invalidateFileCandidates } from "../context/mentions.js";
 registerTool({
     name: "edit_file",
     description: "Edit an existing file by replacing exact strings. Provide a single `old_string`/`new_string`, " +
@@ -53,9 +55,15 @@ registerTool({
         const res = applyEdits(text, edits);
         if ("error" in res)
             return `Error: ${res.error} in ${input.path}. No changes written.`;
-        await writeFile(p, res.text, "utf8");
+        try {
+            await atomicWriteText(p, res.text, { expected: text });
+        }
+        catch (error) {
+            return `Error: cannot edit ${input.path}: ${error?.message ?? String(error)} No changes written.`;
+        }
         emitDiff(input.path, text, res.text, ctx.ui);
         recordEdit([{ path: input.path, absPath: p, before: text }]);
+        invalidateFileCandidates(ctx.cwd);
         const note = res.fuzzy ? " (quote-normalized)" : "";
         const plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
         return `Edited ${input.path}: ${plural(edits.length, "edit")}, ${plural(res.total, "replacement")}${note}.`;

package/dist/tools/patch.js

@@ -1,11 +1,13 @@
 // apply_patch — change MULTIPLE files atomically (all-or-nothing). Everything is validated and
 // computed in memory first; nothing is written unless every change applies cleanly.
-import { readFile, writeFile, mkdir, unlink } from "node:fs/promises";
-import { isAbsolute, resolve, dirname } from "node:path";
+import { lstat, readFile, unlink } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
 import { registerTool } from "./registry.js";
 import { applyEdits } from "./apply-core.js";
 import { emitDiff } from "../diff.js";
 import { recordEdit } from "../undo.js";
+import { atomicWriteText, FileChangedError } from "../fs-write.js";
+import { invalidateFileCandidates } from "../context/mentions.js";
 registerTool({
     name: "apply_patch",
     description: "Change SEVERAL files in one atomic step (all-or-nothing). `changes` is an array of " +
@@ -51,13 +53,29 @@ registerTool({
         const abs = (pth) => (isAbsolute(pth) ? pth : resolve(ctx.cwd, pth));
         // PHASE 1 — validate + compute every change in memory; bail before writing anything.
         const plans = [];
+        const plannedPaths = new Set();
         for (let i = 0; i < changes.length; i++) {
             const ch = changes[i];
             const tag = `change ${i + 1}/${changes.length}`;
             if (typeof ch.path !== "string" || !ch.path)
                 return `Error: ${tag} is missing a path. Nothing written.`;
             const p = abs(ch.path);
-            const type = ch.type ?? (ch.edits ? "update" : "create");
+            if (plannedPaths.has(p))
+                return `Error: ${tag} repeats path ${ch.path}. Combine edits for one file into a single change. Nothing written.`;
+            plannedPaths.add(p);
+            let type = ch.type ?? (ch.edits ? "update" : "create");
+            // Backward-compatible shorthand: {path, content} updates an existing file and creates a missing
+            // one. An EXPLICIT type:create is stricter and never clobbers an existing path.
+            if (!ch.type && !ch.edits) {
+                try {
+                    await lstat(p);
+                    type = "update";
+                }
+                catch (error) {
+                    if (error?.code !== "ENOENT")
+                        return `Error: ${tag} cannot inspect ${ch.path}: ${error?.message ?? String(error)}. Nothing written.`;
+                }
+            }
             if (type === "delete") {
                 let before;
                 try {
@@ -71,16 +89,15 @@ registerTool({
             else if (type === "create") {
                 if (typeof ch.content !== "string")
                     return `Error: ${tag} create ${ch.path} needs \`content\`. Nothing written.`;
-                let before = "";
-                let existed = false;
                 try {
-                    before = await readFile(p, "utf8");
-                    existed = true;
+                    await lstat(p);
+                    return `Error: ${tag} create ${ch.path}: path already exists (use type:update to replace it). Nothing written.`;
                 }
-                catch {
-                    /* new file */
+                catch (error) {
+                    if (error?.code !== "ENOENT")
+                        return `Error: ${tag} create ${ch.path}: ${error?.message ?? String(error)}. Nothing written.`;
                 }
-                plans.push({ path: ch.path, abs: p, type, before, after: ch.content, existed });
+                plans.push({ path: ch.path, abs: p, type, before: "", after: ch.content, existed: false });
             }
             else {
                 // update
@@ -108,27 +125,39 @@ registerTool({
         try {
             for (const pl of plans) {
                 if (pl.type === "delete") {
+                    let current;
+                    try {
+                        current = await readFile(pl.abs, "utf8");
+                    }
+                    catch {
+                        throw new FileChangedError(pl.path);
+                    }
+                    if (current !== pl.before)
+                        throw new FileChangedError(pl.path);
                     await unlink(pl.abs);
                 }
                 else {
-                    await mkdir(dirname(pl.abs), { recursive: true });
-                    await writeFile(pl.abs, pl.after, "utf8");
+                    await atomicWriteText(pl.abs, pl.after, { expected: pl.existed ? pl.before : null });
                 }
                 applied.push(pl);
             }
         }
         catch (e) {
+            const rollbackFailures = [];
             for (const pl of applied.reverse()) {
                 try {
                     if (pl.type === "create" && !pl.existed)
                         await unlink(pl.abs); // remove a file we created
                     else
-                        await writeFile(pl.abs, pl.before, "utf8"); // restore an updated/deleted file's prior content
+                        await atomicWriteText(pl.abs, pl.before); // restore an updated/deleted file's prior content
                 }
-                catch {
-                    /* best-effort rollback */
+                catch (rollbackError) {
+                    rollbackFailures.push(`${pl.path}: ${rollbackError?.message ?? String(rollbackError)}`);
                 }
             }
+            if (rollbackFailures.length) {
+                return `Error: apply_patch failed (${e instanceof Error ? e.message : String(e)}); rollback was INCOMPLETE: ${rollbackFailures.join("; ")}. Inspect these files before continuing.`;
+            }
             return `Error: apply_patch failed writing a file (${e instanceof Error ? e.message : String(e)}) — rolled back, nothing left changed.`;
         }
         // All writes succeeded → now show diffs + record the undo snapshot.
@@ -137,6 +166,7 @@ registerTool({
             return pl.type === "delete" ? `deleted ${pl.path}` : `${pl.type === "create" ? "created" : "updated"} ${pl.path}`;
         });
         recordEdit(plans.map((pl) => ({ path: pl.path, absPath: pl.abs, before: pl.existed ? pl.before : null })));
+        invalidateFileCandidates(ctx.cwd);
         return `apply_patch: ${plans.length} file(s) — ${summary.join("; ")}.`;
     },
 });

package/dist/tools/registry.js

@@ -1,3 +1,4 @@
+import { limitToolResult } from "./result-limit.js";
 /** Names of required parameters that are ABSENT (undefined/null) in a tool call's input. Defends
  *  against models that drop parameters outright (observed: qwen3.7-plus losing write_file's
  *  path/content mid-stream) — the loop rejects the call with a precise error instead of executing
@@ -9,8 +10,16 @@ export function missingRequired(tool, input) {
     return req.filter((k) => obj[k] === undefined || obj[k] === null);
 }
 const registry = new Map();
+let specsCache = null;
 export function registerTool(t) {
-    registry.set(t.name, t);
+    const run = t.run;
+    registry.set(t.name, {
+        ...t,
+        // Apply the context boundary at registration so every caller (main loop, tests, embedders) gets
+        // identical behavior instead of relying on one orchestration path to remember the cap.
+        run: async (input, ctx) => limitToolResult(await run(input, ctx)),
+    });
+    specsCache = null;
 }
 export function getTool(name) {
     return registry.get(name);
@@ -20,9 +29,14 @@ export function getTools() {
 }
 /** Provider-neutral tool specs derived from the registry. */
 export function toolSpecs() {
-    return getTools().map((t) => ({
-        name: t.name,
-        description: t.description,
-        input_schema: t.input_schema,
-    }));
+    if (!specsCache) {
+        specsCache = getTools().map((t) => ({
+            name: t.name,
+            description: t.description,
+            input_schema: t.input_schema,
+        }));
+    }
+    // Callers commonly filter the array for a role. Return a shallow copy so that never mutates the
+    // stable cached snapshot shared by subsequent agent rounds.
+    return specsCache.slice();
 }

package/dist/tools/result-limit.js

@@ -0,0 +1,37 @@
+// One invariant for every registered tool: no single result may monopolize the model context. Individual
+// tools can use tighter domain-specific limits, but this final boundary also covers plugins/new tools.
+export const MAX_TOOL_RESULT_CHARS = 24_000;
+function safeHead(value, end) {
+    let at = Math.max(0, Math.min(value.length, end));
+    if (at > 0 && /[\uD800-\uDBFF]/.test(value[at - 1] ?? ""))
+        at--;
+    return value.slice(0, at);
+}
+function safeTail(value, start) {
+    let at = Math.max(0, Math.min(value.length, start));
+    if (at < value.length && /[\uDC00-\uDFFF]/.test(value[at] ?? ""))
+        at++;
+    return value.slice(at);
+}
+/** Keep actionable beginnings and endings while bounding the exact string persisted in history. */
+export function limitToolResult(value, max = MAX_TOOL_RESULT_CHARS) {
+    const text = typeof value === "string" ? value : String(value ?? "");
+    const cap = Math.max(0, Math.floor(max));
+    if (text.length <= cap)
+        return text;
+    if (cap === 0)
+        return "";
+    let omitted = text.length - cap;
+    let fullMarker = "";
+    // The marker consumes part of the budget too. Iterate twice so its count reflects the actual payload
+    // removed rather than understating it by roughly the marker's own length.
+    for (let i = 0; i < 2; i++) {
+        fullMarker = `\n…[hara: ${omitted} chars omitted; narrow the query or continue read_file with offset/limit]…\n`;
+        omitted = text.length - Math.max(0, cap - fullMarker.length);
+    }
+    const marker = fullMarker.length < cap ? fullMarker : "…[truncated]…".slice(0, cap);
+    const room = cap - marker.length;
+    const headChars = Math.floor(room * 0.6);
+    const tailChars = room - headChars;
+    return safeHead(text, headChars) + marker + safeTail(text, text.length - tailChars);
+}

package/dist/tui/App.js

@@ -516,7 +516,7 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
         const askTextFn = (title) => new Promise((resolve) => setAskText({ title, resolve }));
         // ask_user: when options are given, offer them as a select + a "type my own" escape hatch; otherwise (or
         // when the user chooses to type their own) capture a free-text line. Returns the chosen/typed answer.
-        const OTHER = "__ask_other__"; // sentinel value for the "type my own" option
+        const OTHER = "\\0__ask_other__"; // escaped sentinel keeps this TypeScript file text-only
         const askFn = async (question, options) => {
             if (options && options.length) {
                 const choice = await openPrompt(question, [

package/dist/tui/InputBox.js

@@ -14,10 +14,11 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 //      of leaning on ink's soft-wrap of a single <Text>, which mis-aligns wrapped rows against the
 //      "› " prompt gutter and reflows unpredictably as you type.
 import { Box, Text, useInput, useStdout } from "ink";
-import { memo, useMemo, useState } from "react";
+import { memo, useMemo, useRef, useState } from "react";
 import { fileCandidates } from "../context/mentions.js";
 import { imagePathFromPaste } from "../images.js";
 import { vimNormal } from "./vim.js";
+import { ComposerHistory, moveCursorLine, nextGraphemeIndex, previousGraphemeIndex, previousWordIndex, } from "./input-history.js";
 export const MODES = ["suggest", "auto-edit", "full-auto", "plan"];
 export const nextMode = (m) => MODES[(MODES.indexOf(m) + 1) % MODES.length];
 const tok = (n) => (n >= 1000 ? `${(n / 1000).toFixed(1)}k` : `${n}`);
@@ -312,15 +313,30 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
     const [mode, setMode] = useState("insert"); // vim only
     const [pending, setPending] = useState(""); // vim operator-pending (d/c/g)
     const [register, setRegister] = useState(""); // vim yank/delete register
+    const historyRef = useRef(null);
+    if (!historyRef.current)
+        historyRef.current = new ComposerHistory();
+    const inputHistory = historyRef.current;
     const set = (v, c) => {
+        inputHistory.abandonNavigation();
         setValue(v);
         setCursor(c);
         setSel(0);
         setDismissed(false);
     };
+    const snapshot = () => ({ value, attachments: images, pastes });
+    const restore = (draft) => {
+        setValue(draft.value);
+        setCursor(draft.value.length);
+        setImages(draft.attachments);
+        setPastes(draft.pastes);
+        setSel(0);
+        setDismissed(false);
+    };
     // Attach an image: drop a highlighted `[Image #N]` token inline at the cursor and track the file
     // (codex / Claude-Code style). Backspace over the token removes both.
     const addImage = (img) => {
+        inputHistory.abandonNavigation();
         const tok = `[Image #${images.length + 1}]`;
         const before = value.slice(0, cursor);
         const ins = (before && !/\s$/.test(before) ? " " : "") + tok + " ";
@@ -334,6 +350,7 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
     // the box: typing stays smooth (the VALUE stays short), the box stays small, and a multi-line paste
     // can no longer fire the newline-submit path mid-paste. Expanded back to the full text on submit.
     const addPaste = (text) => {
+        inputHistory.abandonNavigation();
         const lines = text.split("\n").length;
         const tok = `[Paste #${pastes.length + 1} +${lines} lines]`;
         const before = value.slice(0, cursor);
@@ -348,6 +365,7 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
     const submit = (text) => {
         if (!text.trim() && images.length === 0)
             return; // nothing to send
+        inputHistory.record(snapshot());
         onSubmit?.(expandPastes(text), images.length ? images : undefined);
         set("", 0);
         setImages([]);
@@ -365,6 +383,7 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
     const complete = (cand) => {
         if (!mention)
             return;
+        inputHistory.abandonNavigation();
         const before = value.slice(0, mention.start); // includes the leading '@'
         const after = value.slice(cursor);
         const insert = cand.endsWith("/") ? cand : cand + " "; // dirs keep drilling; files end the mention
@@ -406,6 +425,8 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
                 return setCursor((c) => Math.max(0, c - 1));
             if (input && !key.ctrl && !key.meta) {
                 const st = vimNormal({ value, cursor, mode, pending, register }, input);
+                if (st.value !== value)
+                    inputHistory.abandonNavigation();
                 setValue(st.value);
                 setCursor(st.cursor);
                 setMode(st.mode);
@@ -416,20 +437,54 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
             }
             return;
         }
+        if (key.upArrow) {
+            const onFirstLine = cursor === 0 || value.lastIndexOf("\n", cursor - 1) < 0;
+            if (onFirstLine) {
+                const draft = inputHistory.older(snapshot());
+                if (draft)
+                    restore(draft);
+            }
+            else {
+                setCursor(moveCursorLine(value, cursor, -1));
+            }
+            return;
+        }
+        if (key.downArrow) {
+            const onLastLine = value.indexOf("\n", cursor) < 0;
+            if (onLastLine) {
+                const draft = inputHistory.newer();
+                if (draft)
+                    restore(draft);
+            }
+            else {
+                setCursor(moveCursorLine(value, cursor, 1));
+            }
+            return;
+        }
         if (key.return) {
+            if (key.shift || key.meta) {
+                set(value.slice(0, cursor) + "\n" + value.slice(cursor), cursor + 1);
+                return;
+            }
             submit(value);
             return;
         }
         if (key.leftArrow)
-            return setCursor((c) => Math.max(0, c - 1));
+            return setCursor((c) => previousGraphemeIndex(value, c));
         if (key.rightArrow)
-            return setCursor((c) => Math.min(value.length, c + 1));
+            return setCursor((c) => nextGraphemeIndex(value, c));
         if (key.ctrl && input === "a")
             return setCursor(0);
         if (key.ctrl && input === "e")
             return setCursor(value.length);
         if (key.ctrl && input === "u")
             return set(value.slice(cursor), 0);
+        if (key.ctrl && input === "w") {
+            const start = previousWordIndex(value, cursor);
+            return set(value.slice(0, start) + value.slice(cursor), start);
+        }
+        if (key.ctrl && input === "k")
+            return set(value.slice(0, cursor), cursor);
         if (key.ctrl && input === "v") {
             // paste a screenshot / image from the OS clipboard
             const img = onClipboardImage?.();
@@ -442,6 +497,7 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
                 const head = value.slice(0, cursor);
                 const pm = /\[Paste #(\d+) \+\d+ lines\]\s?$/.exec(head); // paste token deletes whole + renumbers
                 if (pm) {
+                    inputHistory.abandonNavigation();
                     const n = Number(pm[1]);
                     const kept = head.slice(0, pm.index) + value.slice(cursor);
                     const renumbered = kept.replace(/\[Paste #(\d+)( \+\d+ lines\])/g, (m2, d, tail) => (Number(d) > n ? `[Paste #${Number(d) - 1}${tail}` : m2));
@@ -454,6 +510,7 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
                 }
                 const tm = /\[Image #(\d+)\]\s?$/.exec(head); // backspacing over an attachment token removes it whole
                 if (tm) {
+                    inputHistory.abandonNavigation();
                     const n = Number(tm[1]);
                     const kept = head.slice(0, tm.index) + value.slice(cursor);
                     const renumbered = kept.replace(/\[Image #(\d+)\]/g, (m2, d) => (Number(d) > n ? `[Image #${Number(d) - 1}]` : m2));
@@ -464,7 +521,8 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
                     setDismissed(false);
                     return;
                 }
-                set(value.slice(0, cursor - 1) + value.slice(cursor), cursor - 1);
+                const previous = previousGraphemeIndex(value, cursor);
+                set(value.slice(0, previous) + value.slice(cursor), previous);
             }
             return;
         }

package/dist/tui/input-history.js

@@ -0,0 +1,167 @@
+// Pure composer state: bounded shell-style history plus Unicode-safe cursor helpers. Keeping this out
+// of the Ink component makes navigation deterministic and avoids copying a growing history on each key.
+const cloneDraft = (draft) => ({
+    value: draft.value,
+    attachments: [...draft.attachments],
+    pastes: [...draft.pastes],
+});
+const draftChars = (draft) => draft.value.length + draft.pastes.reduce((sum, paste) => sum + paste.length, 0) + draft.attachments.length * 128;
+/** Bounded in-process history. The draft that existed before Up is restored after navigating Down. */
+export class ComposerHistory {
+    maxEntries;
+    maxChars;
+    entries = [];
+    cursor = null;
+    scratch = null;
+    totalChars = 0;
+    constructor(maxEntries = 100, maxChars = 2_000_000) {
+        this.maxEntries = maxEntries;
+        this.maxChars = maxChars;
+    }
+    get browsing() {
+        return this.cursor !== null;
+    }
+    get length() {
+        return this.entries.length;
+    }
+    record(draft) {
+        this.abandonNavigation();
+        const chars = draftChars(draft);
+        // A giant paste is already retained by the conversation history. Do not duplicate an entry larger
+        // than the entire composer-history budget just to support Up-arrow recall.
+        if (chars > this.maxChars || this.maxEntries <= 0)
+            return;
+        this.entries.push({ draft: cloneDraft(draft), chars });
+        this.totalChars += chars;
+        while (this.entries.length > this.maxEntries || this.totalChars > this.maxChars) {
+            this.totalChars -= this.entries.shift().chars;
+        }
+    }
+    older(current) {
+        if (!this.entries.length)
+            return null;
+        if (this.cursor === null) {
+            this.scratch = cloneDraft(current);
+            this.cursor = this.entries.length - 1;
+        }
+        else if (this.cursor > 0) {
+            this.cursor--;
+        }
+        return cloneDraft(this.entries[this.cursor].draft);
+    }
+    newer() {
+        if (this.cursor === null)
+            return null;
+        if (this.cursor < this.entries.length - 1) {
+            this.cursor++;
+            return cloneDraft(this.entries[this.cursor].draft);
+        }
+        const draft = this.scratch ?? { value: "", attachments: [], pastes: [] };
+        this.cursor = null;
+        this.scratch = null;
+        return cloneDraft(draft);
+    }
+    abandonNavigation() {
+        this.cursor = null;
+        this.scratch = null;
+    }
+}
+let segmenter;
+function graphemeSegmenter() {
+    // Constructing Intl.Segmenter loads ICU data. Defer that cost until the first actual cursor edit so
+    // lightweight commands such as `hara --version` do not pay for TUI Unicode support.
+    if (segmenter === undefined)
+        segmenter = typeof Intl.Segmenter === "function" ? new Intl.Segmenter(undefined, { granularity: "grapheme" }) : null;
+    return segmenter;
+}
+/** Previous user-perceived character boundary (keeps emoji ZWJ sequences/combining marks intact). */
+export function previousGraphemeIndex(value, cursor) {
+    const at = Math.max(0, Math.min(value.length, cursor));
+    if (at === 0)
+        return 0;
+    const segments = graphemeSegmenter();
+    if (!segments) {
+        const low = value.charCodeAt(at - 1);
+        const paired = low >= 0xdc00 && low <= 0xdfff && at > 1 && value.charCodeAt(at - 2) >= 0xd800 && value.charCodeAt(at - 2) <= 0xdbff;
+        return Math.max(0, at - (paired ? 2 : 1));
+    }
+    let previous = 0;
+    for (const part of segments.segment(value)) {
+        if (part.index >= at)
+            break;
+        previous = part.index;
+    }
+    return previous;
+}
+/** Next user-perceived character boundary. */
+export function nextGraphemeIndex(value, cursor) {
+    const at = Math.max(0, Math.min(value.length, cursor));
+    if (at >= value.length)
+        return value.length;
+    const segments = graphemeSegmenter();
+    if (!segments) {
+        const cp = value.codePointAt(at);
+        return Math.min(value.length, at + (cp !== undefined && cp > 0xffff ? 2 : 1));
+    }
+    for (const part of segments.segment(value)) {
+        const end = part.index + part.segment.length;
+        if (end > at)
+            return end;
+    }
+    return value.length;
+}
+/** Start of the previous shell-style word, used by Ctrl+W. */
+export function previousWordIndex(value, cursor) {
+    let at = Math.max(0, Math.min(value.length, cursor));
+    while (at > 0) {
+        const previous = previousGraphemeIndex(value, at);
+        if (!/\s/u.test(value.slice(previous, at)))
+            break;
+        at = previous;
+    }
+    while (at > 0) {
+        const previous = previousGraphemeIndex(value, at);
+        if (/\s/u.test(value.slice(previous, at)))
+            break;
+        at = previous;
+    }
+    return at;
+}
+function graphemeFloor(value, cursor) {
+    const at = Math.max(0, Math.min(value.length, cursor));
+    if (at === value.length)
+        return at;
+    const segments = graphemeSegmenter();
+    if (!segments)
+        return at > 0 && /[\uDC00-\uDFFF]/.test(value[at]) ? at - 1 : at;
+    let floor = 0;
+    for (const part of segments.segment(value)) {
+        if (part.index > at)
+            break;
+        floor = part.index;
+        if (part.index + part.segment.length === at)
+            return at;
+    }
+    return floor;
+}
+/** Move between logical pasted/typed lines while retaining the closest possible column. */
+export function moveCursorLine(value, cursor, direction) {
+    const at = Math.max(0, Math.min(value.length, cursor));
+    const lineStart = (at === 0 ? -1 : value.lastIndexOf("\n", at - 1)) + 1;
+    const lineEndAt = value.indexOf("\n", at);
+    const lineEnd = lineEndAt < 0 ? value.length : lineEndAt;
+    const column = Math.min(at - lineStart, lineEnd - lineStart);
+    if (direction < 0) {
+        if (lineStart === 0)
+            return at;
+        const previousEnd = lineStart - 1;
+        const previousStart = value.lastIndexOf("\n", Math.max(0, previousEnd - 1)) + 1;
+        return graphemeFloor(value, previousStart + Math.min(column, previousEnd - previousStart));
+    }
+    if (lineEnd === value.length)
+        return at;
+    const nextStart = lineEnd + 1;
+    const nextEndAt = value.indexOf("\n", nextStart);
+    const nextEnd = nextEndAt < 0 ? value.length : nextEndAt;
+    return graphemeFloor(value, nextStart + Math.min(column, nextEnd - nextStart));
+}