@tiens.nguyen/gu-cli 1.0.822 → 1.0.824

package/gonext_agent_chat.py

@@ -2026,7 +2026,11 @@ def _is_greeting_smalltalk(text: str) -> bool:
 # self-labels as "Thought"/"Thinking Process" up front (a real answer doesn't open by
 # naming itself as the model's own reasoning), or it's dense with self-correction
 # language a finished answer wouldn't contain.
-_SCRATCHPAD_START_RE = re.compile(r"^\s*thought\b\s*[:\n]", re.I)
+# The label may come dressed as markdown — "## Thought" or "**Thought:**" — and is still the
+# model naming its own reasoning (#139: Kimi K3 wrote "## Thought\n\n… Let me check git status"
+# and it was delivered as the ANSWER to "commit", so nothing ran).
+_SCRATCHPAD_START_RE = re.compile(
+    r"^\s*(?:#{1,6}\s*|\*\*|__)?thought(?:\s*:|\s*(?:\*\*|__)\s*:?|\s*\n)", re.I)
 _DELIBERATION_RE = re.compile(
     r"\b(wait,|actually,|let'?s (try|just|use|list|see|go)|"
     r"i (?:need to|should) (?:check|verify|confirm))\b",
@@ -5224,6 +5228,37 @@ def _has_runnable_block(text) -> bool:
         return False
 
 
+# Chat-template control tokens a served model sometimes prints instead of acting on (#139,
+# Kimi K3 on ollama.com: "Thought: …<|close|>think<|sep|><|open|>response<|sep|>"). They mark
+# where the model's own reasoning ended and its reply began.
+_TEMPLATE_TOKEN_RE = re.compile(r"<\|[a-z_]{2,24}\|>(?:\s*[a-z_]{2,24}\s*<\|[a-z_]{2,24}\|>)*", re.I)
+
+
+def _strip_leaked_template(content):
+    """Cut leaked chat-template tokens out of a reply; keep what came after the last one.
+
+    Text before the last token is the model's reasoning written into the visible channel; text
+    after it is the reply. An EMPTY reply stays empty, so the empty-content nudge asks the model
+    to act instead of the step failing on a plan that ran nothing (seen live: three steps of
+    "Thought: … now final answer.<|close|>think…" before a final_answer). Tokens inside a
+    <code> block are file content, never ours to touch."""
+    if not isinstance(content, str) or "<|" not in content:
+        return content
+    spans = [m.span() for m in re.finditer(_CODE_PAIR_RE, content, re.I)]
+    last = None
+    for m in _TEMPLATE_TOKEN_RE.finditer(content):
+        if not any(a <= m.start() < b for a, b in spans):
+            last = m
+    if last is None:
+        return content
+    reply = content[last.end():].strip()
+    if reply:
+        return reply
+    head = _TEMPLATE_TOKEN_RE.sub("", content[:last.start()]).strip()
+    # A runnable block before the tokens is still the action — keep it.
+    return head if _has_runnable_block(head) else ""
+
+
 def _code_nudge_reason(content, openai_backend: bool):
     """Why (if at all) this streamed turn should be re-prompted once with the CODE-NOW
     directive — or None to accept it as-is. Pure decision so the three triggers can be
@@ -5234,14 +5269,16 @@ def _code_nudge_reason(content, openai_backend: bool):
          merely TRUNCATED at the `</code>` stop sequence is not that (task #119): it is
          closed first and accepted as-is, so a step that already called a tool no longer
          pays for a second model call to be told to do what it just did.
-      3. prose-only plan — narration of what it is ABOUT to do, no tag at all. This one
-         is openai-only and additionally requires _looks_like_scratchpad, so a FINISHED
-         prose answer is never nudged into inventing another tool call. It exists because
-         the "</code>" visible in a smolagents trace is appended by smolagents AFTER the
-         model returns, so trigger 2 cannot see this shape.
-
-    Triggers 1 and 2 keep their existing backend-agnostic behavior — the Ollama path is
-    unchanged, since trigger 3 is the only new one and it is gated off there."""
+      3. prose-only plan — narration of what it is ABOUT to do, no tag at all. It
+         requires _looks_like_scratchpad, so a FINISHED prose answer is never nudged into
+         inventing another tool call. It exists because the "</code>" visible in a
+         smolagents trace is appended by smolagents AFTER the model returns, so trigger 2
+         cannot see this shape.
+
+    All three apply on every backend. Trigger 3 was openai-only (kept off small local
+    Ollama models); #139 showed the cost: Kimi K3 served by ollama.com is an "ollama"
+    backend, so each plan-only reply burned a whole failed step instead of one retry.
+    `openai_backend` is kept for callers and no longer changes the decision."""
     text = (content or "").strip()
     if not text:
         return "empty-content"
@@ -5249,7 +5286,7 @@ def _code_nudge_reason(content, openai_backend: bool):
         return None  # a real block (closing a stop-truncated one first) — nothing to nudge
     if re.search(r"</?code[\s>/]", content, re.I):
         return "dangling code tag, no valid block"
-    if openai_backend and _looks_like_scratchpad(text):
+    if _looks_like_scratchpad(text):
         return "prose-only plan, no code block"
     return None
 
@@ -11730,6 +11767,12 @@ def run_agent_chat(cfg):
             # anything downstream asks "did this turn produce a code block?" — otherwise a
             # step that called a tool correctly reads as broken. Gated on the code actually
             # compiling, so a genuinely dangling tag still falls through to the nudge below.
+            # Leaked chat-template tokens first (#139): what came before them is reasoning.
+            _unleaked = _strip_leaked_template(content)
+            if _unleaked != content:
+                _log(f"leaked chat-template tokens → kept the reply after them "
+                     f"({len(content)} → {len(_unleaked)} chars)")
+                content = _unleaked
             content = _close_dangling_code_block(content)
             # TAGS FIRST, judgement second. The tag repair used to run much later, so every
             # decision in between — is this a code block? does it need a nudge? — was made on

package/gu-relaunch.mjs

@@ -0,0 +1,35 @@
+/**
+ * `gu` without the bin path in the macOS window title (#358) — see relaunchPlan in
+ * terminal-title.mjs. gu-repl.mjs imports this FIRST, so the process is replaced before any other
+ * module has loaded or anything has been drawn.
+ */
+import { fileURLToPath } from "node:url";
+import { relaunchPlan, restoreAfterRelaunch } from "./terminal-title.mjs";
+
+export const RELAUNCHED = restoreAfterRelaunch(process);
+
+if (!RELAUNCHED) {
+  const plan = relaunchPlan({
+    platform: process.platform,
+    hasExecve: typeof process.execve === "function",
+    env: process.env,
+    argv: process.argv,
+    execPath: process.execPath,
+    script: fileURLToPath(new URL("./gu-repl.mjs", import.meta.url)),
+    stdinTTY: !!process.stdin.isTTY,
+    stdoutTTY: !!process.stdout.isTTY,
+  });
+  if (plan) {
+    // Node 23–24 flag execve as experimental; that warning would be gu's first line.
+    const emitWarning = process.emitWarning;
+    process.emitWarning = (w, ...rest) =>
+      /execve/i.test(String(w?.message ?? w)) ? undefined : emitWarning.call(process, w, ...rest);
+    try {
+      process.execve(plan.file, plan.args, plan.env); // does not return when it works
+    } catch {
+      // not allowed here (sandbox, odd node build): start the normal way, path and all
+    } finally {
+      process.emitWarning = emitWarning;
+    }
+  }
+}

package/gu-repl.mjs

@@ -23,6 +23,7 @@
  * Requires the worker daemon to be running (it claims the job).
  * Commands: /exit  /model  /new  /help   Ctrl-C stops following the current run.
  */
+import { RELAUNCHED } from "./gu-relaunch.mjs"; // FIRST: may replace this process (#358)
 import { readFile, mkdir, writeFile, unlink, rename } from "node:fs/promises";
 import { readStepTokens, readTurnCache } from "./step-tokens.mjs";
 import { snapshotInput, restoreInput, replaceStoppedQuestion, restoredQuestionLetGo, stopNoteLines } from "./turn-stop.mjs";
@@ -14571,3 +14572,10 @@ function releaseScreenAtExit() {
 }
 
 main();
+// Relaunched as `gu` (gu-relaunch.mjs), this file is Node's --import preload, and Node opens its
+// own REPL on the terminal once the preload finishes — so it does not finish. When nothing is
+// left to do, gu exits with its own code instead of Node's "unsettled top-level await" (13).
+if (RELAUNCHED) {
+  process.on("beforeExit", () => process.exit(process.exitCode ?? 0));
+  await new Promise(() => {});
+}

package/package.json

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

package/terminal-title.mjs

@@ -22,6 +22,8 @@
  * the bytes.
  */
 
+import { pathToFileURL } from "node:url";
+
 /** What fits on a tab next to its neighbours. Terminals clip a title; they do not wrap it. */
 export const TITLE_MAX = 60;
 
@@ -77,6 +79,56 @@ export function idleTitle(folder) {
   return name ? `gu · ${trimTitle(name, TITLE_MAX - 5)}` : "gu";
 }
 
+/**
+ * THE PATH AFTER THE TITLE (#358). macOS Terminal (and iTerm) put the running process and its
+ * arguments next to the title gu sets: `bb3d — gu · bb3d — node /opt/homebrew/Cellar/node/…/bin/gu`.
+ * The kernel builds that argv from the `#!/usr/bin/env node` line, so gu cannot change it in
+ * place — `process.title` blanks the argv area and Terminal then shows the first ENVIRONMENT
+ * variable instead (`gu TMPDIR=/var/folders/…`), and a child process shows as `gu ◂ node …`.
+ *
+ * What does work: replace the process (process.execve, Node ≥ 23.11) with node whose whole argv
+ * is `gu` and which loads this script as an --import preload. Terminal then shows `gu`. The
+ * user's flags travel in an env var, and restoreAfterRelaunch puts process.argv back the way
+ * it was, so nothing after it can tell. Node starts its own REPL once a preload finishes, so
+ * the relaunched gu-repl.mjs never finishes (see its last lines).
+ *
+ * Only for the plain interactive `gu` on macOS: a subcommand, --help/--version, a pipe (node
+ * would read a PROGRAM from a non-terminal stdin), Windows and Linux keep the old start.
+ * GU_NO_RELAUNCH=1 turns it off.
+ */
+export const RELAUNCH_ENV = "GU_RELAUNCHED";
+
+/** → { file, args, env } for process.execve, or null to start the normal way. */
+export function relaunchPlan({ platform, hasExecve, env = {}, argv = [], execPath, script, stdinTTY, stdoutTTY }) {
+  if (platform !== "darwin" || !hasExecve || !stdinTTY || !stdoutTTY || !execPath || !script) return null;
+  if (env[RELAUNCH_ENV] != null || env.GU_NO_RELAUNCH === "1") return null;
+  const args = argv.slice(2);
+  if (args.some((a) => !a.startsWith("-") || a === "--help" || a === "-h" || a === "--version")) return null;
+  const state = JSON.stringify({ script, args, nodeOptions: env.NODE_OPTIONS ?? null });
+  // A file URL has no spaces (%20) and no quotes, so it is one NODE_OPTIONS word as it stands.
+  const nodeOptions = [`--import=${pathToFileURL(script).href}`, env.NODE_OPTIONS].filter(Boolean).join(" ");
+  return { file: execPath, args: ["gu"], env: { ...env, [RELAUNCH_ENV]: state, NODE_OPTIONS: nodeOptions } };
+}
+
+/**
+ * In the relaunched process: put process.argv and NODE_OPTIONS back, and take the marker out of
+ * the environment — every process gu starts (the worker, the agent's commands) inherits it, and
+ * a NODE_OPTIONS that preloads gu-repl.mjs would start a gu inside each node they run.
+ * → true when this process is the relaunched one.
+ */
+export function restoreAfterRelaunch(proc) {
+  const raw = proc.env[RELAUNCH_ENV];
+  if (raw == null) return false;
+  delete proc.env[RELAUNCH_ENV];
+  let s;
+  try { s = JSON.parse(raw); } catch { return false; }
+  if (proc.argv.length !== 1 || !s?.script) return false; // a stale marker, not our relaunch
+  if (s.nodeOptions == null) delete proc.env.NODE_OPTIONS;
+  else proc.env.NODE_OPTIONS = s.nodeOptions;
+  proc.argv.splice(0, proc.argv.length, proc.execPath, s.script, ...(s.args ?? []));
+  return true;
+}
+
 /** 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(/\/+$/, "");