@tiens.nguyen/gu-cli 1.0.812 → 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),
     }
 
 
@@ -4769,6 +4776,42 @@ def _collapse_inner_openers(text):
     return text[:body_from] + cleaned + "\n</code>"
 
 
+# DeepSeek DSML tool-call markup (issue #119). Some DeepSeek-family models (seen via
+# token-plan.maas.qwencloudapi.com) answer with their NATIVE tool-call text instead of our code
+# block: prose, then a DSML "calls" tag, a DSML invoke tag with name="code", then plain Python,
+# then closers that are often wrong (a DSML "parameter" close) or missing. The bars in the tags
+# are FULLWIDTH, so the patterns tolerate any short run of non-bracket characters around DSML.
+_DSML_INVOKE_CODE = re.compile(
+    r"<[^<>\n]{0,8}DSML[^<>\n]{0,8}invoke\s+name\s*=\s*[\x22\x27]code[\x22\x27]\s*>[ \t]*\r?\n?"
+)
+_DSML_ANY = re.compile(r"<[^<>\n]{0,8}DSML")
+_DSML_CLOSER = re.compile(r"\n?[ \t]*</[^<>\n]{0,8}DSML")
+
+
+def _dsml_to_code_block(text):
+    """Rewrite a DSML invoke name="code" body into a normal code block, or return the text
+    unchanged. Fires only when there is NO code tag already and the body COMPILES (the same
+    conservative contract as the other readings)."""
+    if not text or "DSML" not in text or re.search(r"<\s*/?\s*code\b", text, re.I):
+        return text
+    m = _DSML_INVOKE_CODE.search(text)
+    if not m:
+        return text
+    rest = text[m.end():]
+    c = _DSML_CLOSER.search(rest)
+    body = (rest[:c.start()] if c else rest).strip("\n")
+    if not body.strip():
+        return text
+    try:
+        compile(body, "<gu-code>", "exec")
+    except Exception:  # noqa: BLE001
+        return text
+    head = text[:m.start()]
+    first = _DSML_ANY.search(head)
+    prose = (head[:first.start()] if first else head).rstrip()
+    return (prose + "\n" if prose else "") + "<code>\n" + body + "\n</code>"
+
+
 def _code_block_readings(text):
     """Every plausible reading of where the code block is, CHEAPEST FIRST.
 
@@ -4829,6 +4872,10 @@ def _canonicalise_code_reply(text):
     # reproduced, inside the fix, the very shape of the bug being fixed: a strict cheap check
     # guarding a tolerant repair. If a pre-check cannot be as permissive as what it guards, it
     # does not belong in front of it.
+    _dsml = _dsml_to_code_block(text)
+    if _dsml != text:
+        _log("DSML tool-call markup converted to a code block (#119)")
+        return _dsml
     if not text or not _CODE_ANY_TAGGISH.search(text):
         return text
     fallback = None
@@ -8279,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
@@ -10575,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)
@@ -10612,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'})")
@@ -11825,7 +11883,8 @@ def run_agent_chat(cfg):
                         if _still_bad:
                             self._parse_fail_streak += 1
                             _log("tool-call code still unparseable after repair "
-                                 f"(streak {self._parse_fail_streak}/3)")
+                                 f"(streak {self._parse_fail_streak}/3) model={getattr(self, 'model_id', '?')} "
+                                 f"reply[:300]={(msg.content or '')[:300]!r}")
                             if self._parse_fail_streak >= 3:
                                 _log("parse-fail streak hit limit → ending the turn honestly "
                                      "instead of looping on an unparseable tool call")

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

@@ -61,6 +61,9 @@ import {
   thoughtFull,
   thoughtBlockRows,
   ragSegmentLabel,
+  ragBarNote,
+  compactBarNote,
+  compactProgressNote,
   searchSegmentLabel,
   runningDetailRows,
   formatThinkTime,
@@ -548,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 },
 };
@@ -2276,9 +2281,13 @@ const ragSegmentText = () => {
   // RAG FAILED MID-TURN and searches were answered by the grep fallback: a WARNING (yellow),
   // always visible — the turn still got results, but not semantic ones.
   const liveFallback = b.ragState === "fallback" && !b.stale;
-  if (!REPL_VERBOSE && !liveDown && !liveFallback) return lexSeg;
+  // Task #34: a LIVE grep fallback (embedder down, or RAG failed mid-turn) is no longer on this
+  // row. In red with a "✗" it read as a serious fault while search kept working. It is now a soft
+  // yellow note on the bottom bar's mode row (ragBarNote → footerRows' modeNote).
+  if (liveDown || liveFallback) return lexSeg;
+  if (!REPL_VERBOSE) return lexSeg;
   if (b.stale) return dim(" · ") + dim(`${label}·`) + lexSeg;
-  return dim(" · ") + (liveDown ? red(label) : liveFallback ? yellow(label) : dim(label)) + lexSeg;
+  return dim(" · ") + dim(label) + lexSeg;
 };
 /**
  * IS ANYTHING NEWER? (task #181) — cached, never probed from a repaint.
@@ -2721,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,
@@ -2729,6 +2771,11 @@ const footerRows = () =>
     identity: identityLineText(),
     token: tokenLineText(),
     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.
+    // 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.
     modeHint: pasteHint({ images: coderTakesImages() }),
@@ -3540,6 +3587,7 @@ function printThoughtBlock(raw, before, { gap = false } = {}) {
       collapsed: true,
       lines: THOUGHT_COLLAPSED_LINES,
     });
+    const rowsBeforeMerge = screenRows().length;
     const newEnd = transcript.replaceRange(prev.from, prev.to, grown.map((r) => GUTTER + dim(r)));
     if (newEnd !== null) {
       prev.prose = merged;
@@ -3548,7 +3596,7 @@ function printThoughtBlock(raw, before, { gap = false } = {}) {
       // move under the pointer, so the cached hover row must be dropped — same reason
       // toggleThoughtBlock does it after a resize of the block.
       hoverCtl.reset();
-      paintLiveTail();
+      repaintTailOrHoldView(rowsBeforeMerge); // #113/#35: a finished thought never pulls a reader down
       return true;
     }
     // Scrolled out of the buffer — fall through and print a new block rather than lose it.
@@ -3855,6 +3903,21 @@ function toggleNewestThought() {
   return toggleThoughtBlock(block);
 }
 
+/**
+ * #113 / #35 — A BLOCK AT THE TAIL CHANGED SIZE (a thought merged, a step group grew). At the
+ * live tail that is a paintLiveTail. Scrolled back, it is NOT: paintLiveTail sets scrollOffset
+ * to 0, which is exactly the "it finished thinking and threw me back to the bottom" report. The
+ * change happened below (or at the edge of) what the reader is looking at, so keep the same
+ * lines on screen — the offset moves by the rows added — and let the jump notice count up.
+ */
+function repaintTailOrHoldView(rowsBefore) {
+  if (barPinned() && scrolledBack()) {
+    scrollOffset = Math.max(1, scrollOffset + (screenRows().length - rowsBefore));
+    renderScrollback(); // same slice as before; ends in paintBar (the "N lines below" count)
+    return;
+  }
+  paintLiveTail();
+}
 /** Back to the live tail: repaint it from the transcript and hand the screen back. */
 function jumpToBottom() {
   if (!barPinned() || !scrollOffset) return; // already live — nothing to come back from
@@ -4333,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;
@@ -11274,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)
@@ -11876,13 +11947,16 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     if (stepGroupStillOpen()) {
       stepGroup.items.push(text);
       const painted = paintThoughtRows(stepGroup, hoverCtl.hovered === stepGroup);
+      const rowsBeforeStep = screenRows().length;
       const newEnd = transcript.replaceRange(stepGroup.from, stepGroup.to, painted);
       if (newEnd !== null) {
         const delta = newEnd - stepGroup.to;
         stepGroup.to = newEnd;
         if (delta === 0) {
           // Collapsed: one row before, one row after — rewrite that row and nothing else.
-          ui(thoughtBlockRepaintSeq(stepGroup));
+          // Scrolled back (#113/#35): those rows are live-tail coordinates, NOT the history the
+          // reader is looking at — painting them would draw over it. The transcript has it.
+          if (!scrolledBack()) ui(thoughtBlockRepaintSeq(stepGroup));
           paintBar();
         } else {
           // Open (the user clicked it mid-turn): it grew, and what is under it moved down.
@@ -11893,7 +11967,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
             }
           }
           hoverCtl.reset();
-          paintLiveTail();
+          repaintTailOrHoldView(rowsBeforeStep); // #113/#35: never pull a reader down
         }
         return;
       }
@@ -12341,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
@@ -12357,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;
@@ -12593,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.812",
+  "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",
@@ -40,6 +40,7 @@
     "test:cache-e2e": "GONEXT_OLLAMA1_LIVE=1 node --test --test-timeout=1800000 tests/prefix-cache-e2e.test.mjs",
     "test:tokens": "python3 -m unittest discover tests -p \"test_cached_tokens.py\" -v && node --test tests/prefix-cache.test.mjs tests/agent-turn-shape.test.mjs",
     "test:selection": "node --test tests/selection-scrollback.test.mjs tests/selection-while-thinking.test.mjs tests/terminal-selection.test.mjs tests/terminal-copy.test.mjs tests/terminal-viewport.test.mjs tests/hover-repaint.test.mjs",
+    "test:autoscroll": "node --test tests/no-autoscroll-hide-total.test.mjs tests/thought-spacing.test.mjs tests/terminal-viewport.test.mjs tests/selection-scrollback.test.mjs",
     "test:steps": "python3 scripts/py-tap.py tests/test_read_caps.py tests/test_trim_payback.py tests/test_explore.py tests/test_and_chains.py tests/test_edit_file_primary.py tests/test_bare_code_rescue.py tests/test_batching_rule.py tests/test_no_pdf_routing.py",
     "check:image": "node scripts/image-paste-check.mjs",
     "check:image-clipboard": "node scripts/image-paste-check.mjs --clipboard",

package/terminal-layout.mjs

@@ -146,8 +146,9 @@ export function ragSegmentLabel(b) {
   const rag = Number.isFinite(b.rag) ? b.rag : 0;
   if (rag > 0) return null; // …the caller renders the number + percent instead
   switch (b.ragState) {
+    // Task #34: no "✗" — search still works through grep, so this is a notice, not an error.
     case "unreachable":
-      return "rag ✗ embedder down → grep fallback";
+      return "rag: embedder down → grep fallback";
     case "no-index":
       return "rag — not indexed";
     case "unavailable":
@@ -167,7 +168,7 @@ export function ragSegmentLabel(b) {
     // RAG FAILED MID-TURN (indexing or query embedding) and the search was answered by the
     // keyword fallback instead. A warning, not an error: the turn still got results.
     case "fallback":
-      return "rag ⚠ unavailable → grep fallback";
+      return "rag: unavailable → grep fallback";
     // Nothing has been measured yet (the state before any turn has run). "0" is a claim we
     // cannot support; a dash says "no figure", which is the truth.
     case "unknown":
@@ -182,6 +183,62 @@ export function ragSegmentLabel(b) {
   }
 }
 
+/**
+ * The RAG notice for the BOTTOM BAR's mode row (task #34), or "" when there is none.
+ *
+ * Only THIS session's live verdict that search fell back to grep: "unreachable" (the embedder is
+ * down) or "fallback" (RAG failed mid-turn). It used to sit in red with a "✗" in the middle of the
+ * token row and read as a serious fault, while every search was still answered by grep. It is
+ * now a soft note beside "accept edits on". A stale verdict reloaded from a saved session is
+ * not a live fault, so it gets no notice.
+ */
+export function ragBarNote(b) {
+  if (!b || typeof b !== "object" || b.stale) return "";
+  if (b.ragState !== "unreachable" && b.ragState !== "fallback") return "";
+  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 ?? "");
+  if (visibleLen(s) <= room) return s;
+  if (room <= 1) return room === 1 ? "…" : "";
+  let out = "";
+  for (const ch of s) {
+    if (visibleLen(out + ch) > room - 1) break;
+    out += ch;
+  }
+  return out + "…";
+}
+
 // The six origin buckets. They are scaled to sum to the server's prompt_tokens for ONE
 // request, so their sum IS the size of the newest context — the number to compare against
 // the model's window. Deliberately excludes ragFresh/ragCarried (shares OF rag, not extra)
@@ -544,11 +601,25 @@ export function buildFooterRows({
   // Right-aligned on the mode row (issue #67), dim. DROPPED WHOLE when it does not fit: every
   // footer row must stay one physical row (#109/#132/#138), and half a key name is worse than none.
   modeHint = "",
+  // Task #34: a soft notice (PLAIN text) after the mode text, painted with notePaint. It takes
+  // priority over the paste hint and is cut with "…" on a narrow window, never wrapped.
+  modeNote = "",
+  notePaint = dim,
   notice = "",
   missing = "",
 }) {
   const w = Math.max(20, width || 80);
-  const modeLeft = gutter + mode;
+  let modeLeft = gutter + mode;
+  if (modeNote) {
+    const NOTE_GAP = "  ";
+    const hintRoom = modeHint ? HINT_MIN_GAP + visibleLen(modeHint) : 0;
+    let room = w - 1 - visibleLen(modeLeft) - NOTE_GAP.length;
+    // Keep the paste hint only when the whole notice still fits beside it.
+    if (modeHint && visibleLen(modeNote) <= room - hintRoom) room -= hintRoom;
+    else modeHint = "";
+    // Too little room to say anything readable: leave the notice out.
+    if (room >= 8) modeLeft += NOTE_GAP + notePaint(fitPlain(modeNote, room));
+  }
   const hintGap = modeHint ? w - 1 - visibleLen(modeLeft) - visibleLen(modeHint) : -1;
   const modeRow =
     hintGap >= HINT_MIN_GAP
@@ -1071,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";