@tiens.nguyen/gu-cli 1.0.788 → 1.0.790

package/gu-repl.mjs

@@ -63,8 +63,6 @@ import {
   ragSegmentLabel,
   searchSegmentLabel,
   runningDetailRows,
-  runningCommandLabel,
-  runningCommandRows,
   formatThinkTime,
   plainAnswer,
   summarizeError,
@@ -130,7 +128,6 @@ 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";
@@ -894,7 +891,6 @@ 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.
@@ -1466,11 +1462,6 @@ 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)
@@ -2689,9 +2680,6 @@ 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 });
 }
 
@@ -2772,7 +2760,6 @@ 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) };
 }
@@ -2842,7 +2829,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 || logsRowTarget ? noticeAbs : 0;
+  updateRowAbs = updateRowTarget || agentsRowTarget || pricesRowTarget ? 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(
@@ -3004,8 +2991,6 @@ 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", () => {
@@ -7894,128 +7879,6 @@ 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).
  *
@@ -9845,10 +9708,6 @@ 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__::";
@@ -10983,12 +10842,6 @@ 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
@@ -11209,23 +11062,9 @@ 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.
-    // 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;
+    const clickable = !!fullLiveThought && !runningCmd && fullLiveThought.length > max;
     let label, rest;
-    if (cmdView) {
-      label = cmdView.label;
-      rest = "";
-    } else if (clickable) {
+    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
@@ -11245,13 +11084,7 @@ 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 = cmdView
-      ? thoughtExpanded
-        ? runningCommandRows(runningCmdFull || runningCmd, {
-            width: Math.max(20, process.stdout.columns || 80) - 1 - GUTTER.length,
-          })
-        : []
-      : thoughtExpanded && rest ? wrapThought(rest, max, 4) : [];
+    const expLines = 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.
@@ -11382,14 +11215,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 && !(runningCmd ? runningCmdMore : fullLiveThought)) return;
+    if (!thoughtExpanded && !(fullLiveThought && !runningCmd)) 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 && !(runningCmd ? runningCmdMore : fullLiveThought)) return;
+    if (!thoughtExpanded && !(fullLiveThought && !runningCmd)) return;
     thoughtExpanded = !thoughtExpanded;
     clearStatus(); // next tick (≤120ms) redraws at the new size; keeps cursor math correct
   };
@@ -11425,9 +11258,6 @@ 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.
@@ -11575,20 +11405,6 @@ 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() };
@@ -11759,17 +11575,7 @@ 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];
-          // 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;
-        }
+        if (mRun) { runningCmd = mRun[1]; 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.
@@ -12271,6 +12077,29 @@ async function main() {
   // Asking an established machine to re-pick its mode on the first run after an upgrade
   // implies that choosing Host would do something. It would not. Reported live on an existing
   // machine that had been working for months.
+  //
+  // THE DATABASE FIRST, on a machine whose Local setup is finished (task #329). Every line below
+  // talks to the API, and the API cannot answer without MongoDB — but its health check says "up"
+  // regardless, so a missing mongod surfaced as two 15s timeouts and "the API is stuck". One
+  // handshake here says what is actually wrong, and on a Mac offers to install or start it.
+  // BEFORE the mode block on purpose: a database that had to be INSTALLED is empty, the steps
+  // that filled it are re-opened, and the resume just below then runs them in this same start.
+  if (isClientExpert()) {
+    let mongoOk = true;
+    try {
+      const cer = await import("./client-expert-run.mjs");
+      const { localMongoUri } = await import("./client-expert-api.mjs");
+      const st0 = await cer.loadState();
+      if (st0.mongo === "done") {
+        const pre = await cer.preflightLocalMongo({ ask, isTty: IS_TTY, uri: localMongoUri() });
+        mongoOk = pre.ok;
+        if (pre.installed) await cer.saveState(cer.reopenAfterEmptyDatabase(st0));
+      }
+    } catch {
+      /* a check, never a new way for gu to fail to start — the errors below still name the API */
+    }
+    if (!mongoOk) process.exit(1);
+  }
   try {
     const { loadState, saveState, askMode } = await import("./client-expert-run.mjs");
     const { clientExpertAvailable, expertPlanPending, shouldAskMode, parseLicenseFlag, resolveFirstRunMode, promptForLicenseToken } =
@@ -12952,7 +12781,25 @@ async function main() {
           dim("\n  Local mode keeps your conversations in MongoDB on this machine, and that") +
           dim("\n  API is what reads it. It does not survive a reboot on its own.\n")
       );
+      // ASK MONGODB ITSELF before telling the reader to (task #329). It can die AFTER the startup
+      // check passed, and "is mongod running?" is a question this process answers in milliseconds.
+      let mongoDown = "";
       if (hung) {
+        try {
+          const { localMongoDown } = await import("./client-expert-run.mjs");
+          const { localMongoUri } = await import("./client-expert-api.mjs");
+          mongoDown = await localMongoDown(localMongoUri());
+        } catch {
+          /* unknown — the general advice below still applies */
+        }
+      }
+      if (mongoDown) {
+        console.error(
+          dim(`  The API is running; MongoDB is not answering at ${mongoDown}, and the API waits on it.`) +
+            dim("\n  Start MongoDB (run `gu` again — it checks the database first and says how),") +
+            dim("\n  no API restart needed.\n")
+        );
+      } else if (hung) {
         // Do NOT try to start it — the port is taken by the process that is failing to answer.
         console.error(
           dim("  Something IS listening there but did not reply within ") +
@@ -12997,8 +12844,6 @@ 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();
@@ -13459,10 +13304,6 @@ 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/mongo-native.mjs

@@ -144,6 +144,28 @@ export const BREW_INSTALL_STEPS = [
 ];
 export const BREW_START_STEPS = [["services", "start", "mongodb/brew/mongodb-community"]];
 
+/**
+ * HOMEBREW 7 REFUSES AN UNTRUSTED TAP (task #329, seen live 2026-10-02 on a fresh Homebrew 7.0.7):
+ *     Error: Refusing to load formula mongodb/brew/mongodb-database-tools from untrusted tap
+ *     mongodb/brew. Run … `brew trust mongodb/brew` to trust it.
+ * so tap → install, the steps that worked two days earlier, stopped at the install on exactly the
+ * machine a first install runs on. An older Homebrew has no `trust` command and must not be
+ * shown one, so the step is added only where the command exists.
+ */
+export const BREW_TRUST_STEP = ["trust", "mongodb/brew"];
+export function brewInstallSteps({ trust = false } = {}) {
+  return trust ? [BREW_INSTALL_STEPS[0], BREW_TRUST_STEP, ...BREW_INSTALL_STEPS.slice(1)] : BREW_INSTALL_STEPS;
+}
+/** Does this Homebrew have `brew trust`? (`brew trust --help` exits 0 only where it exists.) */
+export async function brewHasTrust(brew, { run = runStreaming } = {}) {
+  if (!brew) return false;
+  return (await run(brew, ["trust", "--help"], { env: { ...process.env, HOMEBREW_NO_AUTO_UPDATE: "1" } })) === 0;
+}
+
+/** Homebrew's own one-line installer (https://brew.sh) — it asks for the password itself. */
+export const HOMEBREW_INSTALL_COMMAND =
+  '/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"';
+
 /** Where Homebrew is, or "". Apple Silicon first, then Intel. */
 export function findBrew({ exists = existsSync } = {}) {
   for (const p of ["/opt/homebrew/bin/brew", "/usr/local/bin/brew"]) if (exists(p)) return p;
@@ -153,8 +175,11 @@ export function findBrew({ exists = existsSync } = {}) {
 /** The lines a Mac with no Homebrew is shown. */
 export function noBrewLines() {
   return [
-    "MongoDB is installed with Homebrew on a Mac, and Homebrew is not here.",
-    "Install Homebrew (https://brew.sh), then run gu again — setup installs MongoDB from there.",
+    "MongoDB is installed with Homebrew on a Mac, and Homebrew is not here. Install Homebrew first:",
+    `  ${HOMEBREW_INSTALL_COMMAND}`,
+    "then run gu again — it installs MongoDB from there with:",
+    // A Homebrew installed today is 7+, which needs the tap trusted.
+    ...brewInstallSteps({ trust: true }).map((s) => `  brew ${s.join(" ")}`),
     "Or install MongoDB Community yourself: https://www.mongodb.com/try/download/community",
   ];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.788",
+  "version": "1.0.790",
   "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,7 +77,6 @@
     "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,65 +2586,6 @@ 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).
  *