@nanhara/hara 0.108.1 → 0.109.1

package/CHANGELOG.md

@@ -5,6 +5,50 @@ All notable changes to `@nanhara/hara`.
 > Versioning (pre-1.0, SemVer-style): the **minor** (middle) number bumps for a **new feature**; the
 > **patch** (last) number bumps for **optimizations/fixes of existing features**.
 
+## 0.109.2 — long paste no longer freezes the input box
+
+- **The input box now draws a bottom-anchored viewport, not every wrapped row.** A long multi-line
+  paste (a spec, a stack trace, a design brief) wraps to hundreds of rows; rendering *all* of them on
+  every keystroke floods ink's layout+diff and the box appears frozen ("卡着" — you type and nothing
+  moves). It now renders at most ~14 rows around the cursor with `⋯ N more lines above/below` markers,
+  so a huge paste stays smooth and the box stays a sane height. (This closes the freeze that 0.109.0's
+  "paste inserts as real multi-line text" could reach — the two ship as a pair.) A tip if a paste was
+  meant to *launch* a skill: a plain long message relies on the model to pick the skill; prefixing the
+  explicit command (e.g. `/design <brief>`) enters that mode deterministically and immediately.
+
+## 0.109.1 — prompt caching + dynamic compaction (the "why is it slow" fix)
+
+- **Prompt caching, finally on.** Every turn used to re-send *and re-process* the whole prompt —
+  system + all tool definitions + the entire growing history — with **no cache breakpoints**, so the
+  model re-billed and re-crunched everything from scratch each turn. The longer the session, the
+  slower and pricier each reply. hara now sets Anthropic `cache_control` breakpoints on the static
+  prefix (system, which covers tools+system in cache order) and two rolling points at the message tail,
+  so each turn reads the unchanged prefix **from cache** (~10% the cost, and far lower time-to-first-
+  token). This is the single biggest latency win as history grows. (Cache engages once the prefix
+  passes Anthropic's ~1024-token minimum — i.e. any real coding session.)
+- **Auto-compaction now actually fires on big-window models.** It triggered at 85% of the context
+  window — but on a 1M-token model that's **850k tokens**, a size a session drags sluggishly toward and
+  realistically never hits, so it never compacted and the prompt just kept bloating. Added a **dynamic
+  absolute cap**: compact once the live context passes ~200k tokens *regardless* of window size (either
+  trigger — % of window OR the cap — fires). Override with `HARA_AUTO_COMPACT_TOKENS`; opt out as before
+  with `autoCompact: false` / `HARA_AUTO_COMPACT=0`.
+- Studied codex (Rust `prompt_cache_key` + a 1000-char paste-fold threshold) and cc-haha (Claude Code's
+  session-stable cache TTL) to land the breakpoint layout and keep the TTL steady within a session.
+
+## 0.109.0 — real multi-line input + Windows shell
+
+- **Pasted multi-line text is now real, editable text in the box** — not a `[Paste]` token, not an
+  auto-submit. The input box renders `\n` as actual line breaks (deterministic wrap now treats a
+  newline as a hard row break), so a pasted paragraph / code / stack trace shows in full, you edit it,
+  and only a real **Enter** sends it. (0.108.1 over-corrected by folding every paste to a token; this
+  is codex's behavior — the composer is a multi-line textarea, a pasted newline is content.) A truly
+  enormous dump (>8000 chars) still folds to a token so it can't wall off the screen.
+- **Windows: the shell no longer hard-fails.** The bash tool hardcoded `/bin/sh`, which doesn't exist
+  on Windows — so every command errored. Now on Windows hara prefers a real **bash** (Git Bash / WSL,
+  which it probes on PATH) so the POSIX commands the model writes keep working, and falls back to
+  `cmd.exe` with a one-time notice pointing at the fix. (Still no auto-`cron install` or sandbox on
+  Windows — those stay Unix-only, as before.)
+
 ## 0.108.1 — pasting no longer sends the message
 
 - **A pasted newline is content, not "send".** Pasting multi-line text used to fire the message at

package/dist/agent/compact.js

@@ -3,6 +3,11 @@
 // which reuses the manual /compact path; this just decides *when* to fire.
 /** Auto-compact once the last turn used ≥ this % of the model's context window. */
 export const AUTO_COMPACT_PCT = 85;
+/** Dynamic absolute ceiling. On a 1M-window model, 85% == 850k tokens — a size a session drags for a
+ *  long, sluggish while before ever reaching, so the %-trigger effectively never fires and every turn
+ *  re-sends a bloated prompt. This cap makes auto-compaction actually engage at a snappy working size
+ *  regardless of how large the window is. Overridable via `HARA_AUTO_COMPACT_TOKENS`. */
+export const AUTO_COMPACT_TOKEN_CAP = 200_000;
 /** The compaction brief (shared by /compact and auto-compaction). Eight sections, mirroring Claude
  *  Code's AU2 template — the two that matter most beyond the obvious: **All user messages** (the
  *  user's own words survive verbatim, so however hard the history is squeezed, intent never drifts)
@@ -47,3 +52,9 @@ export function buildFileRestore(paths, readFn, opts) {
 export function shouldAutoCompact(ctxPct, historyLen, autoCompact, threshold = AUTO_COMPACT_PCT) {
     return autoCompact && historyLen >= 4 && ctxPct >= threshold;
 }
+/** Absolute-size companion to shouldAutoCompact: fire once the last turn's real token count crosses the
+ *  cap. This is what makes auto-compaction engage on huge-window models, where the %-trigger sits at an
+ *  unreachable 850k. Either trigger (this OR the %-of-window one) compacts. */
+export function shouldAutoCompactTokens(lastInputTokens, historyLen, autoCompact, cap = AUTO_COMPACT_TOKEN_CAP) {
+    return autoCompact && historyLen >= 4 && lastInputTokens >= cap;
+}

package/dist/index.js

@@ -24,7 +24,7 @@ import { clearEnrollment, enrollDevice, heartbeat, syncOrgRoles } from "./org-fl
 import { loadActiveProfile, listProfiles, useProfile, addProfile, upsertProfile, removeProfile, setModel as setProfileModel, resetModel as resetProfileModel, getProfile, effectiveModel, routingLabel, routeHost, activeId, resolveActive, setFlagOverride, writePin, removePin, pinFilePath, DEFAULT_ORG_ID, PERSONAL_ID, } from "./profile/profile.js";
 import { loadPermissionRules, scaffoldPermissions, globalPermissionsPath, projectPermissionsPath } from "./security/permissions.js";
 import { routingProvider } from "./agent/route.js";
-import { shouldAutoCompact, COMPACT_SYSTEM, buildFileRestore } from "./agent/compact.js";
+import { shouldAutoCompact, shouldAutoCompactTokens, AUTO_COMPACT_TOKEN_CAP, COMPACT_SYSTEM, buildFileRestore } from "./agent/compact.js";
 import { recentTouched } from "./agent/touched.js";
 import { INTERJECT_PREFIX } from "./agent/reminders.js";
 import { checkForUpdate } from "./update-check.js";
@@ -770,10 +770,16 @@ async function compactConversation(provider, history, meta, stats) {
  *  doesn't overflow. Opt-out via `autoCompact: false` / `HARA_AUTO_COMPACT=0`. Best-effort; `notify` surfaces
  *  a one-line status. Returns true if it compacted. */
 async function maybeAutoCompact(provider, history, meta, stats, cfg, notify) {
-    const pct = bar.ctxPctFor(cfg.model, stats.lastInput ?? 0);
-    if (!shouldAutoCompact(pct, history.length, cfg.autoCompact))
+    const lastInput = stats.lastInput ?? 0;
+    const pct = bar.ctxPctFor(cfg.model, lastInput);
+    // Two triggers, whichever hits first: % of window (small-window models) OR an absolute token cap
+    // (huge-window models, where 85% is an unreachable 850k). Cap is overridable via env.
+    const cap = Number(process.env.HARA_AUTO_COMPACT_TOKENS) || AUTO_COMPACT_TOKEN_CAP;
+    const overPct = shouldAutoCompact(pct, history.length, cfg.autoCompact);
+    const overCap = shouldAutoCompactTokens(lastInput, history.length, cfg.autoCompact, cap);
+    if (!overPct && !overCap)
         return false;
-    notify(`✻ Auto-compacting conversation (context ${pct}% full)…`);
+    notify(`✻ Auto-compacting conversation (context ${pct}% full, ~${Math.round(lastInput / 1000)}k tok)…`);
     const summary = await compactConversation(provider, history, meta, stats);
     notify(summary ? `(auto-compacted — context replaced with a summary; ${meta.workingSet?.length ?? 0} notes kept)` : "(auto-compact failed — use /compact or /clear)");
     return !!summary;

package/dist/providers/anthropic.js

@@ -51,6 +51,38 @@ export function toAnthropic(history) {
     }
     return msgs;
 }
+const CACHE = { type: "ephemeral" };
+/** Attach Anthropic prompt-cache breakpoints so each turn re-reads the static prefix and the
+ *  conversation prefix FROM CACHE instead of re-billing + re-processing the whole prompt — the single
+ *  biggest latency + cost win as history grows (uncached, a long session pays full input every turn).
+ *
+ *  Anthropic caps breakpoints at 4 and orders the cache prefix `tools → system → messages`, so a mark
+ *  on `system` already caches tools+system (the big static block) in one shot. We then spend up to two
+ *  rolling marks near the message tail: the last message (so THIS turn's full prefix is written) and one
+ *  ~2 back (so the NEXT turn — which appends new messages — still finds a long cached prefix to read).
+ *  Mutates `messages` in place (toAnthropic hands us a fresh array each turn); returns the request-shaped
+ *  system. Exported pure for tests. */
+export function applyCacheControl(system, messages) {
+    const mark = (m) => {
+        if (typeof m.content === "string") {
+            if (m.content.length)
+                m.content = [{ type: "text", text: m.content, cache_control: CACHE }];
+        }
+        else if (m.content.length) {
+            m.content[m.content.length - 1].cache_control = CACHE;
+        }
+    };
+    const idxs = new Set();
+    if (messages.length)
+        idxs.add(messages.length - 1);
+    if (messages.length >= 3)
+        idxs.add(messages.length - 3);
+    for (const i of idxs)
+        mark(messages[i]);
+    // Only cache system when it's substantial enough to matter (an empty text block would 400).
+    const cachedSystem = system ? [{ type: "text", text: system, cache_control: CACHE }] : system;
+    return { system: cachedSystem, messages };
+}
 /** Anthropic models whose only valid `thinking` setting is `{type: "adaptive"}` — they reject any
  *  explicit `budget_tokens`. We detect them by id family so "off"/low/high still degrade gracefully
  *  (we just omit the field or stay on adaptive instead of sending a 400-triggering body). */
@@ -84,13 +116,14 @@ export function createAnthropicProvider(opts) {
         model: opts.model,
         async turn({ system, history, tools, onText, onReasoning, signal }) {
             const thinking = buildThinkingParam(opts.model, opts.reasoningEffort);
+            const { system: cachedSystem, messages } = applyCacheControl(system, toAnthropic(history));
             const stream = client.messages.stream({
                 model: opts.model,
                 max_tokens: 32000,
                 ...(thinking ? { thinking } : {}),
-                system,
+                system: cachedSystem,
                 tools: tools,
-                messages: toAnthropic(history),
+                messages,
             }, { signal });
             stream.on("text", onText);
             if (onReasoning)

package/dist/sandbox.js

@@ -5,10 +5,33 @@
 // project, NOT a determined exfiltration. Other platforms run UNSANDBOXED (a one-time warning is
 // emitted from runShell so every entry point — REPL, -p, org, cron — surfaces it). Only the `bash`
 // shell is sandboxed; hara's own file tools are in-process, explicit, and gated by the approval flow.
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { writeFileSync, mkdtempSync } from "node:fs";
 import { tmpdir, platform } from "node:os";
 import { join } from "node:path";
+// Windows shell resolution. hara (and the model) speak POSIX shell — the agent writes `ls`, `grep`,
+// `cat`, pipes, `&&`. So on Windows we PREFER a real bash (Git Bash or WSL, which most Windows devs
+// have) and only fall back to cmd.exe when none is found. Memoized: the PATH probe runs at most once.
+let _winBash;
+function findWindowsBash() {
+    if (_winBash !== undefined)
+        return _winBash;
+    // `where bash` finds Git Bash / WSL bash on PATH; also probe the default Git-for-Windows location.
+    const onPath = spawnSync("where", ["bash"], { encoding: "utf8" });
+    const hit = onPath.status === 0 ? String(onPath.stdout).split(/\r?\n/).find((l) => l.trim()) : "";
+    _winBash = (hit && hit.trim()) || null;
+    return _winBash;
+}
+/** Pure shell-argv resolution — split out so the platform branching is unit-testable without spawning.
+ *  `plat` and `bash` are injected; production passes the real platform() + findWindowsBash(). */
+export function resolveShellArgv(command, plat, bash) {
+    if (plat === "win32") {
+        // A real bash keeps POSIX commands working; cmd.exe is the last resort (most `ls/grep` will fail
+        // there — the model should be told, see maybeWarnWindowsShell).
+        return bash ? { cmd: bash, args: ["-c", command] } : { cmd: "cmd.exe", args: ["/d", "/s", "/c", command] };
+    }
+    return { cmd: "/bin/sh", args: ["-c", command] };
+}
 const sbQuote = (s) => '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
 function seatbeltProfile(cwd, mode) {
     const writable = [
@@ -43,7 +66,20 @@ export function shellCommand(command, cwd, mode) {
         return { cmd: "sandbox-exec", args: ["-f", profileFile, "/bin/bash", "-lc", command] };
     }
     maybeWarnUnsandboxed(mode);
-    return { cmd: "/bin/sh", args: ["-c", command] };
+    const plat = platform();
+    if (plat === "win32")
+        maybeWarnWindowsShell();
+    return resolveShellArgv(command, plat, plat === "win32" ? findWindowsBash() : null);
+}
+/** One-time notice on Windows when no bash is found — the POSIX commands the model writes won't run
+ *  under cmd.exe. Points the user at the fix (install Git for Windows or run under WSL). */
+let warnedWinShell = false;
+function maybeWarnWindowsShell() {
+    if (warnedWinShell || findWindowsBash())
+        return;
+    warnedWinShell = true;
+    process.stderr.write("hara: no bash found on PATH — shell commands run under cmd.exe, where most Unix commands (ls, grep, cat) fail.\n" +
+        "      Install Git for Windows (bundles bash) or run hara inside WSL for full command support.\n");
 }
 /** One-time-per-process notice that --sandbox is a no-op off macOS (covers every entry point). */
 export function maybeWarnUnsandboxed(mode) {

package/dist/tui/InputBox.js

@@ -126,12 +126,13 @@ export function wrapRows(value, cols) {
             pos += p.text.length;
         }
         else {
-            // Break the text run into word chunks (keep trailing space with the word) so wraps land on spaces.
-            const re = /\S+\s*|\s+/g;
+            // Break the text run into: a hard newline (its own atom → forces a row break, so a pasted/typed
+            // `\n` renders as an actual line), a word + trailing NON-newline whitespace, or a run of spaces.
+            const re = /\n|\S+[^\S\n]*|[^\S\n]+/g;
             let m;
-            let base = pos;
+            const base = pos;
             while ((m = re.exec(p.text))) {
-                atoms.push({ text: m[0], start: base + m.index, atomic: false });
+                atoms.push({ text: m[0], start: base + m.index, atomic: false, br: m[0] === "\n" });
             }
             pos += p.text.length;
         }
@@ -147,6 +148,12 @@ export function wrapRows(value, cols) {
     };
     for (const a of atoms) {
         const aEnd = a.start + a.text.length;
+        if (a.br) {
+            // A newline ends the current row: the `\n` sits at the row's end (renderRow strips it from the
+            // displayed text). The next row starts right after it — rows stay contiguous over the value.
+            flush(aEnd);
+            continue;
+        }
         if (a.atomic || a.text.length <= width) {
             // A whole unit (image token OR a word chunk that fits within a full row): if it doesn't fit in
             // the remaining room and the row already has content, wrap to a fresh row FIRST — never split it.
@@ -188,7 +195,9 @@ export function wrapRows(value, cols) {
  *  cursor (inverse cell) when it falls on this row. Splitting happens on precomputed rows so the
  *  whole prompt never reflows as a single <Text> — stable under wrapping and quick to diff. */
 function renderRow(value, row, cursor, showCursor, isLastRow, keyPrefix) {
-    const seg = (token, text, k) => token ? (_jsx(Text, { backgroundColor: "magenta", color: "white", children: text }, k)) : (_jsx(Text, { children: text }, k));
+    // `\n` chars are row SEPARATORS (wrapRows already broke the row on them) — never render them, or ink
+    // would insert a second line break and desync the deterministic layout.
+    const seg = (token, text, k) => token ? (_jsx(Text, { backgroundColor: "magenta", color: "white", children: text.replace(/\n/g, "") }, k)) : (_jsx(Text, { children: text.replace(/\n/g, "") }, k));
     // Segments intersected with this row's [start,end) range.
     const parts = segmentize(value);
     const nodes = [];
@@ -208,7 +217,7 @@ function renderRow(value, row, cursor, showCursor, isLastRow, keyPrefix) {
             const rel = cursor - from;
             if (rel > 0)
                 nodes.push(seg(p.token, slice.slice(0, rel), `${keyPrefix}s${ki++}`));
-            nodes.push(_jsx(Text, { inverse: true, children: slice[rel] }, `${keyPrefix}c${ki++}`));
+            nodes.push(_jsx(Text, { inverse: true, children: slice[rel] === "\n" ? " " : slice[rel] }, `${keyPrefix}c${ki++}`));
             if (rel + 1 < slice.length)
                 nodes.push(seg(p.token, slice.slice(rel + 1), `${keyPrefix}e${ki++}`));
         }
@@ -222,6 +231,26 @@ function renderRow(value, row, cursor, showCursor, isLastRow, keyPrefix) {
     }
     return nodes;
 }
+/** Max input rows drawn at once. A long multi-line paste (a spec, a stack trace, a design brief) wraps
+ *  to hundreds/thousands of rows; rendering them ALL every keystroke floods ink's layout+diff and the
+ *  box appears frozen ("卡着"). So we draw a bottom-anchored viewport (codex-style) around the cursor. */
+export const MAX_INPUT_ROWS = 14;
+/** The [first, last) slice of rows to render so the cursor stays visible without drawing the whole
+ *  input. Bottom-anchored: when the cursor is at the end (typing), you see the last MAX rows; when
+ *  editing mid-text, the cursor's row + a little context below stays on screen. Exported pure for tests. */
+export function windowRows(rowCount, cursorRow, max = MAX_INPUT_ROWS) {
+    if (rowCount <= max)
+        return { first: 0, last: rowCount };
+    const last = Math.min(rowCount, Math.max(cursorRow + 2, max));
+    return { first: Math.max(0, last - max), last };
+}
+/** Index of the wrapped row that holds the cursor (last row if past the end). */
+export function cursorRowIndex(rows, cursor) {
+    for (let i = 0; i < rows.length; i++)
+        if (cursor >= rows[i].start && cursor <= rows[i].end)
+            return i;
+    return Math.max(0, rows.length - 1);
+}
 /** The prompt: gutter + wrapped input rows (or a placeholder when empty). Each wrapped continuation
  *  row is indented under the gutter so the text column is stable. Memoized so it only re-renders when
  *  the value/cursor/width/gutter actually change (not when unrelated status ticks over). */
@@ -231,7 +260,11 @@ const InputLine = memo(function InputLine({ value, cursor, width, gutter, gutter
     if (value.length === 0) {
         return (_jsxs(Box, { children: [_jsx(Text, { color: gutterColor, children: gutter }), _jsxs(Text, { children: [_jsx(Text, { inverse: true, children: " " }), _jsx(Text, { dimColor: true, children: placeholder })] })] }));
     }
-    return (_jsx(Box, { flexDirection: "column", children: rows.map((row, i) => (_jsxs(Box, { children: [_jsx(Text, { color: gutterColor, children: i === 0 ? gutter : "  " }), _jsx(Text, { children: renderRow(value, row, cursor, true, i === rows.length - 1, `r${i}_`) })] }, i))) }));
+    const { first, last } = windowRows(rows.length, cursorRowIndex(rows, cursor));
+    return (_jsxs(Box, { flexDirection: "column", children: [first > 0 && _jsx(Text, { dimColor: true, children: `  ⋯ ${first} more line${first > 1 ? "s" : ""} above` }), rows.slice(first, last).map((row, k) => {
+                const i = first + k;
+                return (_jsxs(Box, { children: [_jsx(Text, { color: gutterColor, children: i === 0 ? gutter : "  " }), _jsx(Text, { children: renderRow(value, row, cursor, true, i === rows.length - 1, `r${i}_`) })] }, i));
+            }), last < rows.length && _jsx(Text, { dimColor: true, children: `  ⋯ ${rows.length - last} more line${rows.length - last > 1 ? "s" : ""} below` })] }));
 });
 /** Bordered prompt box + one dim status footer (model · approval · route · cwd · usage · ctx),
  *  with an @path popup. */
@@ -410,13 +443,18 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
                 submit(value);
                 return;
             }
-            // A PASTE — any multi-char chunk that CONTAINS a newline, or a large single chunk — folds to a
-            // `[Paste #N +L lines]` token and NEVER submits. A pasted newline is content, not "send" (codex's
-            // paste-burst rule: Enter inside a paste is a newline, not submit). This fixes "paste is sent
-            // immediately": the old code submitted at the first newline in a pasted chunk, so any 1–2 line
-            // paste under 600 chars fired the message. Now only a real Enter (above / key.return) sends.
-            if (/[\r\n]/.test(input) || input.length >= 600) {
-                addPaste(input);
+            // A PASTE containing newlines inserts as REAL MULTI-LINE TEXT (normalize CRLF/CR → LF) — the
+            // user sees and can edit it, and a pasted newline is content, NOT "send" (only a real Enter,
+            // above / key.return, submits). Only a truly ENORMOUS dump folds to a `[Paste #N]` token, so a
+            // 500-line paste doesn't turn the box into a wall — normal multi-line pastes stay visible.
+            const hasNL = /[\r\n]/.test(input);
+            if (input.length >= 8000) {
+                addPaste(input.replace(/\r\n?/g, "\n"));
+                return;
+            }
+            if (hasNL) {
+                const text = input.replace(/\r\n?/g, "\n");
+                set(value.slice(0, cursor) + text + value.slice(cursor), cursor + text.length);
                 return;
             }
             // a dragged-in / pasted image file path attaches instead of inserting literal text

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.108.1",
+  "version": "0.109.1",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "dist/index.js"