@nanhara/hara 0.109.0 → 0.109.1

package/CHANGELOG.md

@@ -5,6 +5,36 @@ 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

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/tui/InputBox.js

@@ -231,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). */
@@ -240,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. */

package/package.json

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