@nanhara/hara 0.119.0 → 0.119.1

package/CHANGELOG.md

@@ -5,6 +5,22 @@ 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.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/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/package.json

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