@tiens.nguyen/gu-cli 1.0.788 → 1.0.789

package/gu-repl.mjs

@@ -65,6 +65,9 @@ import {
   runningDetailRows,
   runningCommandLabel,
   runningCommandRows,
+  dropRestatement,
+  isRestatement,
+  liveThoughtText,
   formatThinkTime,
   plainAnswer,
   summarizeError,
@@ -3316,7 +3319,33 @@ const paintThoughtRows = (block, hovered, collapsed = block.collapsed) => {
     collapsed,
     lines: THOUGHT_COLLAPSED_LINES,
   });
-  return rows.map((r) => GUTTER + paint(r));
+  return (block.lead ? [""] : []).concat(rows.map((r) => THOUGHT_GUTTER + paint(r)));
+};
+
+/**
+ * A THOUGHT HAS ITS OWN MARK AND ITS OWN ROOM (task #334).
+ *
+ * Reported with a screenshot: "● listed files · read file 7×" and, flush under it in the same
+ * grey at the same indent, "The user wants me to use the .env file…" — which read as the rest of
+ * the bullet. Two things were missing, both since #326 made the look-ups ONE row that stays where
+ * it is while thoughts print under it (before that a blank or the question always sat above):
+ *
+ *   THE MARK — a dim rule down the margin, on every row of the block, so two or twenty rows read
+ *   as one thing and never as an action ("●" means something was DONE). It takes the gutter's own
+ *   three cells, so no row gets wider and nothing that measures rows changes.
+ *
+ *   THE BLANK ROW — owned by the BLOCK (`lead`), not written beside it. The open group's row is
+ *   rewritten in place and everything under it is found by row arithmetic that expects the blocks
+ *   to touch (stepGroupStillOpen, the merge below, the shift when a block opens); a blank that
+ *   belonged to nobody would break each of those. As the block's first row it moves, repaints
+ *   and is replaced with the block.
+ */
+const THOUGHT_GUTTER = " " + dim("│") + " ";
+
+/** Is the last finished line of the transcript empty (so a block printed now needs no blank)? */
+const transcriptEndsBlank = () => {
+  const lines = transcript.lines();
+  return lines.length < 2 || stripAnsiEscapes(lines[lines.length - 2] ?? "").trim() === "";
 };
 
 /** Width available to a thought row: the screen, less the gutter it hangs in. */
@@ -3332,7 +3361,9 @@ const thoughtWidth = () =>
  */
 function printThoughtBlock(raw, before) {
   if (!sessionShowThought) return false;
-  const prose = thoughtProse(raw);
+  // The question said back ("The user wants me to…") is dropped from the front (#333): it sits
+  // directly under the question, and it was all the two collapsed rows had room for.
+  const prose = dropRestatement(thoughtProse(raw), turnQuestionText);
   if (!prose) return false; // a bare tool label or pure code — not what anyone means by a thought
   const rows = thoughtBlockRows(prose, {
     width: thoughtWidth(),
@@ -3359,12 +3390,7 @@ function printThoughtBlock(raw, before) {
   const prev = thoughtBlocks[thoughtBlocks.length - 1];
   if (prev && !prev.kind && prev.collapsed && prev.to === transcript.dropped() + transcript.length() - 2) {
     const merged = prev.prose.replace(/\s+$/, "") + " " + prose;
-    const grown = thoughtBlockRows(merged, {
-      width: thoughtWidth(),
-      collapsed: true,
-      lines: THOUGHT_COLLAPSED_LINES,
-    });
-    const newEnd = transcript.replaceRange(prev.from, prev.to, grown.map((r) => GUTTER + dim(r)));
+    const newEnd = transcript.replaceRange(prev.from, prev.to, paintThoughtRows({ ...prev, prose: merged }, false));
     if (newEnd !== null) {
       prev.prose = merged;
       prev.to = newEnd;
@@ -3377,11 +3403,16 @@ function printThoughtBlock(raw, before) {
     }
     // Scrolled out of the buffer — fall through and print a new block rather than lose it.
   }
-  process.stdout.write(rows.map((r) => GUTTER + dim(r)).join("\n") + "\n");
+  // Its own blank row when what is above is not one — see THOUGHT_GUTTER.
+  const block = { from: 0, to: 0, prose, collapsed: true, lead: !transcriptEndsBlank() };
+  const painted = paintThoughtRows(block, false);
+  process.stdout.write(painted.join("\n") + "\n");
   // Record where it landed. Measured AFTER the write so a trim during it cannot skew the
   // range: the last completed line is length-2 (the final entry is the still-open line).
   const endAbs = transcript.dropped() + transcript.length() - 2;
-  thoughtBlocks.push({ from: endAbs - rows.length + 1, to: endAbs, prose, collapsed: true });
+  block.from = endAbs - painted.length + 1;
+  block.to = endAbs;
+  thoughtBlocks.push(block);
   if (thoughtBlocks.length > 200) thoughtBlocks = thoughtBlocks.slice(-200);
   return true;
 }
@@ -10765,7 +10796,25 @@ async function askTokenAtStart() {
 /** The token refresh started at launch — askTokenAtStart waits for it (see there). */
 let startupTokenRefresh = null;
 
+/**
+ * The fuller live thought (what the status row is driven from once it is longer than the row),
+ * held to the same rule as the short one (#333): from its first real sentence, without the
+ * question or gu's own instructions said back — "" while that is all there is so far.
+ */
+const liveThoughtClean = (text) => {
+  const kept = dropRestatement(text, turnQuestionText);
+  return isRestatement(kept, turnQuestionText) ? "" : liveThoughtText(kept);
+};
+
+// The question the running turn is answering — what a thought is compared with so that the
+// question said back is not printed under the question (#333). Display only.
+let turnQuestionText = "";
+
 async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {}) {
+  {
+    const asked = [...(Array.isArray(history) ? history : [])].reverse().find((m) => m?.role === "user");
+    turnQuestionText = typeof asked?.content === "string" ? asked.content : "";
+  }
   // #238: when the licence is ENFORCED and this account is not entitled, no turn is sent. Decided at
   // startup (see licenceBlock) — never re-checked here, so a turn cannot die halfway through.
   if (licenceBlock) {
@@ -11008,6 +11057,28 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   // became of it. A no-code retry notice discards it (the model restates the plan on the retry);
   // anything else prints it. Always null under --verbose, which shows everything as it comes.
   let heldThought = null;
+  // A THOUGHT INTERRUPTED BY THE HEARTBEAT IS STILL ONE THOUGHT (#333). The worker's
+  // "…almost completed thinking… (180s)" is a step, and a step closes the stream fence — in the
+  // MIDDLE of the model's sentence. The fence then reopens and the rest of the sentence arrived
+  // as a new thought: the live line read `one, call use_skill(name) FIRST…` and
+  // `` `, `bootstrap-api-service.mjs` — add… `` (both from stored streams), and the history got
+  // the thought in two halves. So a closing fence is only PARKED here: if nothing but blanks and
+  // heartbeats follow and the fence opens again, the thought carries on where it stopped;
+  // anything else finishes it exactly as before.
+  let pausedFence = null; // { step, fence } while a fence is closed but not yet finished
+  const finishPausedFence = () => {
+    if (!pausedFence) return;
+    const step = pausedFence.step;
+    pausedFence = null;
+    // The step's model output is complete. Print its reasoning HERE, before the tools
+    // report what they did, so the transcript reads in the order it happened: the model
+    // says what it intends, then the actions it took appear under it.
+    if (!REPL_VERBOSE && step.trim() && !stepHasCode(step)) {
+      heldThought = step; // #45: decided by the next line — see releaseHeldThought
+    } else if (printThoughtBlock(step, onContent)) {
+      lastWasBlank = false;
+    }
+  };
   const releaseHeldThought = () => {
     if (heldThought === null) return;
     const raw = heldThought;
@@ -11551,6 +11622,9 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
         almostDone = /almost/i.test(line);
         continue;
       }
+      // A parked fence (see pausedFence) is finished by the first real line that is not the
+      // fence opening again.
+      if (pausedFence && line.trim() !== "" && !isFenceLine(line)) finishPausedFence();
       // #45: retry notices and context-window bookkeeping are the agent's own machinery. Shown
       // under --verbose only; otherwise swallowed, together with the no-code false start the
       // retry notice is about.
@@ -11606,17 +11680,19 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
       if (isFenceLine(line)) {
         inStreamFence = !inStreamFence;
         if (inStreamFence) {
-          fenceThought = "";
-          stepThought = "";
-        } else {
-          // The step's model output is complete. Print its reasoning HERE, before the tools
-          // report what they did, so the transcript reads in the order it happened: the model
-          // says what it intends, then the actions it took appear under it.
-          if (!REPL_VERBOSE && stepThought.trim() && !stepHasCode(stepThought)) {
-            heldThought = stepThought; // #45: decided by the next line — see releaseHeldThought
-          } else if (printThoughtBlock(stepThought, onContent)) {
-            lastWasBlank = false;
+          if (pausedFence) {
+            // …the same thought, carrying on. The fence close put a line break where the model
+            // had none ("…When the TASK matches" / " one, call…"), so the two halves are joined
+            // on the line they were cut in.
+            stepThought = pausedFence.step.replace(/\n$/, "");
+            fenceThought = pausedFence.fence.replace(/\n$/, "");
+            pausedFence = null;
+          } else {
+            fenceThought = "";
+            stepThought = "";
           }
+        } else {
+          pausedFence = { step: stepThought, fence: fenceThought };
           stepThought = "";
         }
         continue;
@@ -11636,11 +11712,13 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
         // Accumulate a bounded head of the stream (enough to see the Thought prose OR the
         // tool call), capped so a 16k-char runaway can't grow the buffer. normalizeThought
         // yields a clean label — never raw code/CSS.
-        if (fenceThought.length < 400) {
+        // (1200, not 400, since #333: the line is now taken from past the question said back,
+        // and a restatement alone can run to a few hundred characters)
+        if (fenceThought.length < 1200) {
           fenceThought += line + "\n";
-          const th = normalizeThought(fenceThought);
+          const th = normalizeThought(fenceThought, { question: turnQuestionText });
           if (th) liveThought = th;
-          fullLiveThought = thoughtFull(fenceThought); // #96: keep the fuller thought for expand
+          fullLiveThought = liveThoughtClean(thoughtFull(fenceThought)); // #96: keep the fuller thought for expand
         }
         continue;
       }
@@ -11852,9 +11930,9 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     // live clause from the partial too, so the blinking line updates mid-sentence instead
     // of only once the line finally breaks (task #64).
     if (inStreamFence && fenceThought.length < 400) {
-      const th = normalizeThought(fenceThought + carry);
+      const th = normalizeThought(fenceThought + carry, { question: turnQuestionText });
       if (th) liveThought = th;
-      fullLiveThought = thoughtFull(fenceThought + carry); // #96: fuller thought for expand
+      fullLiveThought = liveThoughtClean(thoughtFull(fenceThought + carry)); // #96: fuller thought for expand
     }
     // A non-empty remainder is a partial CONTENT line (heartbeats always arrive whole with
     // a newline), so tokens are actively flowing — keep the ticker asleep. EXCEPT a buffered
@@ -12055,6 +12133,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
             lastWasBlank = false;
           }
         }
+        finishPausedFence(); // #333: a fence closed and nothing followed — it is finished now
         releaseHeldThought(); // #45: nothing followed it, so it was not a false start
         clearStatus();
         // Task #104: expose this turn's code-model INPUT + the CUMULATIVE output-token

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.788",
+  "version": "1.0.789",
   "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",

package/terminal-layout.mjs

@@ -2434,11 +2434,104 @@ export function firstToolArg(codePart) {
   return { name: m[1], arg: String(value).trim() };
 }
 
+/**
+ * WHERE A THOUGHT LINE REALLY STARTS (task #333).
+ *
+ * The live line once read `one, call use_skill(name) FIRST, read what it returns, and follow it".
+ * I'll…` for 83 seconds, and later `` `, `bootstrap-api-service.mjs` — add … `` — both the tail of
+ * a sentence whose head had been cut away. The main cause is fixed where it happened (a heartbeat
+ * splitting the thought, see the fence handling in gu-repl.mjs); this is the guard for every other
+ * way a line can arrive headless (a poll boundary, a buffer cap): a line that opens with closing
+ * punctuation, or with a lower-case word, is the middle of something. Start at the next sentence
+ * instead — and when there is none, say nothing ("" keeps whatever the line showed before).
+ */
+const _SENTENCE_END = /[.!?]["'”’`)\]]*\s+(?=["'“‘`(\[]?[A-Z0-9])/g;
+
+export function thoughtLineStart(line) {
+  const s = String(line ?? "").trim();
+  if (!s) return "";
+  const headless =
+    /^[`'"”’)\]}]*\s*[,.;:!?)\]}]/.test(s) || // "`, `bootstrap…", ", and then", ") so"
+    /^[a-z]/.test(s);                          // "one, call use_skill…" — a sentence starts with a capital
+  if (!headless) return s;
+  _SENTENCE_END.lastIndex = 0;
+  const m = _SENTENCE_END.exec(s);
+  return m ? s.slice(m.index + m[0].length).trim() : "";
+}
+
+/**
+ * gu's OWN INSTRUCTIONS, recited (task #333). A model weighing its prompt quotes it — "Rules say
+ * call use_skill FIRST when the task matches" — and the status line then shows gu's scaffolding as
+ * if it were news about the user's task. Matched by the fixed phrases of the prompt blocks the
+ * worker writes (gu_skills.prompt_block, the workspace directives); a sentence carrying one is
+ * not shown on the live line.
+ */
+const _PROMPT_ECHO = /use_skill\(name\)|call use_skill\b[^.]*\bFIRST\b|When the TASK matches|WORK LIKE A SENIOR DEVELOPER|packaged instructions for particular kinds of work/i;
+
+/** Split prose into sentences, keeping each one's own punctuation. */
+function _sentences(text) {
+  const s = String(text ?? "").trim();
+  const out = [];
+  let from = 0;
+  _SENTENCE_END.lastIndex = 0;
+  let m;
+  while ((m = _SENTENCE_END.exec(s))) {
+    out.push(s.slice(from, m.index + m[0].length).trim());
+    from = m.index + m[0].length;
+  }
+  if (from < s.length) out.push(s.slice(from).trim());
+  return out.filter(Boolean);
+}
+
+/** The line to show live: from its first real sentence, past any recital of gu's own prompt. */
+export function liveThoughtText(line) {
+  const sentences = _sentences(thoughtLineStart(line));
+  const at = sentences.findIndex((x) => !_PROMPT_ECHO.test(x));
+  return at < 0 ? "" : sentences.slice(at).join(" ");
+}
+
+/**
+ * THE QUESTION, SAID BACK (task #333). A thought that opens "The user wants me to use the .env
+ * file and add a template file." sits directly under ">> currently we are not using the .env
+ * file, please use that and also add a template file" — the same thing twice, and on the two
+ * collapsed rows that are all most people read. Measured on this machine's stored turns: 169 of
+ * 296 first thoughts (57%) open this way.
+ *
+ * Leading sentences that restate are dropped; what the model said NEXT — what it will look at,
+ * what it found — becomes the block's first row. Two tests, either is enough: the sentence is
+ * shaped like a restatement ("The user wants/says/asks…", "Let me understand the task"), or most
+ * of its words are the question's own. Only from the START, and never the whole thought: when
+ * every sentence restates, the last one is kept, so a thought is shortened, not lost.
+ * Display only — what the model wrote, and what is sent back to it, are untouched.
+ */
+const _RESTATE_SHAPE = /^(?:(?:ok(?:ay)?|so|alright|right|now|first)[,.]?\s+)*(?:let me (?:first\s+)?(?:understand|re-?read|restate|parse|break down|think about)\b[^.]*\b(?:task|request|question|ask)|the user(?:'s (?:request|question|task|message))?\s+(?:wants?|says?|said|is asking|asks?|asked|would like|needs?|is|has asked|requests?)|the (?:task|request|question)(?:\s+is)?\s*[:,]|(?:the )?user (?:request|query|message)\s*[:,]|the (?:system prompt|instructions?|rules?|skill)\s+(?:says?|tells?|states?|wants?|requires?)|(?:rules?|instructions?) say\b)/i;
+
+const _words = (t) => String(t ?? "").toLowerCase().match(/[a-z0-9_.-]{3,}/g) ?? [];
+
+/** Is this ONE sentence the question (or gu's instructions) said back? */
+export function isRestatement(sentence, question = "") {
+  if (_RESTATE_SHAPE.test(sentence)) return true;
+  const asked = new Set(_words(question));
+  if (asked.size < 4) return false;
+  const w = _words(sentence);
+  if (w.length < 4) return false;
+  return w.filter((x) => asked.has(x)).length / w.length >= 0.7;
+}
+
+export function dropRestatement(prose, question = "") {
+  const sentences = _sentences(prose);
+  if (sentences.length < 2) return String(prose ?? "").trim();
+  const restates = (sentence) => isRestatement(sentence, question);
+  let at = 0;
+  while (at < sentences.length - 1 && restates(sentences[at])) at++;
+  return sentences.slice(at).join(" ");
+}
+
 /**
  * Raw in-fence stream → a short, meaningful status: a real Thought clause if the model wrote
  * one, else a label naming the tool it is calling, else "" (the caller shows "Thinking…").
  */
-export function normalizeThought(buf) {
+export function normalizeThought(buf, { question = null } = {}) {
   const t = String(buf || "");
   const ci = t.search(/<code[\s>]/i);
   const head = ci >= 0 ? t.slice(0, ci) : t;
@@ -2455,7 +2548,24 @@ export function normalizeThought(buf) {
     .map((x) => x.trim())
     .find(Boolean);
   const proseIsClause = !!prose && prose.length >= 6 && prose.trim().split(/\s+/).length >= 2;
-  if (proseIsClause && !_thoughtLooksCodey(prose)) return prose.slice(0, 100);
+  if (proseIsClause && !_thoughtLooksCodey(prose)) {
+    // …from where a sentence starts, and never gu's own prompt said back (#333). A line with
+    // nothing left falls through to the tool label / "", like any other non-thought.
+    //
+    // WITH THE QUESTION KNOWN (the terminal passes it), the line is taken from the whole head
+    // rather than its first line, minus the question said back: "The user wants me to read
+    // package.json…" sat on the status row for the whole wait while the next sentence — what
+    // the model was actually about to do — was already there. While all there is so far IS the
+    // restatement, nothing is shown: the row keeps "Thinking" for the second that takes.
+    let text = prose;
+    if (question !== null) {
+      const whole = head.replace(/^\s*Thought:\s*/i, "").replace(/\s+/g, " ").trim();
+      text = dropRestatement(whole, question);
+      if (isRestatement(text, question)) text = "";
+    }
+    const shown = liveThoughtText(text);
+    if (shown.length >= 6 && shown.split(/\s+/).length >= 2) return shown.slice(0, 100);
+  }
   // 2) otherwise name the tool being called (from the code part).
   const codePart = ci >= 0 ? t.slice(ci) : t;
   const call = firstToolArg(codePart);