@nanhara/hara 0.119.0 → 0.119.2

package/CHANGELOG.md

@@ -5,6 +5,32 @@ 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.119.2 — TUI: update notices actually visible · CJK-correct input wrapping
+
+- **Update notices now render INSIDE the TUI** (yellow line under the header card). They used to
+  print to stdout before ink mounted and vanished when the TUI took the screen — which is why TUI
+  users never saw them and versions silently went stale (field report: stuck on 0.112.5).
+- **Input wrapping measures terminal CELLS, not characters.** CJK/emoji render 2 cells wide;
+  mixed 中文+ASCII prompts used to overflow the real width and get soft-wrapped a second time
+  mid-word ("output" torn into "ou/tput"). Long words hard-break per code point so a double-width
+  char never straddles the terminal edge.
+
+## 0.119.1 — field-feedback robustness: param gate · no-hang git · actionable timeouts · stale-artifact rule
+
+- **Required-parameter gate.** A tool call arriving WITHOUT its required parameters (observed:
+  qwen3.7-plus dropping write_file's path/content, then retrying the same broken call forever) is
+  now rejected before execution with an error naming exactly what's missing; repeat-guard
+  escalates if the model loops anyway. Empty strings stay legal.
+- **git can no longer hang to the timeout.** Shell commands run with `GIT_TERMINAL_PROMPT=0` +
+  `GCM_INTERACTIVE=never` (user env overrides win): an https op that wants credentials fails in
+  seconds with a real auth error instead of sitting silently for 5 minutes.
+- **Timeouts tell you what to do next**: larger `timeout_ms` for long builds, `background:true`
+  for servers, and for network ops — diagnose or skip, never blind-retry.
+- **Stale-artifact rule** (prompt): before previewing generated artifacts, verify they're newer
+  than their sources; AGENTS.md/README command sequences are authoritative — middle steps (render/
+  build) are never skipped. Pairs with hara-design 0.3.6's deterministic staleness tripwire +
+  preview idle auto-exit.
+
 ## 0.119.0 — project panels: the chat ↔ live-preview split
 
 - **Plugin panels become project-aware.** A plugin panel can declare `detect` markers (e.g.

package/dist/agent/loop.js

@@ -1,4 +1,4 @@
-import { getTool, toolSpecs } from "../tools/registry.js";
+import { getTool, toolSpecs, missingRequired } from "../tools/registry.js";
 import { stdout } from "node:process";
 import { c, out } from "../ui.js";
 import { activity } from "../activity.js";
@@ -83,7 +83,12 @@ can't serve private repos), don't switch protocols — hara already fast-fails r
 diagnose instead. git ignores the macOS system / Clash proxy unless configured (git config --global
 http.proxy), so a browser that reaches a site doesn't mean the terminal does — verify connectivity yourself
 rather than trusting "the network is fine". If a step's output artifact already exists and is newer than its
-inputs, skip re-running it. After completing a task, give a one-line summary.`;
+inputs, skip re-running it — and the INVERSE: before serving or previewing GENERATED artifacts (a gallery,
+site, build output), check they are newer than their sources (compare mtimes or the latest commit time); if
+the sources changed since the artifacts were built, run the project's documented build/render steps FIRST.
+When AGENTS.md / README / package.json document a command sequence (e.g. pull → render → build → preview),
+that ordering is authoritative — never skip the middle steps, or you serve stale output and the user sees
+two-day-old work. After completing a task, give a one-line summary.`;
 /** When running inside `hara gateway`, tell the agent it's in a chat — so it delivers files via send_file
  *  (the only channel that reaches the peer) and never reaches for the desktop client / computer tool. */
 function gatewayNote() {
@@ -433,6 +438,16 @@ export async function runAgent(history, opts) {
             }
             activity.inc();
             try {
+                // Defensive parameter gate — some models drop required tool parameters outright (observed:
+                // qwen3.7-plus sending write_file without path/content, then retrying the same broken call
+                // forever). Reject precisely and name what's missing; repeat-guard escalates if it loops.
+                const missing = missingRequired(p.tool, p.tu.input);
+                if (missing.length) {
+                    const msg = `Error: tool call NOT executed — missing required parameter${missing.length > 1 ? "s" : ""}: ` +
+                        `${missing.join(", ")}. Send the call again with ALL required parameters (${(p.tool.input_schema.required ?? []).join(", ")}) present and complete.`;
+                    results[idx] = { id: p.tu.id, name: p.tu.name, content: msg + recordCall(p.tu.name, p.tu.input, msg, true), isError: true };
+                    return;
+                }
                 const pre = runHooks("PreToolUse", p.tu.name, p.tu.input, ctx.cwd); // a hook may veto the call
                 if (pre.block) {
                     results[idx] = { id: p.tu.id, name: p.tu.name, content: pre.message, isError: true };

package/dist/index.js

@@ -2937,6 +2937,9 @@ program.action(async (opts) => {
                 routeHost: __routeForHeader?.host,
                 modelSource: __modelSource,
                 visionModel: cfg.visionModel,
+                // the pre-mount stdout notice (line ~2497) doesn't survive ink taking the screen — TUI users
+                // never saw update notices and versions silently went stale (field report: stuck on 0.112.5)
+                updateNotice: cfg.updateCheck ? (checkForUpdate(pkg.version) ?? undefined) : undefined,
             },
             visionNotice: __visionNotice,
             cycleApproval: (m) => cycleMode(m),

package/dist/sandbox.js

@@ -93,7 +93,16 @@ export function maybeWarnUnsandboxed(mode) {
 export function runShell(command, cwd, mode, opts) {
     const { cmd, args } = shellCommand(command, cwd, mode);
     return new Promise((resolve, reject) => {
-        const child = spawn(cmd, args, { cwd });
+        // Non-interactive by contract: there is no terminal to answer a credential prompt, so a git
+        // https op against a private repo would otherwise sit silently until the timeout (observed as
+        // "git hangs 5 minutes"). With prompts disabled it fails in seconds with a real auth error.
+        // Users' credential helpers (keychain/GCM store) still work — only interactive PROMPTS are off.
+        const env = {
+            ...process.env,
+            GIT_TERMINAL_PROMPT: process.env.GIT_TERMINAL_PROMPT ?? "0",
+            GCM_INTERACTIVE: process.env.GCM_INTERACTIVE ?? "never",
+        };
+        const child = spawn(cmd, args, { cwd, env });
         let stdout = "";
         let stderr = "";
         let timedOut = false;

package/dist/tools/builtin.js

@@ -179,7 +179,15 @@ registerTool({
             return capHeadTail(combined.trim() || "(no output)");
         }
         catch (e) {
-            const base = `Command failed: ${e.message}\n${e.stdout || ""}${e.stderr || ""}`;
+            let base = `Command failed: ${e.message}\n${e.stdout || ""}${e.stderr || ""}`;
+            // Timeout gets an ACTIONABLE next step, not just a corpse — the model (and user) should pick a
+            // lane instead of blind-retrying into the same wall.
+            if (/timed out after \d+ms/.test(String(e.message))) {
+                base +=
+                    `\n⏱ hara: the command hit its ${input.timeout_ms ?? 300_000}ms cap and was killed. Pick ONE: ` +
+                        `a long build/transform → re-run with a larger timeout_ms; a server/watcher → background:true; ` +
+                        `a network op (git/curl/npm) → do NOT just retry — check connectivity/proxy or skip this step and tell the user.`;
+            }
             // Network fault tolerance — if this was a genuine host-unreachability (connect timeout / DNS, NOT
             // auth / 404 / connection-refused), remember the host so we fast-fail future ops to it this session.
             if (isConnectFailure(base)) {

package/dist/tools/registry.js

@@ -1,3 +1,13 @@
+/** 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
+ *  garbage, and repeat-guard escalates if the model loops on the same broken shape. Empty strings
+ *  are NOT flagged (writing an empty file is legitimate). */
+export function missingRequired(tool, input) {
+    const req = tool.input_schema.required ?? [];
+    const obj = (input && typeof input === "object" ? input : {});
+    return req.filter((k) => obj[k] === undefined || obj[k] === null);
+}
 const registry = new Map();
 export function registerTool(t) {
     registry.set(t.name, t);

package/dist/tui/App.js

@@ -231,7 +231,7 @@ function HeaderCard(props) {
         : row("profile", _jsx(Text, { children: props.profileId ? `personal:${props.profileId}` : "personal" }));
     return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", borderDimColor: true, paddingX: 1, alignSelf: "flex-start", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { color: accent(), bold: true, children: "◆ hara" }), _jsx(Text, { dimColor: true, children: `   v${version} · the agent that runs like an org` })] }), _jsx(Text, { children: " " }), identityRow, row("model", (_jsxs(Text, { children: [_jsx(Text, { children: modelLabel }), isOrg
                                 ? props.modelSource ? _jsx(Text, { dimColor: true, children: ` · from ${props.modelSource}` }) : null
-                                : props.visionModel ? _jsx(Text, { dimColor: true, children: modelLineSuffix(props.visionModel) }) : null, _jsx(Text, { children: "   " }), _jsx(Text, { color: "green", children: "/model ↹" })] }))), row("cwd", (_jsxs(Text, { children: [_jsx(Text, { children: cwdShort }), agentsMdLoaded ? _jsx(Text, { dimColor: true, children: " · AGENTS.md" }) : null] }))), sessionShort ? row("session", _jsx(Text, { children: sessionShort })) : null] }), _jsx(Text, { dimColor: true, children: "  Tip: @ attach file · ctrl+t transcript · ctrl+r reasoning · shift+tab approval · esc interrupt" })] }));
+                                : props.visionModel ? _jsx(Text, { dimColor: true, children: modelLineSuffix(props.visionModel) }) : null, _jsx(Text, { children: "   " }), _jsx(Text, { color: "green", children: "/model ↹" })] }))), row("cwd", (_jsxs(Text, { children: [_jsx(Text, { children: cwdShort }), agentsMdLoaded ? _jsx(Text, { dimColor: true, children: " · AGENTS.md" }) : null] }))), sessionShort ? row("session", _jsx(Text, { children: sessionShort })) : null] }), _jsx(Text, { dimColor: true, children: "  Tip: @ attach file · ctrl+t transcript · ctrl+r reasoning · shift+tab approval · esc interrupt" }), props.updateNotice ? _jsx(Text, { color: "yellow", children: `  ⬆ ${props.updateNotice}` }) : null] }));
 }
 // Spinner verb: while a turn is running, prefer the in_progress todo's activeForm (or its text),
 // so the bottom line reads "▶ updating tests…" instead of an abstract "working". Falls back to

package/dist/tui/InputBox.js

@@ -110,6 +110,35 @@ function segmentize(value) {
         parts.push({ text: value.slice(last), token: false });
     return parts;
 }
+/** Terminal cell width of one code point: CJK/fullwidth/emoji render 2 cells, combining marks and
+ *  joiners 0, everything else 1. Wrapping used to count `.length` (1 per char) — mixed CJK+ASCII
+ *  input then overflowed the real terminal width and ink soft-wrapped a second time mid-word
+ *  (field report: "output" torn into "ou/tput" while typing a URL + 中文 prompt). */
+export function charCells(ch) {
+    const cp = ch.codePointAt(0);
+    if ((cp >= 0x300 && cp <= 0x36f) || cp === 0x200d || (cp >= 0xfe00 && cp <= 0xfe0f))
+        return 0; // combining/ZWJ/VS
+    if ((cp >= 0x1100 && cp <= 0x115f) || // Hangul Jamo
+        (cp >= 0x2e80 && cp <= 0xa4cf) || // CJK radicals … Yi
+        (cp >= 0xa960 && cp <= 0xa97f) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) || // Hangul syllables
+        (cp >= 0xf900 && cp <= 0xfaff) || // CJK compatibility ideographs
+        (cp >= 0xfe30 && cp <= 0xfe4f) || // CJK compatibility forms
+        (cp >= 0xff00 && cp <= 0xff60) || // fullwidth forms
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f300 && cp <= 0x1faff) || // emoji
+        (cp >= 0x20000 && cp <= 0x3fffd) // CJK extension planes
+    )
+        return 2;
+    return 1;
+}
+/** Display width of a string in terminal cells (sum of charCells over code points). */
+export function cells(s) {
+    let n = 0;
+    for (const ch of s)
+        n += charCells(ch);
+    return n;
+}
 /** Wrap `value` into rows that each fit within `cols` cells, breaking on spaces where possible but
  *  never inside an `[Image #N]` token. Deterministic (no reliance on ink's soft-wrap) so wrapped rows
  *  align under a stable gutter and the cursor position is exact. Always returns at least one row. */
@@ -154,25 +183,28 @@ export function wrapRows(value, cols) {
             flush(aEnd);
             continue;
         }
-        if (a.atomic || a.text.length <= width) {
+        const aCells = cells(a.text);
+        if (a.atomic || aCells <= 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.
-            if (a.text.length > width - col && col > 0)
+            if (aCells > width - col && col > 0)
                 flush(a.start);
-            col += a.text.length; // an oversized atomic token may exceed width — acceptable (rare, kept whole)
+            col += aCells; // an oversized atomic token may exceed width — acceptable (rare, kept whole)
             if (col >= width)
                 flush(aEnd);
         }
         else {
-            // A single word longer than the whole width: hard-break it across rows.
+            // A single word longer than the whole width: hard-break it across rows — walking CODE POINTS
+            // and accumulating CELLS, so a double-width char never straddles the terminal edge.
             let s = a.start;
             if (col > 0)
                 flush(s); // start the long word on a fresh row
-            while (s < aEnd) {
-                const room = width - col;
-                const take = Math.min(room, aEnd - s);
-                col += take;
-                s += take;
+            for (const ch of a.text) {
+                const w = charCells(ch);
+                if (col + w > width && col > 0)
+                    flush(s);
+                col += w;
+                s += ch.length;
                 if (col >= width)
                     flush(s);
             }

package/package.json

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