@tiens.nguyen/gu-cli 1.0.813 → 1.0.814

package/gonext_agent_chat.py

@@ -2628,6 +2628,10 @@ _RAG_STEP: dict = {"n": 0}
 #   "unavailable" — RAG isn't configured at all
 # A metric that cannot tell "it wasn't needed" from "it couldn't have worked" answers nothing.
 _RAG_STATE: dict = {"s": "unknown"}
+# Issue #120: mid-turn auto-compaction, per turn. n = passes that actually saved something,
+# tok = the prompt size (tokens) that triggered the latest one. Rides on the prompt breakdown
+# so the REPL can show a "compacting context" note on the bottom bar.
+_COMPACT_STATE: dict = {"n": 0, "tok": 0}
 # Is this turn's index on LOCAL disk? Module-level because _rag_known_sources() reads it from
 # outside run_agent_chat — and it had no module-level definition at all, so that function raised
 # NameError on EVERY call, in every mode. Found by testing the three storage modes (#180).
@@ -2979,6 +2983,9 @@ def _prompt_breakdown(messages, total_tokens: int, step: int = 0, ledger=None) -
         "grepCalls": int(_SEARCH_TALLY.get("grep") or 0),
         "grepHits": int(_SEARCH_TALLY.get("grep_hits") or 0),
         "readCalls": int(_SEARCH_TALLY.get("read") or 0),
+        # Issue #120: how often this turn auto-compacted, and at what size (tokens).
+        "compacted": int(_COMPACT_STATE.get("n") or 0),
+        "compactedAt": int(_COMPACT_STATE.get("tok") or 0),
     }
 
 
@@ -8319,6 +8326,8 @@ def run_agent_chat(cfg):
     # credit RAG for tokens it never cost, and a wrong number is worse than none.
     _rag_ledger_reset()
     _RAG_STEP["n"] = 0
+    _COMPACT_STATE["n"] = 0
+    _COMPACT_STATE["tok"] = 0
     _overload_notified["yes"] = False
     try:
         from smolagents import CodeAgent, OpenAIServerModel, tool
@@ -10615,8 +10624,11 @@ def run_agent_chat(cfg):
                 # Yes/No before deep-compacting (the auto-trim above is always-on; THIS is
                 # the extra, opt-in aggressive pass). Only in the terminal (interactive) —
                 # web has no picker, so it just keeps the auto-trim.
-                if (_interactive_approval and _job_id and worker_api_base and worker_api_key
-                        and _compact_state["decision"] != "never"):
+                # Issue #120: this used to be gated on an interactive terminal AND read
+                # _compact_state["decision"], a key removed with the old Yes/No prompt — the
+                # KeyError was swallowed below as "memory-trim skip", so mid-turn compaction
+                # NEVER ran and the context grew past the model's window. Always on now.
+                if _steps:
                     # Size of the last request in prompt tokens (exact if the server
                     # reported it, else ~chars/4 of the current step memory).
                     _tu = getattr(step_log, "token_usage", None)
@@ -10652,6 +10664,12 @@ def run_agent_chat(cfg):
                                 f"{_VERBOSE_PREFIX}Context reached ~{_in_tok // 1000}k tokens — trimming older "
                                 "steps to stay fast (files are re-readable)")})
                         if _cs:
+                            _COMPACT_STATE["n"] += 1
+                            _COMPACT_STATE["tok"] = int(_in_tok)
+                            # Issue #120: tell the terminal NOW (not on the next request's
+                            # breakdown) so it can lock input and show the compacting bar.
+                            _emit({"type": "compact", "n": _COMPACT_STATE["n"],
+                                   "tok": _COMPACT_STATE["tok"]})
                             _log(f"context compact: saved ~{_cs} chars "
                                  f"(at ~{_in_tok} tok, threshold {_compact_at}, "
                                  f"window {_ctx_window or 'unknown'})")

package/gu-cli.mjs

@@ -4394,6 +4394,18 @@ async function runAgentChatJob(job) {
             }),
           }).catch(() => {});
         }
+      } else if (event.type === "compact" && Number.isFinite(event.n)) {
+        // Issue #120: a mid-turn compaction just landed — put it on the job straight away so
+        // the REPL locks input and shows its progress bar now, not at the next request.
+        latestPromptBreakdown = {
+          ...(latestPromptBreakdown || {}),
+          compacted: event.n,
+          ...(Number.isFinite(event.tok) ? { compactedAt: event.tok } : {}),
+        };
+        workerFetch(`/api/worker/jobs/${jobId}`, {
+          method: "PATCH",
+          body: JSON.stringify({ agentPromptBreakdown: latestPromptBreakdown }),
+        }).catch(() => {});
       } else if (event.type === "code_request") {
         // Task #155: the row is opened BEFORE the request goes out, so a step that is
         // cancelled, hangs, or is refused still leaves a readable record of exactly what was

package/gu-repl.mjs

@@ -62,6 +62,8 @@ import {
   thoughtBlockRows,
   ragSegmentLabel,
   ragBarNote,
+  compactBarNote,
+  compactProgressNote,
   searchSegmentLabel,
   runningDetailRows,
   formatThinkTime,
@@ -549,6 +551,8 @@ const brightText = (s) => s; // default terminal colour (un-dimmed) — the "pop
 // forward reference here is a startup crash, not a lint warning.
 const BULLET_STYLE = {
   fail: { mark: CROSS, markColor: red, textColor: brightText },
+  // A look-up (grep/pgrep/rg…) that found nothing: not an error — a dim grey ✗, dim text.
+  soft: { mark: CROSS, markColor: dim, textColor: dim },
   ok: { mark: CHECK, markColor: accent, textColor: dim },
   info: { mark: BULLET, markColor: dim, textColor: dim },
 };
@@ -2726,6 +2730,39 @@ const ragLineText = () => {
 // that counts rows with ESC[nA / ESC[nB (the #109 failure mode). Called fresh on every draw,
 // so a resize simply re-lays it out (task #138); the RAG row is verbose-only, which is why the
 // row COUNT is taken from this array rather than hard-coded anywhere.
+// Issue #120: while a mid-turn compaction runs, EVERYTHING is locked — keys are swallowed, the
+// turn's output is held back — and only the progress bar on the bottom bar moves. The trim
+// itself takes milliseconds, so the lock lasts a short fixed window the user can actually see.
+// Ctrl+C (SIGINT) still cancels the turn: a lock must never trap the user.
+const COMPACT_LOCK_MS = 1500;
+let compactLock = null;        // { startedAt, until } while locked
+let compactSeenPasses = 0;     // compaction passes already shown this turn
+let compactLockTimer = null;
+const compactLocked = () => !!compactLock && Date.now() < compactLock.until;
+function startCompactLock() {
+  const now = Date.now();
+  compactLock = { startedAt: now, until: now + COMPACT_LOCK_MS };
+  if (compactLockTimer) clearInterval(compactLockTimer);
+  compactLockTimer = setInterval(() => {
+    if (!compactLocked()) endCompactLock();
+    else if (barPinned()) paintBar();
+  }, 80);
+  if (barPinned()) paintBar();
+}
+function endCompactLock() {
+  if (compactLockTimer) clearInterval(compactLockTimer);
+  compactLockTimer = null;
+  const was = !!compactLock;
+  compactLock = null;
+  if (was && barPinned()) paintBar();
+}
+const compactLockNote = () =>
+  compactLock
+    ? compactProgressNote({
+        frac: (Date.now() - compactLock.startedAt) / COMPACT_LOCK_MS,
+        at: lastPromptBreakdown?.compactedAt,
+      })
+    : "";
 const footerRows = () =>
   buildFooterRows({
     width: process.stdout.columns || 80,
@@ -2736,7 +2773,8 @@ const footerRows = () =>
     mode: modeLineText(),
     // Task #34: "rag: embedder down → grep fallback" as a soft yellow note beside the mode, not an
     // alarming red segment on the token row. yellow goes through paint(), so NO_COLOR turns it off.
-    modeNote: ragBarNote(lastPromptBreakdown),
+    // Issue #120: an auto-compaction this turn outranks the rag note (same soft yellow slot).
+    modeNote: compactLockNote() || compactBarNote(lastPromptBreakdown) || ragBarNote(lastPromptBreakdown),
     notePaint: yellow,
     // How to paste here (issue #67): the platform's text key, plus gu's image key when the coder
     // can take an image.
@@ -4358,6 +4396,13 @@ if (process.stdin.isTTY) {
     // re-rendered the slash overlay (the line still starts with "/" from before the paste) and
     // re-walked the paste store. Same for a mouse report's characters, which are not keys.
     if (pasteBuffer !== null || inMouseKeyWindow()) return;
+    // Issue #120: compacting → every key is locked (Ctrl+C still arrives as SIGINT).
+    if (compactLocked()) {
+      rl.line = "";
+      rl.cursor = 0;
+      rl.historyIndex = -1;
+      return;
+    }
     // #247: the restored question was erased (Backspace, Ctrl+U, a picker taking the line) — it
     // is let go, exactly as with Ctrl+C, so the next message does not REPLACE it in history.
     if (prefillFor && (listPickerActive || restoredQuestionLetGo(rl.line, key))) prefillFor = null;
@@ -11299,6 +11344,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   following = true;
   followingAttached = attached;
   typedDuringTurn = false;
+  compactSeenPasses = 0; // issue #120: python counts passes per turn
   followAborted = false;
   currentJobId = jobId;
   jobIdForApprovalRace = jobId; // so an approval picker can watch THIS job for early end (#110)
@@ -12369,6 +12415,12 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
       if (job.agentPromptBreakdown && typeof job.agentPromptBreakdown === "object") {
         lastPromptBreakdown = job.agentPromptBreakdown;
         liveStepTokens = readStepTokens(job.agentPromptBreakdown);
+        // Issue #120: a NEW compaction pass this turn → lock everything and show the bar.
+        const compactPasses = Number.isFinite(job.agentPromptBreakdown.compacted) ? job.agentPromptBreakdown.compacted : 0;
+        if (compactPasses > compactSeenPasses) {
+          compactSeenPasses = compactPasses;
+          startCompactLock();
+        }
         // Persisted per folder so the next `gu` here starts from the real picture instead
         // of a zero that looks like a failure. Fire-and-forget: a bar value is never worth
         // delaying a turn for, and losing one is harmless. Shown while attached (it is what
@@ -12385,6 +12437,9 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
       // Mirror both into the bottom bar's token row so it counts UP live while the turn runs
       // (the bar rides under the status block now), instead of sitting on the last turn's
       // figures until this one finishes. The turn-end assignment writes the same numbers again.
+      // Issue #120: hold the turn's output while compacting — only the bar moves. Ctrl+C ends it.
+      while (compactLocked() && !cancelRequested && !followAborted) await sleep(80);
+      if (compactLock && (cancelRequested || followAborted)) endCompactLock();
       lastTurnInputTokens = latestCodeTokens;
       lastTurnOutputTokens = latestOutputTokens;
       lastTurnTotalOutput = globalOutputTokens + latestOutputTokens;
@@ -12621,6 +12676,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     following = false;
     followingAttached = false;
     typedDuringTurn = false;
+    endCompactLock(); // issue #120: never leave the terminal locked after a turn
     currentJobId = null;
     // Drop anything typed (but not submitted) during the turn — echo was muted, so it's
     // invisible; without this it would surface on the next prompt.

package/package.json

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

@@ -198,6 +198,34 @@ export function ragBarNote(b) {
   return ragSegmentLabel(b) || "";
 }
 
+/**
+ * Issue #120: the bottom bar's note while a turn has AUTO-COMPACTED its context, or "".
+ *
+ * python trims older steps mid-turn once the prompt reaches ~2/3 of the model's window and
+ * reports it on the prompt breakdown (compacted = passes this turn, compactedAt = tokens at
+ * the latest one). A stale breakdown reloaded from disk is not this turn, so it gets no note.
+ */
+export function compactBarNote(b) {
+  if (!b || typeof b !== "object" || b.stale) return "";
+  const n = Number.isFinite(b.compacted) ? b.compacted : 0;
+  if (n <= 0) return "";
+  const at = Number.isFinite(b.compactedAt) && b.compactedAt > 0
+    ? ` at ~${Math.round(b.compactedAt / 1000)}k` : "";
+  return `⟳ compacting context${at} — older steps trimmed${n > 1 ? ` (${n}×)` : ""}`;
+}
+
+/**
+ * Issue #120: the bottom bar's ANIMATED note while a compaction holds the terminal locked.
+ * `frac` 0..1 is how far through the lock window we are; `at` the prompt tokens at the trim.
+ */
+export function compactProgressNote({ frac = 0, at = 0, cells = 12 } = {}) {
+  const f = Math.max(0, Math.min(1, Number.isFinite(frac) ? frac : 0));
+  const full = Math.round(f * cells);
+  const bar = "█".repeat(full) + "░".repeat(cells - full);
+  const k = Number.isFinite(at) && at > 0 ? ` at ~${Math.round(at / 1000)}k` : "";
+  return `⟳ compacting context${k} ▕${bar}▏ ${Math.round(f * 100)}% — input locked`;
+}
+
 /** Cut plain text to `room` visible columns, ending with "…" when it was cut. */
 function fitPlain(s, room) {
   s = String(s ?? "");
@@ -1114,7 +1142,28 @@ export function trimWords(text, limit) {
   return toks.join(" ").trimEnd() + "…";
 }
 
+// A LOOK-UP command (grep, rg, pgrep, which, lsof…) exits non-zero when it simply finds
+// nothing. That is an answer ("not there"), not a fault — so a "Command failed → pgrep -f x"
+// must not pop as a red ✗ (#41's "the one thing you must not miss"). It is "soft": a dim
+// grey ✗ with dim text. Judged by the LAST segment of a chain/pipeline (its exit status is
+// the one reported): `ps aux | grep foo` and `cd src && rg Foo` are both look-ups.
+const SEARCH_CMDS = new Set([
+  "grep", "egrep", "fgrep", "zgrep", "rg", "ag", "ack", "pgrep", "which", "whereis", "lsof",
+]);
+export function isSoftFailCommand(cmd) {
+  const segs = String(cmd ?? "").split(/&&|\|\||[|;]/).map((s) => s.trim()).filter(Boolean);
+  if (!segs.length) return false;
+  const toks = segs[segs.length - 1].split(/\s+/);
+  let i = 0;
+  while (i < toks.length && (/^[A-Za-z_][A-Za-z0-9_]*=/.test(toks[i]) || ["env", "command", "time", "nice"].includes(toks[i]))) i++;
+  const prog = (toks[i] || "").split("/").pop();
+  if (SEARCH_CMDS.has(prog)) return true;
+  return prog === "git" && toks[i + 1] === "grep";
+}
+
 export function bulletKind(text) {
+  const mFail = /^Command failed → (.+)$/.exec(String(text ?? "").trim());
+  if (mFail && isSoftFailCommand(mFail[1])) return "soft";
   if (/\bfail(ed|s|ure)?\b|\berror(ed)?\b|→\s*(?:HTTP\s*)?[45]\d\d\b/i.test(text)) return "fail";
   if (/^(?:Command finished|Server up|App launched)\b|→\s*(?:HTTP\s*)?2\d\d\b|\b(?:passed|succeeded|ready)\b/i.test(text))
     return "ok";