@tiens.nguyen/gu-cli 1.0.787 → 1.0.788

package/clear-logs.mjs

@@ -0,0 +1,352 @@
+/**
+ * "clear logs" (#329) — what is taking the disk under ~/.gonext, and a way to give it back.
+ *
+ * Asked for after this Mac's disk filled three times in one day and took the local MongoDB down
+ * with it (#328). A click on the notice row's "clear logs" (or /clear-logs) DELETES NOTHING at
+ * first: it measures, shows the logs beside the two things that are actually big — the RAG indexes
+ * and the downloaded API versions — with a total, and then asks about each of the three.
+ *
+ * THREE DIFFERENT KINDS OF "CLEAR", because losing each costs something different:
+ *
+ *   logs  nothing. But the worker and the local API hold their log OPEN: a deleted open file frees
+ *         no space on macOS/Linux until the holder closes it (and the holder keeps writing into
+ *         the unlinked file), and on Windows the delete fails outright. So the live "<name>.log"
+ *         is TRUNCATED IN PLACE and only rotations and finished run-logs are deleted — the same
+ *         rule rotateIfLarge (log-policy.mjs) already lives by.
+ *   rag   minutes of embedding per folder: an index is rebuilt the next time its folder is used.
+ *   api   nothing, PROVIDED the version in use stays. One folder per installed version, none ever
+ *         removed; deleting the running one would break every open terminal's turn. So "clear
+ *         api" only ever means the OLDER versions.
+ *
+ * SELECTED BY AN EXPLICIT LIST, never by a "*.log*" / "*.jsonl" sweep of the home: sessions/archive
+ * is conversation history (#278) and rag/ shards are also .jsonl. Anything not named here is not
+ * touched, whatever the answers.
+ *
+ * Everything takes `home` so the tests run against a real temp folder, not this machine's.
+ */
+import { readdir, readFile, rm, rmdir, stat, truncate, unlink } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pickUsableVersion, compareVersions } from "./version-check.mjs";
+
+/** The logs gu writes at the top of its home. `<name>` is live; `<name>.N` are its rotations. */
+export const LIVE_LOGS = ["worker.log", "local-api.log", "model.log", "embed.log"];
+/** Folders that hold nothing but finished log files. */
+export const LOG_DIRS = ["run-logs", "logs"];
+/** The link appears once the logs pass this — below it the row stays quiet. */
+export const LOGS_NOTICE_BYTES = 50 * 1024 * 1024;
+
+const guHome = (home = homedir()) => join(home, ".gonext");
+
+/** "740 KB", "15 MB", "4.9 GB" — two significant figures, the way `du -h` reads. */
+export function humanSize(bytes) {
+  const n = Math.max(0, Number(bytes) || 0);
+  const units = [["GB", 1024 ** 3], ["MB", 1024 ** 2], ["KB", 1024]];
+  for (const [unit, size] of units) {
+    if (n < size) continue;
+    const v = n / size;
+    // 9.96 would print as "10.0" with one decimal — let it round up to the integer form instead.
+    return `${v < 9.95 ? v.toFixed(1) : Math.round(v)} ${unit}`;
+  }
+  return `${Math.round(n)} B`;
+}
+
+const plural = (n, one, many = one + "s") => `${n} ${n === 1 ? one : many}`;
+
+/**
+ * What a file takes ON DISK — its blocks, which is what clearing gives back and what `du` reports.
+ * The byte length undercounts thousands of small files (an API version read as 85 MB here against
+ * du's 120 MB). Windows reports no blocks; the length is the best there is.
+ */
+const onDisk = (s) => (s.blocks > 0 ? s.blocks * 512 : s.size);
+
+async function fileSize(p) {
+  try {
+    const s = await stat(p);
+    return s.isFile() ? onDisk(s) : -1;
+  } catch {
+    return -1;
+  }
+}
+
+/** Bytes under a folder. Children are walked together: an API version is thousands of files. */
+async function dirSize(p) {
+  let entries;
+  try {
+    entries = await readdir(p, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+  const sizes = await Promise.all(
+    entries.map(async (e) => {
+      const full = join(p, e.name);
+      if (e.isDirectory()) return dirSize(full);
+      if (e.isSymbolicLink()) return 0; // never followed: a link out of the home is not ours to count
+      try {
+        return onDisk(await stat(full));
+      } catch {
+        return 0;
+      }
+    })
+  );
+  return sizes.reduce((a, b) => a + b, 0);
+}
+
+/**
+ * The logs: each live file and its rotations by name, each log folder as a count.
+ * → { items: [{ name, bytes, kind: "live" | "rotation" | "dir", files?, paths? }], bytes, files }
+ */
+export async function surveyLogs({ home = homedir() } = {}) {
+  const root = guHome(home);
+  let names = [];
+  try {
+    names = await readdir(root);
+  } catch {
+    /* no home yet — nothing to report */
+  }
+  const items = [];
+  for (const live of LIVE_LOGS) {
+    const bytes = await fileSize(join(root, live));
+    if (bytes >= 0) items.push({ name: live, bytes, kind: "live", path: join(root, live) });
+    const rotations = names
+      .filter((n) => n.startsWith(live + ".") && /^\d+$/.test(n.slice(live.length + 1)))
+      .sort((a, b) => Number(a.slice(live.length + 1)) - Number(b.slice(live.length + 1)));
+    for (const r of rotations) {
+      const b = await fileSize(join(root, r));
+      if (b >= 0) items.push({ name: r, bytes: b, kind: "rotation", path: join(root, r) });
+    }
+  }
+  for (const dir of LOG_DIRS) {
+    let files = [];
+    try {
+      files = (await readdir(join(root, dir), { withFileTypes: true })).filter(
+        (e) => e.isFile() && /\.log(\.\d+)?$/.test(e.name)
+      );
+    } catch {
+      continue;
+    }
+    const paths = files.map((e) => join(root, dir, e.name));
+    let bytes = 0;
+    for (const p of paths) bytes += Math.max(0, await fileSize(p));
+    if (paths.length) items.push({ name: dir, bytes, kind: "dir", files: paths.length, paths });
+  }
+  return {
+    items,
+    bytes: items.reduce((n, i) => n + i.bytes, 0),
+    files: items.reduce((n, i) => n + (i.kind === "dir" ? i.files : 1), 0),
+  };
+}
+
+/**
+ * Every local index: ~/.gonext/rag/<folder hash>/<source hash>/. The hashes say nothing to a
+ * person, so the name comes from the manifest the agent wrote (`sourceUrl`). `missing` = that
+ * source was a folder on this machine and is gone — the index can never be used again.
+ */
+export async function surveyRag({ home = homedir() } = {}) {
+  const root = join(guHome(home), "rag");
+  const indexes = [];
+  let folders = [];
+  try {
+    folders = (await readdir(root, { withFileTypes: true })).filter((e) => e.isDirectory());
+  } catch {
+    return { indexes, bytes: 0 };
+  }
+  for (const f of folders) {
+    let sources = [];
+    try {
+      sources = (await readdir(join(root, f.name), { withFileTypes: true })).filter((e) => e.isDirectory());
+    } catch {
+      continue;
+    }
+    for (const s of sources) {
+      const dir = join(root, f.name, s.name);
+      let source = "";
+      try {
+        source = String(JSON.parse(await readFile(join(dir, "manifest.json"), "utf8"))?.sourceUrl ?? "");
+      } catch {
+        /* no manifest — an interrupted index; still counted, still clearable */
+      }
+      const isPath = source.startsWith("/") || /^[A-Za-z]:[\\/]/.test(source);
+      indexes.push({
+        dir,
+        parent: join(root, f.name),
+        source,
+        label: source ? source.replace(/[\\/]+$/, "").split(/[\\/]/).pop() || source : `${s.name.slice(0, 8)}…`,
+        missing: isPath && !existsSync(source),
+        bytes: await dirSize(dir),
+      });
+    }
+  }
+  indexes.sort((a, b) => b.bytes - a.bytes);
+  return { indexes, bytes: indexes.reduce((n, i) => n + i.bytes, 0) };
+}
+
+/**
+ * The installed API versions, and which must stay.
+ *
+ * KEPT: the version answering on the port right now (`runningVersion`, from /api/health), the one
+ * `gu-cli api start` would pick (newest that has its dependencies — #181), and the newest folder
+ * even when it is not runnable yet (an upgrade in progress). Everything else is "old".
+ */
+export async function surveyApi({ home = homedir(), runningVersion = "" } = {}) {
+  const root = join(guHome(home), "api");
+  let names = [];
+  try {
+    names = (await readdir(root, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return { versions: [], bytes: 0, oldBytes: 0, old: [], inUse: "" };
+  }
+  names.sort((a, b) => compareVersions(a, b));
+  const usable = pickUsableVersion(names, (v) => existsSync(join(root, v, "node_modules", "mongodb", "package.json")));
+  const running = names.includes(runningVersion) ? runningVersion : "";
+  const keep = new Set([running, usable, names[names.length - 1]].filter(Boolean));
+  const sizes = await Promise.all(names.map((v) => dirSize(join(root, v))));
+  const versions = names.map((version, i) => ({ version, dir: join(root, version), bytes: sizes[i], keep: keep.has(version) }));
+  const old = versions.filter((v) => !v.keep);
+  return {
+    versions,
+    old,
+    bytes: versions.reduce((n, v) => n + v.bytes, 0),
+    oldBytes: old.reduce((n, v) => n + v.bytes, 0),
+    inUse: running || usable || "",
+  };
+}
+
+/** All three, measured together. */
+export async function surveyDisk({ home = homedir(), runningVersion = "" } = {}) {
+  const [logs, rag, api] = await Promise.all([surveyLogs({ home }), surveyRag({ home }), surveyApi({ home, runningVersion })]);
+  return { logs, rag, api, total: logs.bytes + rag.bytes + api.bytes };
+}
+
+/** Lay `parts` out after `lead`, breaking only between parts; later rows start at `indent`. */
+function wrapParts(lead, parts, width, { sep = " · ", indent = lead.length } = {}) {
+  const pad = " ".repeat(indent);
+  const rows = [];
+  let cur = lead;
+  let empty = true;
+  for (const part of parts) {
+    if (!empty && cur.length + sep.length + part.length > width) {
+      rows.push(cur);
+      cur = pad + part;
+    } else {
+      cur += (empty ? "" : sep) + part;
+    }
+    empty = false;
+  }
+  rows.push(cur.trimEnd());
+  // a single part longer than the row is cut, never wrapped — a wrapped row moves everything under it
+  return rows.map((r) => (r.length > width ? r.slice(0, Math.max(1, width - 1)) + "…" : r));
+}
+
+/**
+ * What the click shows before it asks anything: the logs with their files, RAG and API with what
+ * they are, and the total. Plain text rows that fit `width` — the caller paints and indents them.
+ * A part that is not on this machine (no api/ outside Local mode) has no row.
+ */
+export function summaryRows(survey, { width = 76, top = 3 } = {}) {
+  const w = Math.max(30, width | 0);
+  const { logs, rag, api } = survey;
+  const parts = [
+    { name: "Logs", bytes: logs.bytes, detail: logs.items.map((i) => i.kind === "dir"
+      ? `${i.name} ${plural(i.files, "file")} ${humanSize(i.bytes)}`
+      : `${i.name} ${humanSize(i.bytes)}`), none: "none" },
+  ];
+  if (rag.indexes.length) {
+    const shown = rag.indexes.slice(0, top);
+    const rest = rag.indexes.slice(top);
+    const detail = shown.map((i) => `${i.label} ${humanSize(i.bytes)}`);
+    if (rest.length) detail.push(`${rest.length} more ${humanSize(rest.reduce((n, i) => n + i.bytes, 0))}`);
+    parts.push({ name: "RAG", bytes: rag.bytes, intro: plural(rag.indexes.length, "folder index", "folder indexes") + ":", detail });
+  }
+  if (api.versions.length) {
+    const detail = [plural(api.versions.length, "version")];
+    if (api.inUse) detail.push(`${api.inUse} in use`);
+    if (api.old.length) detail.push(`${plural(api.old.length, "older one")} ${humanSize(api.oldBytes)}`);
+    parts.push({ name: "API", bytes: api.bytes, detail });
+  }
+  const nameW = Math.max(5, ...parts.map((p) => p.name.length));
+  const sizeW = Math.max(humanSize(survey.total).length, ...parts.map((p) => humanSize(p.bytes).length));
+  const lead = (name, bytes) => `${name.padEnd(nameW)}  ${humanSize(bytes).padStart(sizeW)}  `;
+  const rows = [];
+  for (const p of parts) {
+    const head = lead(p.name, p.bytes);
+    // "22 folder indexes:" introduces the list — the list wraps under the first index, the
+    // other parts under their own first word
+    rows.push(...wrapParts(head + (p.intro ? p.intro + " " : ""), p.detail.length ? p.detail : [p.none ?? ""], w, { indent: head.length }));
+  }
+  rows.push(lead("Total", survey.total).trimEnd());
+  return rows;
+}
+
+/**
+ * Clear the logs `surveyLogs` found: truncate the live ones, delete rotations and log folders'
+ * files. → { freed, truncated, deleted, failed: [name] } — `freed` is what really went, so a file
+ * Windows refused to let go of is reported, not counted.
+ */
+export async function clearLogs(logs) {
+  const out = { freed: 0, truncated: 0, deleted: 0, failed: [] };
+  for (const item of logs?.items ?? []) {
+    if (item.kind === "live") {
+      try {
+        const before = Math.max(0, await fileSize(item.path));
+        await truncate(item.path, 0);
+        out.freed += before;
+        out.truncated += 1;
+      } catch {
+        out.failed.push(item.name);
+      }
+      continue;
+    }
+    for (const p of item.kind === "dir" ? item.paths : [item.path]) {
+      try {
+        const before = Math.max(0, await fileSize(p));
+        await unlink(p);
+        out.freed += before;
+        out.deleted += 1;
+      } catch (e) {
+        if (e?.code === "ENOENT") continue; // pruned meanwhile — gone is what was wanted
+        if (!out.failed.includes(item.name)) out.failed.push(item.name);
+      }
+    }
+  }
+  return out;
+}
+
+/** Remove the given indexes (surveyRag's rows). An emptied folder-hash directory goes with them. */
+export async function clearRagIndexes(indexes) {
+  const out = { freed: 0, removed: 0, failed: [] };
+  for (const idx of indexes ?? []) {
+    try {
+      await rm(idx.dir, { recursive: true, force: true });
+      out.freed += idx.bytes;
+      out.removed += 1;
+      await rmdir(idx.parent).catch(() => {}); // only succeeds when nothing else lives there
+    } catch {
+      out.failed.push(idx.label);
+    }
+  }
+  return out;
+}
+
+/** Remove the OLD API versions (surveyApi's `old`). A row marked keep is refused, whoever asks. */
+export async function clearOldApiVersions(versions) {
+  const out = { freed: 0, removed: 0, failed: [] };
+  for (const v of versions ?? []) {
+    if (v.keep) continue;
+    try {
+      await rm(v.dir, { recursive: true, force: true });
+      out.freed += v.bytes;
+      out.removed += 1;
+    } catch {
+      out.failed.push(v.version);
+    }
+  }
+  return out;
+}
+
+/** The notice-row item's text, or "" while the logs are too small to be worth a row. */
+export function clearLogsNoticeText(logBytes, { threshold = LOGS_NOTICE_BYTES } = {}) {
+  const n = Number(logBytes) || 0;
+  return n >= threshold ? `clear logs · ${humanSize(n)} (click)` : "";
+}

package/gonext_agent_chat.py

@@ -5183,6 +5183,90 @@ def _same_embed_model(a: str, b: str) -> bool:
 _RUNTOOL_PREFIX = "__RUNTOOL__::"
 
 
+# ---- the command that is running, WHOLE (task #331) ------------------------------------------
+# "Running → <cmd>" carries the first 70 characters, which is right for a history line and wrong
+# for the one moment someone is watching: a heredoc or a long pipeline was cut at the source, so
+# the terminal could not show the rest whatever its layout. Sent beside that line (which stays,
+# for the web app and for older terminals) as ONE line of JSON — a command can span lines.
+_RUNCMD_PREFIX = "__RUNCMD__::"
+# How much it has printed so far: "__RUNOUT__::<lines>". From the wait loop, only when it changed.
+_RUNOUT_PREFIX = "__RUNOUT__::"
+_RUNCMD_MAX_CHARS = 4000
+
+# SECRETS. The 70-character cut hid most credentials by accident; showing the whole command must
+# not undo that. Conservative and by SHAPE — a value after a name that says it is a secret, a
+# bearer header, user:password@ in a URL, sshpass -p, and the key formats gu itself hands out.
+# This is what goes to the SCREEN and the job stream; the command that runs is untouched.
+# "pass" and "token" only as whole words: --passes=3, bypass=true and --max-tokens 100 are not secrets.
+_SECRET_NAME = (r"(?:password|passwd|passphrase|pwd|(?<![a-z])pass(?![a-z])|secret|token(?![a-z])"
+                r"|api[_-]?key|access[_-]?key)")
+_CMD_SECRET_RES = (
+    (re.compile(r"(?i)(\b[\w.-]*" + _SECRET_NAME + r"[\w.-]*\s*[=:]\s*)(\"[^\"]*\"|'[^']*'|[^\s;&|]+)"), r"\1•••"),
+    (re.compile(r"(?i)(--?[\w-]*" + _SECRET_NAME + r"[\w-]*[ =])(\"[^\"]*\"|'[^']*'|[^\s;&|]+)"), r"\1•••"),
+    (re.compile(r"(?i)(\bsshpass\s+-p\s*)(\"[^\"]*\"|'[^']*'|[^\s;&|]+)"), r"\1•••"),
+    (re.compile(r"(?i)(authorization:\s*(?:bearer|basic)\s+)[^\s\"']+"), r"\1•••"),
+    (re.compile(r"(?i)(\b[a-z][a-z0-9+.-]*://[^\s/:@]+:)[^\s/@]+(@)"), r"\1•••\2"),
+    (re.compile(r"\b(?:sk-[A-Za-z0-9_-]{16,}|gh[pousr]_[A-Za-z0-9]{20,}|wk_[A-Za-z0-9_-]{16,}|gu1\.[A-Za-z0-9_.-]{20,})"), "•••"),
+)
+
+
+def _mask_command_secrets(command: str) -> str:
+    """The command as it may be SHOWN: credentials replaced by •••, everything else as written."""
+    text = str(command or "")
+    for rx, sub in _CMD_SECRET_RES:
+        text = rx.sub(sub, text)
+    return text
+
+
+def _command_label(command: str, limit: int = 70) -> str:
+    """A command as ONE LINE of a step label: masked, its first line only, cut to `limit`.
+
+    A step is a line of the stream. A heredoc's newlines made "Command finished → python3 - <<'EOF'"
+    followed by every line of the script as a bullet of its own — and, on the way in, ended the
+    live status row the moment the "Running →" line was read (#332). " …" says there is more.
+    """
+    lines = [ln.strip() for ln in _mask_command_secrets(command).replace("\r", "").split("\n") if ln.strip()]
+    if not lines:
+        return ""
+    return lines[0][:limit] + (" …" if len(lines) > 1 else "")
+
+
+def _running_command_line(command: str) -> str:
+    """The stream line that carries the whole command to the terminal (masked, capped)."""
+    shown = _mask_command_secrets(command)
+    if len(shown) > _RUNCMD_MAX_CHARS:
+        shown = shown[:_RUNCMD_MAX_CHARS] + "…"
+    return _RUNCMD_PREFIX + json.dumps({"cmd": shown}, ensure_ascii=False)
+
+
+def _count_output_lines(path: str, state: dict) -> int:
+    """Lines a running command has written to its log so far. Reads only what is NEW since the
+    last call (`state` keeps the offset), so a chatty ten-minute build is not re-read every tick."""
+    try:
+        with open(path, "rb") as fh:
+            fh.seek(state.get("off", 0))
+            chunk = fh.read()
+    except OSError:
+        return state.get("lines", 0)
+    if chunk:
+        state["off"] = state.get("off", 0) + len(chunk)
+        state["lines"] = state.get("lines", 0) + chunk.count(b"\n")
+        state["partial"] = not chunk.endswith(b"\n")
+    # a last line with no newline yet is still a line someone could read
+    return state.get("lines", 0) + (1 if state.get("partial") else 0)
+
+
+def _emit_command_progress(path: str, state: dict) -> None:
+    """Tell the terminal how much the running command has printed — only when that changed."""
+    try:
+        n = _count_output_lines(path, state)
+        if n != state.get("sent", 0):
+            state["sent"] = n
+            _emit({"type": "step", "text": f"{_RUNOUT_PREFIX}{n}"})
+    except Exception:  # noqa: BLE001 — a progress figure must never fail a command
+        pass
+
+
 def _fmt_call(name: str, **kw) -> str:
     """A tool call rendered the way the model writes it. Skips empty/default arguments."""
     parts = []
@@ -6391,6 +6475,114 @@ def _and_chain_parts(command):
     return parts
 
 
+def _parse_heredoc(command):
+    """A heredoc or here-string in `command` → what to run and what to feed it. (task #332)
+
+    THE BUG THIS EXISTS FOR. run_command has no shell, so
+
+        python3 - <<'EOF'
+        print("hello")
+        EOF
+
+    became argv ["python3", "-", "<<EOF", "print(hello)", "EOF"]: python read its script from an
+    EMPTY stdin and exited 0 with no output. Nothing ran and the step looked like a success —
+    the #204 failure again, in the one shape #204's check did not cover (its redirect pattern
+    matches "<" and ">", not "<<"). Seen live: the model lost two steps rewriting the work as
+    `python3 -c`. Heredocs are how a strong model runs a multi-line script without a file, so
+    this is the common case, not an edge.
+
+    SUPPORTED, still with no shell: ONE program fed a body.
+        PROG ARGS <<'TAG' … TAG      the body becomes the program's stdin
+        PROG ARGS <<-TAG … TAG       same, leading tabs stripped
+        PROG ARGS <<< 'text'         a here-string: text + newline on stdin
+    REFUSED, each with the one change that fixes it — a guess costs a model step:
+        an unquoted TAG (or a double-quoted here-string) whose text has $ or ` — a shell would
+        expand those and we cannot; anything after the closing TAG; no closing TAG; two heredocs.
+
+    Returns None when there is no heredoc (`echo "a << b"` and `python3 -c "print(1 << 3)"` are
+    not: the operator only counts OUTSIDE quotes), else {"command", "stdin"} or {"error"}.
+    Pure, so every shape is testable without spawning anything.
+    """
+    s = command or ""
+    q = None
+    i = 0
+    at = -1
+    while i < len(s):
+        c = s[i]
+        if q:
+            if c == q:
+                q = None
+            elif c == "\\" and q == '"':
+                i += 1
+        elif c in "'\"":
+            q = c
+        elif c == "\\":
+            i += 1
+        elif s.startswith("<<", i):
+            at = i
+            break
+        i += 1
+    if at < 0:
+        return None
+    _why = "Error: that command did NOT run — nothing was executed. "
+    before = s[:at]
+    if s.startswith("<<<", at):
+        # HERE-STRING: the next word is the input; anything after it stays an argument.
+        rest = s[at + 3:]
+        import shlex as _shlex
+        try:
+            words = _shlex.split(rest)
+        except ValueError as e:
+            return {"error": _why + f"The here-string is not closed: {e}."}
+        if not words:
+            return {"error": _why + "'<<<' needs the text to feed the program: PROG <<< 'text'."}
+        lead = rest.lstrip()
+        if not lead.startswith("'") and re.search(r"[$`]", words[0]):
+            return {"error": _why + "run_command has NO shell, so $variables and `commands` in a "
+                    "here-string are not expanded. Put the text in SINGLE quotes to pass it "
+                    "exactly as written, or write the final text yourself."}
+        tail = " ".join(_shlex.quote(w) for w in words[1:])
+        return {"command": (before.rstrip() + (" " + tail if tail else "")).strip(),
+                "stdin": words[0] + "\n"}
+    m = re.match(r"<<(-?)[ \t]*(?:'([^'\n]+)'|\"([^\"\n]+)\"|\\?([A-Za-z_][\w.-]*))", s[at:])
+    if not m:
+        return {"error": _why + "'<<' must be followed by a tag: PROG <<'EOF', the text, then "
+                "EOF on a line of its own."}
+    strip_tabs = bool(m.group(1))
+    tag = m.group(2) or m.group(3) or m.group(4)
+    quoted = bool(m.group(2) or m.group(3)) or s[at + m.end() - len(tag) - 1] == "\\"
+    after = s[at + m.end():]
+    line_rest, nl, body_and_more = after.partition("\n")
+    if "<<" in line_rest and _parse_heredoc(line_rest) is not None:
+        return {"error": _why + "Only one heredoc per command is supported. Write the second "
+                "text with create_file, or run the two commands in separate calls."}
+    lines = body_and_more.split("\n") if nl else []
+    end = -1
+    for k, ln in enumerate(lines):
+        if (ln.lstrip("\t") if strip_tabs else ln).rstrip("\r") == tag:
+            end = k
+            break
+    if end < 0:
+        return {"error": _why + f"The heredoc is never closed: put {tag} on a line of its own "
+                "after the text."}
+    body_lines = [(ln.lstrip("\t") if strip_tabs else ln).rstrip("\r") for ln in lines[:end]]
+    trailing = "\n".join(lines[end + 1:]).strip()
+    if trailing:
+        return {"error": _why + f"There is more after the closing {tag}, and run_command runs "
+                "ONE command per call (only && chains continue). Run what follows in a "
+                "separate run_command call."}
+    cmdline = (before.rstrip() + " " + line_rest.strip()).strip()
+    body = "\n".join(body_lines) + ("\n" if body_lines else "")
+    if not quoted and re.search(r"[$`]", body):
+        return {"error": _why + "run_command has NO shell, so the $variables and `commands` in "
+                f"this heredoc would not be expanded. Quote the tag — <<'{tag}' — to pass the "
+                "text exactly as written (that is what a script wants), or write the final "
+                "text yourself."}
+    if not cmdline:
+        return {"error": _why + "The heredoc has no program to feed: PROG <<'EOF' … EOF."}
+    return {"command": cmdline, "stdin": body}
+
+
 def _shell_syntax_error(command, argv):
     """Why this command cannot do what it says, or None. (task #204)
 
@@ -6963,7 +7155,7 @@ def _ws_request_approval(api_base, worker_key, job_id, command, reason, deadline
         _srv, _, _rest = command[len("__MCPTOOL__::"):].partition("\t")
         _emit({"type": "step", "text": f"Awaiting your approval: MCP tool {_srv}/{_rest.split(chr(9))[0]}"})
     else:
-        _emit({"type": "step", "text": f"Awaiting your approval to run: {command[:70]}"})
+        _emit({"type": "step", "text": f"Awaiting your approval to run: {_command_label(command, 70)}"})
     deadline = _t.time() + max(30, int(deadline_s))  # per-call; risky=180s, __MAXSTEP__ long
     while _t.time() < deadline:
         _t.sleep(1.2)
@@ -7341,6 +7533,12 @@ def _ws_scrubbed_env() -> dict:
     # CI=1 makes watch-mode test runners (CRA's `npm test`, jest --watch) run ONCE and
     # exit instead of sitting in interactive watch mode until the timeout kills them.
     env["CI"] = "1"
+    # WINDOWS: a python child reads and writes in the ANSI code page unless told otherwise, so a
+    # script fed on stdin (a heredoc, #332) with "é" or "→" in it is mis-decoded, and printing
+    # one raises UnicodeEncodeError. The worker's own python is started with PYTHONUTF8=1 for
+    # exactly this reason; the whitelist above dropped it for the commands it runs.
+    if _IS_WINDOWS:
+        env["PYTHONUTF8"] = "1"
     return env
 
 
@@ -12501,7 +12699,7 @@ def run_agent_chat(cfg):
             """Run a command inside a workspace that has run permission (e.g. 'npm test', 'npm run build', 'npm start', 'mvn test', 'python3 app.py'). One-shot commands return their output when they exit. If the command turns out to be a SERVER (keeps running and listens on a port), it is left RUNNING and its URL is reported. If it is a DESKTOP/GUI app (opens a window — tkinter, pygame, PyQt…), it is LAUNCHED and left running: its window appears on the user's Mac; tell them it's open. Both are stoppable via stop_server. Also allows DEPLOY commands (ssh/scp/rsync) — use non-interactive KEY auth (-o BatchMode=yes); never put a password in the command (there is no stdin). Note: an interactive CLI that reads stdin (input()) cannot be driven here — it will fail with EOFError; make it non-interactive or give the user the command to run themselves.
 
             Args:
-                command: the command line. Chain dependent steps with && in ONE call ("cd app && npm ci && npm test"): they run in order, cd sets the folder, the first failure stops the rest. No other shell syntax (no pipes/redirects/;). sudo/su are blocked.
+                command: the command line. Chain dependent steps with && in ONE call ("cd app && npm ci && npm test"): they run in order, cd sets the folder, the first failure stops the rest. To run a multi-line script without a file, feed ONE program a heredoc, tag quoted: "python3 - <<'EOF'\n...\nEOF". No other shell syntax (no pipes/redirects/;). sudo/su are blocked.
                 workdir: directory to run in. Empty = first registered workspace.
                 timeout_seconds: give up after this many seconds if the command neither exits nor starts a server (max 600).
             """
@@ -12546,7 +12744,24 @@ def run_agent_chat(cfg):
                            "gu-local-worker workspace add <path> --allow-run)")
                     _last_obs["text"] = msg
                     return msg
-                argv = shlex.split(command or "")
+                # A HEREDOC / HERE-STRING (task #332): the text is the program's stdin, and the
+                # command line is what is left. `command` stays the whole text for the risk gate,
+                # the status row and the log; `_cmdline` is what is split and judged as argv.
+                _here = _parse_heredoc(command)
+                if _here and _here.get("error"):
+                    _log(f"run_command refused heredoc: {_c(_clip(command, 120))}")
+                    _last_obs["text"] = _here["error"]
+                    return _here["error"]
+                _cmdline = _here["command"] if _here else (command or "")
+                _stdin_text = _here["stdin"] if _here else None
+                if _here and _and_chain_parts(_cmdline):
+                    msg = ("Error: that command did NOT run — nothing was executed. A heredoc "
+                           "cannot be part of an && chain here. Run the program that reads it in "
+                           "its own run_command call, and pass the folder as the cwd argument "
+                           "instead of `cd X &&`.")
+                    _last_obs["text"] = msg
+                    return msg
+                argv = shlex.split(_cmdline)
                 if not argv:
                     msg = "Error: empty command."
                     _last_obs["text"] = msg
@@ -12554,7 +12769,7 @@ def run_agent_chat(cfg):
                 # AN `&&` CHAIN IS ONE STEP (task #274): each part runs through THIS function —
                 # allowlist, risk gate, approval, server detection, all of it — in order, and
                 # the first failure stops the rest. `cd DIR` sets the folder for what follows.
-                _chain = _and_chain_parts(command)
+                _chain = None if _here else _and_chain_parts(command)
                 if _chain:
                     _chain_start = _t.time()
                     _cur_wd = wd
@@ -12604,7 +12819,7 @@ def run_agent_chat(cfg):
                 # executes the `cd` PROGRAM — which exits 0 with no output — and the step is
                 # reported as a success that did nothing. Refusing costs one step; the observed
                 # alternative cost two hour-long turns and a false report to the user.
-                _shell_err = _shell_syntax_error(command, argv)
+                _shell_err = _shell_syntax_error(_cmdline, argv)
                 if _shell_err:
                     _log(f"run_command refused shell syntax: {_c(_clip(command, 120))}")
                     _last_obs["text"] = _shell_err
@@ -12622,7 +12837,10 @@ def run_agent_chat(cfg):
                 # Risk gate: privilege escalation / denylisted / destructive. When the
                 # client can approve interactively (terminal), PAUSE and ask the user;
                 # otherwise (web) keep hard-blocking the privilege/denylist cases.
-                _hard_reason, _ask_reason = _ws_command_risk(command, argv, _WS_RUN_DENYLIST, wd)
+                # Judged on the COMMAND LINE, not on a heredoc's text: the text is data for the
+                # program (a script that prints "sudo …" is not a sudo), and what a script does
+                # is no more visible here than it is for `python3 -c`.
+                _hard_reason, _ask_reason = _ws_command_risk(_cmdline, argv, _WS_RUN_DENYLIST, wd)
                 # Shift+Tab may have switched it since the turn started (#47).
                 global _accept_edits
                 if _interactive_approval and _job_id:
@@ -12638,7 +12856,7 @@ def run_agent_chat(cfg):
                 # states it. "this needs root and sudo needs a password we cannot type" is a
                 # different question from "sudo is passwordless here", and the user can only
                 # answer the one they are shown.
-                _priv = _ws_priv_reason(command)
+                _priv = _ws_priv_reason(_cmdline)
                 _facts = _ws_access_facts() if _priv else None
                 if _priv and _facts and not _facts["can_elevate"]:
                     # REFUSE BEFORE SPAWNING (requirement 5). With no tty, `sudo x` dies with
@@ -12689,7 +12907,8 @@ def run_agent_chat(cfg):
                             _emit({"type": "step", "text": f"Server already up → {_urls} (reused)"})
                             _last_obs["text"] = msg
                             return msg
-                _emit({"type": "step", "text": f"Running → {command[:70]}"})
+                _emit({"type": "step", "text": f"Running → {_command_label(command, 70)}"})
+                _emit({"type": "step", "text": _running_command_line(command)})  # whole (#331)
                 t = max(5, min(int(timeout_seconds or 180), 600))
                 # Own process group (start_new_session) + output to a log file. This is
                 # what lets a server OUTLIVE this job process, and what lets a timeout
@@ -12705,13 +12924,30 @@ def run_agent_chat(cfg):
                 if _attrib_note:
                     _log(f"run_command: {_attrib_note}")
                 # Scrubbed env: repo scripts must never see worker secrets.
-                proc = subprocess.Popen(
-                    argv, cwd=wd, env=_ws_scrubbed_env(),
-                    stdout=log_fh, stderr=subprocess.STDOUT,
-                    **_ws_spawn_kwargs(),
-                )
+                # The heredoc's text as stdin, from an unnamed temp file: no pipe to keep fed (a
+                # pipe needs a writer thread or it deadlocks past 64 KB), and nothing left on
+                # disk — the file goes when the last handle on it closes.
+                _stdin_fh = None
+                if _stdin_text is not None:
+                    import tempfile
+                    _stdin_fh = tempfile.TemporaryFile()
+                    _stdin_fh.write(_stdin_text.encode("utf-8"))
+                    _stdin_fh.seek(0)
+                try:
+                    # stdin is passed ONLY for a heredoc — every other command keeps exactly
+                    # the stdin it has always had.
+                    proc = subprocess.Popen(
+                        argv, cwd=wd, env=_ws_scrubbed_env(),
+                        stdout=log_fh, stderr=subprocess.STDOUT,
+                        **({"stdin": _stdin_fh} if _stdin_fh is not None else {}),
+                        **_ws_spawn_kwargs(),
+                    )
+                finally:
+                    if _stdin_fh is not None:
+                        _stdin_fh.close()  # the child holds its own copy
                 _INFLIGHT_CMDS.add(proc.pid)  # killed with the agent until it is classified
                 start = _t.time()
+                _out_seen: dict = {}  # how much of its output the terminal has been told about
 
                 def _read_log() -> str:
                     log_fh.flush()
@@ -12744,7 +12980,7 @@ def run_agent_chat(cfg):
                             if rc == 0 else f"FAILED (exit {rc})"
                         )
                         _emit({"type": "step", "text":
-                               f"Command {'finished' if rc == 0 else 'failed'} → {command[:50]}"})
+                               f"Command {'finished' if rc == 0 else 'failed'} → {_command_label(command, 50)}"})
                         # SAY "no output" RATHER THAN SHOW NOTHING (task #204). An empty result
                         # was indistinguishable from a command that never ran — which is exactly
                         # what `cd X && Y` used to do — and the model read the silence as a
@@ -12818,6 +13054,8 @@ def run_agent_chat(cfg):
                                f"{t}s — killed. Output so far:\n{tail}")
                         _last_obs["text"] = msg
                         return msg
+                    log_fh.flush()
+                    _emit_command_progress(log_path, _out_seen)
                     _t.sleep(2)
             except Exception as ex:  # noqa: BLE001
                 msg = f"Error: run_command failed: {type(ex).__name__}: {ex}"

package/gu-repl.mjs

@@ -63,6 +63,8 @@ import {
   ragSegmentLabel,
   searchSegmentLabel,
   runningDetailRows,
+  runningCommandLabel,
+  runningCommandRows,
   formatThinkTime,
   plainAnswer,
   summarizeError,
@@ -128,6 +130,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 +894,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 +1466,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 +2689,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 +2772,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 +2842,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 +3004,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", () => {
@@ -7879,6 +7894,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 +9845,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__::";
@@ -10842,6 +10983,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
@@ -11062,9 +11209,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 +11245,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 +11382,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 +11425,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.
@@ -11405,6 +11575,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() };
@@ -11575,7 +11759,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.
@@ -12803,6 +12997,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 +13459,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.788",
   "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",

package/terminal-layout.mjs

@@ -2586,6 +2586,65 @@ export function runningDetailRows(detail, { width = 80, indent = 5, maxRows = 2
   ];
 }
 
+/**
+ * THE COMMAND THAT IS RUNNING, on the live status row (task #331): "$ find . -type f … (17s · 5 lines)".
+ *
+ * It used to read "Running <first 70 characters>… (17s)" with every newline squashed to a space,
+ * so a heredoc was one run-on line and a long pipeline stopped mid-flag. Now: the shell's "$", the
+ * command's FIRST LINE (a heredoc's first line is what names it), and at the right what the user
+ * is waiting to learn — how long it has run and how much it has printed.
+ *
+ * ONE ROW, ALWAYS — the status block is redrawn in place and a taller block moves the input line.
+ * The rest of the command is a click (or Ctrl+T) away: see runningCommandRows. → { label, more }
+ * `more` = there is more of the command than this row shows, i.e. the click has something to open.
+ */
+export function runningCommandLabel(command, { room = 66, secs = 0, lines = 0, expanded = false } = {}) {
+  const all = String(command ?? "").replace(/\r/g, "").split("\n").map((l) => l.replace(/\t/g, "  ").replace(/\s+$/, "")).filter((l) => l.trim());
+  const n = Math.max(0, Number(lines) || 0);
+  const suffix = `(${Math.max(0, secs | 0)}s${n ? ` · ${n} line${n === 1 ? "" : "s"}` : ""})`;
+  const multi = all.length > 1;
+  // opened: the rows underneath ARE the command, so the row above them just says what they are
+  if (expanded) return { label: `Running command  ${suffix}`, more: true };
+  const head = `$ ${(all[0] ?? "").trim()}`;
+  const space = Math.max(8, (room | 0) - suffix.length - 2);
+  const cut = head.length + (multi ? 2 : 0) > space;
+  const shown = cut ? head.slice(0, Math.max(1, space - 1)).replace(/\s+$/, "") + "…" : head + (multi ? " …" : "");
+  return { label: `${shown}  ${suffix}`, more: cut || multi };
+}
+
+/**
+ * The whole command, opened under the status row: "└ $ …" with a hanging indent, its own line
+ * breaks kept (a heredoc reads as the script it is), long lines wrapped at a space, and a cap —
+ * past it the last row ends in "…". Rows NEVER exceed `width`: the block is redrawn by walking
+ * physical rows, and a row that wraps on its own breaks every row under it (#109, #138).
+ */
+export function runningCommandRows(command, { width = 76, maxRows = 5 } = {}) {
+  const lead = "└ $ ";
+  const pad = " ".repeat(lead.length);
+  const room = Math.max(12, (width | 0) - lead.length);
+  const out = [];
+  for (const raw of String(command ?? "").replace(/\r/g, "").split("\n")) {
+    let rest = raw.replace(/\t/g, "  ").replace(/\s+$/, "");
+    if (!rest.trim()) continue;
+    while (rest.length > room) {
+      const sp = rest.lastIndexOf(" ", room);
+      // …but never break inside the leading indentation, or a wrapped line loses its shape
+      const cut = sp > room * 0.5 ? sp : room;
+      out.push(rest.slice(0, cut));
+      rest = rest.slice(cut).replace(/^ /, "");
+    }
+    out.push(rest);
+  }
+  if (!out.length) return [];
+  const cap = Math.max(1, maxRows | 0);
+  const rows = out.slice(0, cap);
+  if (out.length > cap) {
+    const last = rows[cap - 1];
+    rows[cap - 1] = (last.length >= room ? last.slice(0, room - 1) : last) + "…";
+  }
+  return rows.map((r, i) => (i ? pad : lead) + r);
+}
+
 /**
  * How long the turn took, for the line above the answer (task #178).
  *