@tiens.nguyen/gu-cli 1.0.787 → 1.0.789

package/gu-repl.mjs

@@ -63,6 +63,11 @@ import {
   ragSegmentLabel,
   searchSegmentLabel,
   runningDetailRows,
+  runningCommandLabel,
+  runningCommandRows,
+  dropRestatement,
+  isRestatement,
+  liveThoughtText,
   formatThinkTime,
   plainAnswer,
   summarizeError,
@@ -128,6 +133,7 @@ import {
 } from "./terminal-layout.mjs";
 import { completedFlush, splitLiveStream } from "./completed-flush.mjs";
 import { isScaffoldStep, isGroupableStep, stepGroupRows, relativizePaths } from "./step-group.mjs";
+import { clearLogsNoticeText } from "./clear-logs.mjs";
 import { discoverSkills, matchSkillCommand } from "./skills.mjs";
 import { appendNew, archivePathFor, archivedWorkspaceKey, markReset, seedArchive } from "./conversation-archive.mjs";
 import { addAllowRule, listServers as listMcpServers } from "./mcp-config.mjs";
@@ -891,6 +897,7 @@ const COMMANDS = [
   { name: "/use-presets", usage: "/use-presets [name]", desc: "pick a saved preset and apply it — shows what changes, backs up your setup, asks first" },
   { name: "/doctor", desc: "check every configured model ANSWERS — especially the embedder, which a turn only reaches after several steps" },
   { name: "/tokens", desc: "break down the last prompt sent to the coding model — how much of it was RAG" },
+  { name: "/clear-logs", desc: "show what gu's logs, RAG indexes and old API versions take on disk, then ask what to clear — the logs first" },
   { name: "/prices", usage: "/prices [update]", desc: "the price table and the cache table, and what the last turn and this session cost — \"update\" applies gu's newest published tables" },
   // ONE name, /new (user, #278). /reset and /clear still work (HIDDEN_COMMANDS) for habit and
   // for Claude Code users — not to be confused with `gu clear` in a shell, which wipes gu's state.
@@ -1462,6 +1469,11 @@ function applyClick({ row, col }) {
     void runPricesUpdate();
     return;
   }
+  if (logsRowTarget && row === updateRowAbs &&
+      col - 1 >= logsRowTarget.from && col - 1 < logsRowTarget.to) {
+    void runClearLogs();
+    return;
+  }
   if (agentsRowTarget && row === updateRowAbs &&
       col - 1 >= agentsRowTarget.from && col - 1 < agentsRowTarget.to) {
     void showOtherAgents(); // async now — it offers stop / switch-to (task #211)
@@ -2680,6 +2692,9 @@ function zoneNotice(width) {
   if (tokenNotice?.text) items.push({ key: "token", paint: tokenNotice.urgent ? yellow : dim, text: tokenNotice.text });
   const agents = agentsIndicator(otherAgents);
   if (agents) items.push({ key: "agents", clickable: true, paint: accent, text: `${agents} running (click)` });
+  // LAST, so it is the first to give way on a narrow window: housekeeping, never urgent (#329).
+  const logs = clearLogsNoticeText(logsBytes);
+  if (logs) items.push({ key: "logs", clickable: true, paint: dim, text: logs });
   return noticeRow(items, { width, gutter: GUTTER });
 }
 
@@ -2760,6 +2775,7 @@ function frozenZone() {
   updateRowTarget = notice?.spans.update ?? null;
   agentsRowTarget = notice?.spans.agents ?? null;
   pricesRowTarget = notice?.spans.prices ?? null;
+  logsRowTarget = notice?.spans.logs ?? null;
   jumpSpan = notice?.spans.jump ?? null;
   return { ...zone, rows, statusRows: sep, noticeRow: Boolean(notice) };
 }
@@ -2829,7 +2845,7 @@ function paintBar() {
   // THE NOTICE ROW is the one directly above the separator (#318) — never the separator itself.
   const noticeAbs = zone.noticeRow ? sepAbs - 1 : 0;
   jumpRowTarget = scrolledBack() && jumpSpan ? { row: noticeAbs, ...jumpSpan } : null;
-  updateRowAbs = updateRowTarget || agentsRowTarget || pricesRowTarget ? noticeAbs : 0;
+  updateRowAbs = updateRowTarget || agentsRowTarget || pricesRowTarget || logsRowTarget ? noticeAbs : 0;
   // preserveCaret:false — the save slot holds the OUTPUT position (see regionUi), and the caret
   // is parked on the input line right after, so there is nothing to preserve here.
   ui(
@@ -2991,6 +3007,8 @@ let updateRowAbs = 0;
 let agentsRowTarget = null;
 // …and "new prices updated <date>" (#323).
 let pricesRowTarget = null;
+// …and "clear logs · 175 MB" (#329), shown only once the logs are worth a row.
+let logsRowTarget = null;
 // A terminal left with a scrolling region is a broken shell — a hard guarantee, like the
 // bracketed-paste and mouse-reporting teardowns.
 process.on("exit", () => {
@@ -3301,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. */
@@ -3317,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(),
@@ -3344,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;
@@ -3362,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;
 }
@@ -7879,6 +7925,128 @@ async function runPricesUpdate() {
   }
 }
 
+// ---------------------------------------------------------------------------------------------
+// "CLEAR LOGS" (#329): a quiet item at the right of the notice row once gu's logs are worth a row,
+// and /clear-logs for where there is no mouse. A click deletes nothing: it MEASURES — the logs,
+// and beside them the two things that are actually big, the RAG indexes and the downloaded API
+// versions — shows that with a total, then asks about each. What each "clear" may and may not
+// touch is decided in clear-logs.mjs; this is the terminal half only.
+// ---------------------------------------------------------------------------------------------
+let logsBytes = 0; // what the notice shows; only the logs are measured for it (a handful of stats)
+let clearLogsBusy = false;
+
+async function refreshLogsSize() {
+  try {
+    const { surveyLogs } = await import("./clear-logs.mjs");
+    const was = clearLogsNoticeText(logsBytes);
+    logsBytes = (await surveyLogs()).bytes;
+    if (clearLogsNoticeText(logsBytes) !== was && barPinned()) paintBar();
+  } catch {
+    /* a housekeeping notice is never worth an error */
+  }
+}
+
+async function runClearLogs() {
+  // ONE AT A TIME, and never over a turn or another picker — reached from a fire-and-forget click
+  // (see showOtherAgents for what a second picker over the first one does).
+  if (clearLogsBusy || listPickerActive || approvalActive || following) return;
+  clearLogsBusy = true;
+  try {
+    const cl = await import("./clear-logs.mjs");
+    const { LOCAL_API_PORT } = await import("./client-expert-api.mjs");
+    const width = Math.max(20, process.stdout.columns || 80);
+    console.log("\n" + GUTTER + dim("Measuring ~/.gonext…"));
+    // Which API version is ANSWERING decides what "old" means — ask it, do not infer it.
+    const runningVersion = await fetch(`http://127.0.0.1:${LOCAL_API_PORT}/api/health`, { signal: AbortSignal.timeout(2000) })
+      .then((r) => r.json())
+      .then((j) => String(j?.version ?? ""))
+      .catch(() => "");
+    const survey = await cl.surveyDisk({ runningVersion });
+    console.log("");
+    for (const row of cl.summaryRows(survey, { width: width - GUTTER.length - 1 })) {
+      console.log(GUTTER + (row.startsWith("Total") ? bold(row) : row));
+    }
+    const freed = [];
+    // A question never wraps: at 80 columns over SSH the picker hint goes on a row of its own.
+    const question = (q) => {
+      const hint = `(${PICK_HINT}):`;
+      console.log("");
+      if (2 + q.length + 2 + hint.length < width) console.log(dim(`  ${q}  ${hint}`));
+      else console.log(dim(`  ${q}\n  ${hint}`));
+    };
+    const cancelled = () => {
+      console.log(dim(`  (stopped — nothing ${freed.length ? "further " : ""}removed)\n`));
+      paintBar();
+    };
+
+    // 1. THE LOGS — what was asked for, so Yes is the first row.
+    if (survey.logs.bytes > 0) {
+      question(`Clear the logs — ${cl.humanSize(survey.logs.bytes)}?`);
+      const go = await pickFromList(["Yes — clear the logs" + dim("  · the worker and the API keep running"), "No"], 0);
+      if (go < 0) return cancelled();
+      if (go === 0) {
+        const r = await cl.clearLogs(survey.logs);
+        freed.push({ what: "logs", ...r });
+        console.log(GUTTER + accent(`✓ logs cleared — ${cl.humanSize(r.freed)} freed`) +
+          (r.failed.length ? yellow(`  (still in use, left alone: ${r.failed.join(", ")})`) : ""));
+      } else {
+        console.log(GUTTER + dim("logs kept"));
+      }
+    } else {
+      console.log("\n" + GUTTER + dim("No logs to clear."));
+    }
+
+    // 2. RAG — costs a re-index, so No is the first row.
+    if (survey.rag.indexes.length) {
+      const gone = survey.rag.indexes.filter((i) => i.missing);
+      const goneBytes = gone.reduce((n, i) => n + i.bytes, 0);
+      const choices = [{ id: "no", label: "No — keep them" }];
+      if (gone.length && gone.length < survey.rag.indexes.length) {
+        choices.push({ id: "gone", label: `Only the ${gone.length} whose folder no longer exists — ${cl.humanSize(goneBytes)}` });
+      }
+      choices.push({ id: "all", label: `Yes — all ${survey.rag.indexes.length}` + dim("  · a folder is indexed again when it is next used") });
+      question(`Also clear the RAG indexes — ${cl.humanSize(survey.rag.bytes)}?`);
+      const pick = await pickFromList(choices.map((c) => c.label), 0);
+      if (pick < 0) return cancelled();
+      if (choices[pick].id !== "no") {
+        const r = await cl.clearRagIndexes(choices[pick].id === "gone" ? gone : survey.rag.indexes);
+        freed.push({ what: "rag", ...r });
+        console.log(GUTTER + accent(`✓ ${r.removed} RAG index${r.removed === 1 ? "" : "es"} cleared — ${cl.humanSize(r.freed)} freed`) +
+          (r.failed.length ? yellow(`  (could not remove: ${r.failed.join(", ")})`) : ""));
+      } else {
+        console.log(GUTTER + dim("RAG indexes kept"));
+      }
+    }
+
+    // 3. THE API — only ever the OLDER versions; the one in use is not on offer.
+    if (survey.api.old.length) {
+      const n = survey.api.old.length;
+      question(`Also remove the ${n} older API version${n === 1 ? "" : "s"} — ${cl.humanSize(survey.api.oldBytes)}?`);
+      const go = await pickFromList(["No — keep them", `Yes — remove the ${n} older one${n === 1 ? "" : "s"}` +
+        dim(survey.api.inUse ? `  · ${survey.api.inUse}, the one in use, stays` : "")], 0);
+      if (go < 0) return cancelled();
+      if (go === 1) {
+        console.log(GUTTER + dim("Removing…"));
+        const r = await cl.clearOldApiVersions(survey.api.old);
+        freed.push({ what: "api", ...r });
+        console.log(GUTTER + accent(`✓ ${r.removed} older API version${r.removed === 1 ? "" : "s"} removed — ${cl.humanSize(r.freed)} freed`) +
+          (r.failed.length ? yellow(`  (could not remove: ${r.failed.join(", ")})`) : ""));
+      } else {
+        console.log(GUTTER + dim("older API versions kept"));
+      }
+    }
+
+    const total = freed.reduce((n, f) => n + f.freed, 0);
+    console.log("\n" + GUTTER + (freed.length ? bold(`${cl.humanSize(total)} freed in all.`) : dim("Nothing removed.")) + "\n");
+  } catch (e) {
+    console.log(GUTTER + red(`couldn't finish — ${e?.message ?? e}`) + "\n");
+  } finally {
+    clearLogsBusy = false;
+    await refreshLogsSize();
+    if (barPinned()) paintBar();
+  }
+}
+
 /**
  * `/embed-model` — switch the RAG embedder, the embed server, or the embed key (task #169).
  *
@@ -9708,6 +9876,10 @@ const RAGSTATE_PREFIX = "__RAGSTATE__::";
 // The tool ABOUT to run: "<label>\t<call>" (task #177). Swallowed from scrollback like
 // "Running → …" — it belongs to the live block, and the finished bullet replaces it.
 const RUNTOOL_PREFIX = "__RUNTOOL__::";
+// The command that is running, WHOLE (task #331): one line of JSON {cmd}, sent beside the
+// 70-character "Running → …" line — and how many lines it has printed so far. Both swallowed.
+const RUNCMD_PREFIX = "__RUNCMD__::";
+const RUNOUT_PREFIX = "__RUNOUT__::";
 const MAXSTEP_PREFIX = "__MAXSTEP__::";
 const TIMEOUT_PREFIX = "__TIMEOUT__::";
 const COMPACT_PREFIX = "__COMPACT__::";
@@ -10624,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) {
@@ -10842,6 +11032,12 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   let lastWordBucket = -1; // 12s window index → rotate the word once per window (task: 30-spinner)
   let almostDone = false; // set from the worker's "…almost completed thinking…" heartbeat
   let runningCmd = null; // the command currently executing (from a "Running → …" event)
+  // …the same command WHOLE, what it has printed so far, when it started, and whether the status
+  // row is hiding some of it (i.e. a click has something to open) — task #331.
+  let runningCmdFull = "";
+  let runningCmdLines = 0;
+  let runningCmdAt = 0;
+  let runningCmdMore = false;
   let runningTool = null; // { label, detail } for the tool executing right now (task #177)
   // The model's CURRENT Thought (task #64): while it streams its reasoning inside the
   // hidden ~~~ fence, show a one-clause summary on the blinking line so a 300s CPU-bound
@@ -10861,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;
@@ -11062,9 +11280,23 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     // to reveal). Line 1 (what's happening now): a live command > the model's current Thought >
     // "almost done" > "Thinking". When clickable we drive line 1 from the SAME fuller string, so
     // the grey expansion CONTINUES where line 1 was cut off instead of repeating the head.
-    const clickable = !!fullLiveThought && !runningCmd && fullLiveThought.length > max;
+    // A RUNNING COMMAND is its own kind of line (#331): "$ <first line>…  (17s · 5 lines)" on one
+    // row, and a click opens the whole command underneath instead of a thought's remainder.
+    const cmdView = runningCmd && !runningTool
+      ? runningCommandLabel(runningCmdFull || runningCmd, {
+          room: max,
+          secs: runningCmdAt ? Math.max(0, Math.round((now - runningCmdAt) / 1000)) : secs,
+          lines: runningCmdLines,
+          expanded: thoughtExpanded,
+        })
+      : null;
+    runningCmdMore = Boolean(cmdView?.more);
+    const clickable = cmdView ? cmdView.more : !!fullLiveThought && !runningCmd && fullLiveThought.length > max;
     let label, rest;
-    if (clickable) {
+    if (cmdView) {
+      label = cmdView.label;
+      rest = "";
+    } else if (clickable) {
       // Split at a WORD boundary near the line-1 width so nothing is cut mid-word: the last
       // space at/before max-1 (unless that snaps back too far into the line — then hard-cut).
       // Line 1 shows the head; the grey expansion CONTINUES from the same point (no dup, no
@@ -11084,7 +11316,13 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     }
     // When clicked, unfold the remainder as up to 4 wrapped GREY lines BETWEEN the thought and
     // the playful-word line.
-    const expLines = thoughtExpanded && rest ? wrapThought(rest, max, 4) : [];
+    const expLines = cmdView
+      ? thoughtExpanded
+        ? runningCommandRows(runningCmdFull || runningCmd, {
+            width: Math.max(20, process.stdout.columns || 80) - 1 - GUTTER.length,
+          })
+        : []
+      : thoughtExpanded && rest ? wrapThought(rest, max, 4) : [];
     // WHAT IS RUNNING, under the label (task #177). Capped at two rows and clipped, because
     // this block is redrawn by walking the caret over PHYSICAL rows — a wrapped row here is
     // the #109/#138 failure mode.
@@ -11215,14 +11453,14 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     if (row < top || row > top + statusContentLines - LEAD_ROWS - WORD_GAP - 2) return;
     // Only meaningful when there IS a fuller thought to reveal; otherwise ignore the click
     // so we don't flicker an empty expand.
-    if (!thoughtExpanded && !(fullLiveThought && !runningCmd)) return;
+    if (!thoughtExpanded && !(runningCmd ? runningCmdMore : fullLiveThought)) return;
     toggleThought();
   };
   // Same expand/collapse, reachable without the mouse: Ctrl+T while a turn runs (see
   // toggleActiveThought). Ignored when there's nothing more to reveal, so it never flickers an
   // empty expansion.
   const toggleThought = () => {
-    if (!thoughtExpanded && !(fullLiveThought && !runningCmd)) return;
+    if (!thoughtExpanded && !(runningCmd ? runningCmdMore : fullLiveThought)) return;
     thoughtExpanded = !thoughtExpanded;
     clearStatus(); // next tick (≤120ms) redraws at the new size; keeps cursor math correct
   };
@@ -11258,6 +11496,9 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     clearStatus();
     thinking = false;
     runningCmd = null;
+    runningCmdFull = "";
+    runningCmdLines = 0;
+    runningCmdAt = 0;
     runningTool = null;
     // A concrete action landed → the Thought that led to it is spent; clear it so the
     // next step's blinking line starts from "Thinking", not last step's stale clause.
@@ -11381,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.
@@ -11405,6 +11649,20 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
         lastContentAt = Date.now();
         continue;
       }
+      if (line.startsWith(RUNCMD_PREFIX)) {
+        try {
+          runningCmdFull = String(JSON.parse(line.slice(RUNCMD_PREFIX.length))?.cmd ?? "");
+        } catch {
+          runningCmdFull = ""; // the short "Running → …" line still names it
+        }
+        lastContentAt = Date.now();
+        continue;
+      }
+      if (line.startsWith(RUNOUT_PREFIX)) {
+        runningCmdLines = Number(line.slice(RUNOUT_PREFIX.length).trim()) || 0;
+        lastContentAt = Date.now();
+        continue;
+      }
       if (line.startsWith(RUNTOOL_PREFIX)) {
         const [label, ...rest] = line.slice(RUNTOOL_PREFIX.length).split("\t");
         runningTool = { label: (label || "Working").trim(), detail: rest.join("\t").trim() };
@@ -11422,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;
@@ -11452,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;
       }
@@ -11575,7 +11837,17 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
       // So the pair collapses to: "◑ Running <cmd>…" while it runs, then "● <result>".
       if (!plainReplyFlow) {
         const mRun = /^Running → (.+)$/.exec(line.trim());
-        if (mRun) { runningCmd = mRun[1]; thinking = false; lastContentAt = Date.now(); continue; }
+        if (mRun) {
+          runningCmd = mRun[1];
+          // a NEW command: its own clock and count, and it starts as one row (#331)
+          runningCmdFull = "";
+          runningCmdLines = 0;
+          runningCmdAt = Date.now();
+          thoughtExpanded = false;
+          thinking = false;
+          lastContentAt = Date.now();
+          continue;
+        }
       }
       // Skip the status-clear for a BUFFERED plain reply (STREAM_PLAIN_REPLY=false): nothing
       // prints yet, so the thinking ticker should keep animating until completion.
@@ -11658,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
@@ -11861,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
@@ -12803,6 +13076,8 @@ async function main() {
   // #323: gu's newest published price + cache tables — same cadence, same silent failure.
   void refreshPriceUpdate();
   setInterval(() => void refreshPriceUpdate(), UPDATE_CHECK_MS).unref();
+  void refreshLogsSize();
+  setInterval(() => void refreshLogsSize(), UPDATE_CHECK_MS).unref();
   // The gu token (#232): same arrangement — background, never delays the prompt, unref'd.
   startupTokenRefresh = refreshCliToken();
   setInterval(() => void refreshCliToken(), TOKEN_TICK_MS).unref();
@@ -13263,6 +13538,10 @@ async function main() {
       await runPricesCommand(line);
       continue;
     }
+    if (line === "/clear-logs") {
+      await runClearLogs();
+      continue;
+    }
     if (line === "/tokens") {
       // Task #142: WHERE the last request's prompt went. The bar answers "how much is RAG";
       // this answers "and what displaced it", which is the part that tells you whether RAG is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.787",
+  "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",
@@ -77,6 +77,7 @@
     "poll-errors.mjs",
     "node-version.mjs",
     "clear-state.mjs",
+    "clear-logs.mjs",
     "platform-tools.mjs",
     "job-pools.mjs",
     "agent-stop.mjs",