@tiens.nguyen/gu-cli 1.0.817 → 1.0.820

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

@@ -154,6 +154,7 @@ import {
   parseModelFallback,
 } from "./model-fallback.mjs";
 import { codingChoiceTags, coderDisplayName, coderWhere, whereOfActiveCoder } from "./coding-choice-tags.mjs";
+import { TITLE_POP, TITLE_PUSH, idleTitle, needsSummary, summariseForTitle, titleSeq, trimTitle } from "./terminal-title.mjs";
 import { IMAGE_NEEDS_CLAUDE, coderTakesImagesFor, clipboardImageToFile, fitImageNotice, imageMarkersForDisplay, createImageStore, imagePasteKey, imagePathFromPaste, isClaudeCoderUrl, isImagePasteKey, storeImageFile } from "./image-paste.mjs";
 import {
   isDoubleClick,
@@ -1603,6 +1604,40 @@ if (IS_TTY) {
   process.on("exit", () => _stdoutWrite(PASTE_MODE_OFF));
 }
 
+// THE TAB SAYS WHAT IS BEING WORKED ON (task #357) — see terminal-title.mjs. Until the first
+// question it names the folder, which is already more than the `node /opt/homebrew/…/gu` a
+// terminal shows for a program that never names itself.
+const TITLE_ON = IS_TTY && process.env.GU_NO_TITLE !== "1";
+let _titleSeq = 0; // which question the title belongs to; a late summary for an older one is dropped
+const writeTitle = (text) => {
+  if (TITLE_ON) ui(titleSeq(text));
+};
+if (TITLE_ON) {
+  ui(TITLE_PUSH);
+  writeTitle(idleTitle(process.cwd()));
+  // Hand the title back: restore the one that was there where the terminal keeps a stack, and
+  // clear ours where it does not, so the shell is not left wearing the last question.
+  process.on("exit", () => _stdoutWrite(titleSeq("") + TITLE_POP));
+}
+
+/**
+ * A new question: the trimmed text now, and — only when it had to be cut — the agent model's
+ * few-word summary whenever it arrives. Fire-and-forget by design: it never delays the turn,
+ * never prints, and a summary that lands after the NEXT question is thrown away.
+ */
+function showQuestionInTitle(question) {
+  if (!TITLE_ON) return;
+  const mine = ++_titleSeq;
+  writeTitle(trimTitle(question));
+  if (!needsSummary(question)) return;
+  void (async () => {
+    const settings = await fetchWorkerSettings();
+    if (!settings || mine !== _titleSeq) return;
+    const title = await summariseForTitle(question, settings, { fetchImpl: doctorFetch });
+    if (title && mine === _titleSeq) writeTitle(title);
+  })().catch(() => {});
+}
+
 // ">>" is a MARGIN MARKER like the ● bullets — it hangs in the gutter (no leading gutter) so
 // the user's typed input lands on the SAME text column (GUTTER+1) as the agent's bullets and
 // answer. ">> " is exactly GUTTER-wide, so input aligns; the ">>" right-edge sits at the same
@@ -11057,14 +11092,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 +11119,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 +11832,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
@@ -14323,6 +14383,9 @@ async function main() {
       history.push({ role: "user", content: taskLine });
     }
     await saveSession(cwd, history, { unfinishedTask: isResumeWord(taskLine) ? "" : taskLine });
+    // #357: the tab is this question until the next one. A bare "continue" with nothing to
+    // resume says nothing about the work, so the title it follows stays.
+    if (!isResumeWord(taskLine)) showQuestionInTitle(taskLine);
     try {
       const turnStartMs = Date.now();
       // #323: priced by the coder this turn STARTS on — a /model switch afterwards must not put

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.817",
+  "version": "1.0.820",
   "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",
@@ -115,6 +115,7 @@
     "model-doctor.mjs",
     "coding-key-prompt.mjs",
     "model-fallback.mjs",
+    "terminal-title.mjs",
     "server-keys.mjs",
     "add-server.mjs",
     "powershell-alias.mjs",

package/terminal-title.mjs

@@ -0,0 +1,165 @@
+/**
+ * THE TERMINAL'S TITLE IS THE QUESTION BEING WORKED ON (task #357).
+ *
+ * Reported: the tab said `node /opt/homebrew/…/gu` — where the gu bin lives, which is what a
+ * terminal shows when the program inside never names itself. With several gu tabs open that is
+ * the same useless string on every one. The ask: show the current turn's question instead,
+ * shortened, and keep it there until the next question.
+ *
+ * TWO STEPS, AND THE FIRST NEVER WAITS FOR THE SECOND. The trimmed question goes up the moment
+ * the turn starts. Only a question too long to fit is then sent to the agent model for a
+ * few-word summary, which replaces the trimmed one if — and only if — it arrives usable and the
+ * user has not asked something else in the meantime. Every way that call can fail (no model
+ * configured, a provider that wants a key this side does not hold, a timeout, a model that
+ * answers with an essay) ends the same way: the trimmed question stays.
+ *
+ * WHY SHORT QUESTIONS ARE NOT SUMMARISED. The agent model is the one the turn itself is about to
+ * use, and a single-GPU Ollama queues requests rather than running them side by side — a summary
+ * of "fix the login test" would cost the turn its first seconds to say the same thing in fewer
+ * words. A question that already fits is its own best title.
+ *
+ * Pure: no terminal and no network of its own. `fetchImpl` is injected, and the caller writes
+ * the bytes.
+ */
+
+/** What fits on a tab next to its neighbours. Terminals clip a title; they do not wrap it. */
+export const TITLE_MAX = 60;
+
+/** How much of a long question the summary is given — the ask is in the opening lines. */
+export const SUMMARY_INPUT_MAX = 1200;
+
+const ELLIPSIS = "…";
+
+/**
+ * One line of plain text, safe to put inside an escape sequence.
+ *
+ * NOT COSMETIC. The title is written as `ESC ] 0 ; <text> BEL`, so a BEL or ESC inside the text
+ * ends the sequence early and the rest is read by the terminal as commands — and the text is
+ * whatever was typed or PASTED as a question. Every C0/C1 control character goes, newlines
+ * included (as spaces: a pasted stack trace is one title, not twenty).
+ */
+export function cleanTitleText(text) {
+  return String(text ?? "")
+    .replace(/[\u0000-\u001f\u007f-\u009f]+/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+/** The question cut to fit, on a word boundary when there is one in the last third. */
+export function trimTitle(text, max = TITLE_MAX) {
+  const s = cleanTitleText(text);
+  const chars = Array.from(s); // by code point: never half of an emoji or a Vietnamese letter
+  if (chars.length <= max) return s;
+  const cut = chars.slice(0, max - 1).join("");
+  const space = cut.lastIndexOf(" ");
+  const head = space >= Math.floor((max * 2) / 3) ? cut.slice(0, space) : cut;
+  return head.replace(/[\s,;:.\-–—]+$/u, "") + ELLIPSIS;
+}
+
+/** Only a question that had to be cut is worth a model call (see the header). */
+export function needsSummary(text, max = TITLE_MAX) {
+  return Array.from(cleanTitleText(text)).length > max;
+}
+
+/** The bytes that set the window and tab title. "" hands the title back to the terminal. */
+export function titleSeq(text) {
+  return `\x1b]0;${cleanTitleText(text)}\x07`;
+}
+
+/** xterm's title stack: remember the title that was there, and put it back on the way out.
+ *  Terminals that do not have one ignore both. */
+export const TITLE_PUSH = "\x1b[22;0t";
+export const TITLE_POP = "\x1b[23;0t";
+
+/** What the tab says before anything has been asked. */
+export function idleTitle(folder) {
+  const name = cleanTitleText(String(folder ?? "").split(/[\\/]/).filter(Boolean).pop() ?? "");
+  return name ? `gu · ${trimTitle(name, TITLE_MAX - 5)}` : "gu";
+}
+
+/** Where the agent model answers chat, from a base that may or may not already end in /v1. */
+export function chatEndpoint(url) {
+  const root = String(url ?? "").trim().replace(/\/+$/, "");
+  if (!root) return "";
+  return /\/v1$/i.test(root) ? `${root}/chat/completions` : `${root}/v1/chat/completions`;
+}
+
+/**
+ * The agent model this machine is set to use, from the settings row.
+ *
+ * With a direct URL and no name the API itself sends the literal "default_model" (an MLX server
+ * answers to anything), so the same is sent here rather than skipping the summary on every MLX
+ * host.
+ */
+export function agentModelFromSettings(settings) {
+  const str = (v) => String(v ?? "").trim();
+  const url = str(settings?.agentModelUrl);
+  if (!url) return null;
+  return { url, model: str(settings?.agentModelName) || "default_model" };
+}
+
+export function summaryRequest(model, question) {
+  const q = Array.from(cleanTitleText(question)).slice(0, SUMMARY_INPUT_MAX).join("");
+  return {
+    model,
+    stream: false,
+    max_tokens: 200, // room for a reasoning model to think briefly and still answer
+    messages: [
+      {
+        role: "system",
+        content:
+          "You write window titles. Reply with ONLY a title of at most 8 words that says what " +
+          "the user's request is about, in the language the request is written in. No quotes, " +
+          "no trailing punctuation, no explanation. Do not answer or carry out the request.",
+      },
+      { role: "user", content: `Request:\n${q}` },
+    ],
+  };
+}
+
+/**
+ * The title out of the model's reply, or "" when the reply is not one.
+ *
+ * A model that ignores the instruction and starts answering the question must not get its first
+ * paragraph into the tab, so anything that is not a single short line is refused, and the caller
+ * keeps the trimmed question.
+ */
+export function pickSummary(body, max = TITLE_MAX) {
+  let raw = body?.choices?.[0]?.message?.content;
+  if (typeof raw !== "string") return "";
+  raw = raw.replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
+  const lines = raw.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  if (lines.length !== 1) return "";
+  const line = cleanTitleText(lines[0])
+    .replace(/^title\s*:\s*/i, "")
+    .replace(/^["'“”‘’`*]+|["'“”‘’`*]+$/gu, "")
+    .replace(/[.。!?]+$/u, "")
+    .trim();
+  const n = Array.from(line).length;
+  return n > 0 && n <= max ? line : "";
+}
+
+/**
+ * Ask the agent model for a title. → the title, or "" for every reason there is not one.
+ * Never throws: this runs beside a turn and must not be able to disturb it.
+ */
+export async function summariseForTitle(
+  question,
+  settings,
+  { fetchImpl = fetch, timeoutMs = 20_000 } = {},
+) {
+  const agent = agentModelFromSettings(settings);
+  if (!agent || !needsSummary(question)) return "";
+  try {
+    const res = await fetchImpl(chatEndpoint(agent.url), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(summaryRequest(agent.model, question)),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res?.ok) return "";
+    return pickSummary(await res.json());
+  } catch {
+    return "";
+  }
+}