@tiens.nguyen/gu-cli 1.0.817 → 1.0.818

package/gonext_agent_chat.py

@@ -10556,11 +10556,18 @@ def run_agent_chat(cfg):
             "run /context-window <tokens> to use more")})
 
     # Task #90 Phase 3 — completion gate (code-enforced, complements the prompt). Fires at
-    # most ONCE per turn: refuse the first final_answer that either hands the task back to
-    # the user, or lands right after a state-changing command that was never verified — with
-    # a verify-or-explain nudge fed back to the model (smolagents final_answer_checks: a
+    # most ONCE per turn: refuse the first final_answer that hands the task back to the user,
+    # with a verify-or-explain nudge fed back to the model (smolagents final_answer_checks: a
     # raised message becomes the check-failure the model sees and retries on). After one
     # nudge it ACCEPTS unconditionally — no loop; an honest "here's what failed" is valid.
+    #
+    # IT NO LONGER FIRES ON "THE LAST COMMAND EXITED 0" (GitHub #136). That trigger read the
+    # truthful-exit label every successful run_command carries as proof of unverified work, so
+    # it rejected the answer of any turn that ENDED on a command — measured over 296 real
+    # turns: 140 rejections (47% of turns), at least 65 of them straight after the test run or
+    # read-only check that WAS the verification, the rest mostly after a commit or a posted
+    # comment. Each cost a ritual re-check plus a rewritten answer: 400 steps, 11.6% of all
+    # input tokens. The label still sits in the Observation, where the model reads it.
     _completion_gate: dict = {"nudged": False}
     # Punt phrases: handing the CORE task back ("…start it yourself", "you'll need to run").
     # Deliberately narrow so a helpful tip ("you can also run npm test") does NOT trigger it.
@@ -10586,31 +10593,17 @@ def run_agent_chat(cfg):
 
     def _final_answer_gate(final_answer, memory, agent=None):
         """smolagents final_answer_check. True = accept; raising = reject with the message
-        the model then sees. Only nudges when there's real evidence of an unfinished job."""
+        the model then sees. Only nudges when the answer hands the job back to the user."""
         if _completion_gate["nudged"]:
             return True  # already nudged once this turn — accept, never loop
         ans = str(final_answer if final_answer is not None else "")
-        punt = bool(_PUNT_RE.search(ans))
-        # The most-recent tool result: a command that finished but whose EFFECT was never
-        # verified (Phase-1 'EXITED 0 (…VERIFY…)' marker), with no server/HTTP confirmation.
-        last_unverified = False
-        try:
-            for _st in reversed(getattr(memory, "steps", []) or []):
-                _obs = getattr(_st, "observations", None)
-                if isinstance(_obs, str) and _obs.strip():
-                    last_unverified = ("EXITED 0 (" in _obs) and not any(
-                        k in _obs for k in
-                        ("RUNNING:", "listening", "HTTP 2", "http://localhost"))
-                    break
-        except Exception:  # noqa: BLE001
-            pass
-        if punt or last_unverified:
+        if _PUNT_RE.search(ans):
             _completion_gate["nudged"] = True
             raise ValueError(
-                "NOT DONE YET — you ran commands or changed files but have NOT shown the "
-                "goal actually works. Do ONE of these, then call final_answer:\n"
-                "  1) VERIFY it — curl/open the server, run the test, or re-read the file to "
-                "confirm the change took — and answer WITH that evidence; OR\n"
+                "NOT DONE YET — your answer hands the work back to the user. Do ONE of these, "
+                "then call final_answer:\n"
+                "  1) DO it yourself with your tools, VERIFY it — run it, run the test, or "
+                "re-read the file to confirm the change took — and answer WITH that evidence; OR\n"
                 "  2) if it genuinely cannot be done with these tools, state plainly WHAT "
                 "failed and WHY.\n"
                 "Do NOT hand an unfinished task back to the user.")

package/gu-repl.mjs

@@ -11057,14 +11057,23 @@ const answerFrom = (s) =>
 const THOUGHT_PREVIEW_LINES = 3; // #134: dim lines always shown under the cut purple thought
 const THOUGHT_OPEN_LINES = 8; // …and after a click / Ctrl+T
 const wrapThought = (s, width, maxLines) => {
-  const words = String(s || "").split(/\s+/).filter(Boolean);
+  const W = Math.max(4, width);
+  // A single token wider than a row (a URL, a path) is the only thing that MUST be split; it is
+  // chunked to the row width so no line ever exceeds `width` (a wider row wraps physically and
+  // breaks the redraw's row maths, #109/#138).
+  const words = [];
+  for (const w0 of String(s || "").split(/\s+/).filter(Boolean)) {
+    let w = w0;
+    while (w.length > W) { words.push(w.slice(0, W)); w = w.slice(W); }
+    words.push(w);
+  }
   const lines = [];
   let cur = "";
   let truncated = false;
   for (let i = 0; i < words.length; i++) {
     const w = words[i];
     const next = cur ? cur + " " + w : w;
-    if (next.length <= width) {
+    if (next.length <= W) {
       cur = next;
     } else {
       if (cur) lines.push(cur);
@@ -11075,15 +11084,30 @@ const wrapThought = (s, width, maxLines) => {
   if (cur && lines.length < maxLines) lines.push(cur);
   else if (cur) truncated = true;
   if (truncated && lines.length) {
-    const last = lines[maxLines - 1] ?? lines[lines.length - 1];
-    const room = Math.max(1, width - 1);
-    let kept = last;
-    if (last.length > room) {
-      // Cut at a word boundary (#134) so the "…" never lands inside a half word like "lim…".
-      const sp = last.lastIndexOf(" ", room);
-      kept = sp >= Math.floor(room * 0.5) ? last.slice(0, sp) : last.slice(0, room);
+    // End on a WHOLE, meaningful word (#134): drop whole words until the "…" fits, then drop a
+    // dangling connective ("the", "of", "and"…) and trailing punctuation, so the line never
+    // ends "…and the…" or "word,…". Only a lone oversized word is ever cut inside itself.
+    const idx0 = lines.length - 1;
+    const first = lines[idx0].split(" ")[0];
+    const dangling = /^(a|an|the|of|to|and|or|but|in|on|at|for|with|by|from|as|is|are|that|which|if|then|than|so|into|via|per)$/i;
+    const isDangling = (w) => dangling.test(w.replace(/[^\w]/g, ""));
+    let idx = idx0;
+    let ws = lines[idx].split(" ");
+    for (;;) {
+      while (ws.length > 0 && isDangling(ws[ws.length - 1])) ws.pop();
+      if (ws.length === 0) {
+        if (idx > 0) { lines.pop(); idx--; ws = lines[idx].split(" "); continue; }
+        ws = [first];
+        break;
+      }
+      if (ws.length > 1 && ws.join(" ").length + 1 > W) { ws.pop(); continue; }
+      break;
     }
-    lines[lines.length - 1] = kept.replace(/\s+$/, "") + "…";
+    lines.length = idx + 1;
+    let kept = ws.join(" ").replace(/[\s,;:(\-\u2013\u2014]+$/, "");
+    if (!kept) kept = ws[0];
+    if (kept.length + 1 > W) kept = kept.slice(0, W - 1);
+    lines[idx] = kept + "\u2026";
   }
   return lines;
 };
@@ -11773,8 +11797,9 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
       // Line 1 shows the head; the grey expansion CONTINUES from the same point (no dup, no
       // split word).
       const sp = fullLiveThought.lastIndexOf(" ", max - 1);
-      const cut = sp >= Math.floor(max * 0.6) ? sp : max - 1;
-      label = `${fullLiveThought.slice(0, cut).replace(/\s+$/, "")}… (${secs}s)`;
+      // Any space at all beats a mid-word cut (#134); only a first word wider than the row is split.
+      const cut = sp > 0 ? sp : max - 1;
+      label = `${fullLiveThought.slice(0, cut).replace(/[\s,;:(\-\u2013\u2014]+$/, "")}… (${secs}s)`;
       rest = fullLiveThought.slice(cut).trim();
     } else {
       const primary = runningTool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.817",
+  "version": "1.0.818",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",