@tiens.nguyen/gu-cli 1.0.862 → 1.0.864

package/gu-cli.mjs

@@ -139,7 +139,8 @@ Usage:
   gu-cli workspace revert [runId]          # undo an agent run's file edits from its backups
   gu-cli mongo migrate-from-docker         # macOS: move a Docker MongoDB to native (Homebrew)
   gu-cli clear [--scratch|--keep-history] [--yes]  # back to a fresh machine (asks first)
-  gu-cli support                           # write a masked health report for the support team
+  gu-cli support                           # send the support team a request with gu's logs (masked) attached
+  gu-cli support --no-send                 # only make the logs zip (~/.gonext/support/) to email yourself
   gu-cli fix-path [--check]                # put npm's global folder on PATH (Windows: check, then ask)
                                                #   (what the install does, if npm skipped it)
   gu-cli fix-powershell [--check]          # Windows: drop PowerShell's built-in \`gu\` alias
@@ -1111,14 +1112,45 @@ if (args[0] === "fix-path") {
   // #94: under `npx @tiens.nguyen/gu-cli fix-path` this file runs from npx's cache; fixPathPrefix
   // then falls back to npm's global prefix when gu is installed there.
   const prefix = fixPathPrefix({ here });
+  // #221: besides the PATH line, look for what an old or second install left behind — broken
+  // `gu` links, a second copy from another npm, a profile line pinned to a versioned Homebrew
+  // folder. Each is explained and asked about; `--check` only reports.
+  const scanEnvironment = async () => {
+    const { checkEnvironment, applyFix } = await import("./env-check.mjs");
+    const { homedir } = await import("node:os");
+    const findings = checkEnvironment({ pathDirs: (process.env.PATH || "").split(":"), home: homedir(), here });
+    if (!findings.length) return;
+    console.log("\n  Also found:");
+    const { spawnSync } = await import("node:child_process");
+    let rl = null;
+    const check = args.includes("--check") || !process.stdin.isTTY;
+    for (const f of findings) {
+      console.log(`  • ${f.text}`);
+      if (!f.fix || check) {
+        if (f.fix) console.log(`    Fix: ${f.fix.label}   (run \`gu-cli fix-path\` in a terminal to be asked)`);
+        continue;
+      }
+      rl ??= (await import("node:readline/promises")).createInterface({ input: process.stdin, output: process.stdout });
+      // Removing another gu install is the one that costs something: default No.
+      const dflt = f.fix.kind === "uninstall-copy" ? "N" : "Y";
+      const a = (await rl.question(`    ${f.fix.label}? [${dflt === "Y" ? "Y/n" : "y/N"}] `)).trim().toLowerCase();
+      if (!(a === "y" || a === "yes" || (a === "" && dflt === "Y"))) continue;
+      const r = applyFix(f.fix, { run: (cmd, a2) => spawnSync(cmd, a2, { encoding: "utf8" }) });
+      console.log(r.ok ? "    Done." : `    Could not: ${r.why}`);
+    }
+    rl?.close();
+  };
   if (!prefix) {
     console.log(`  gu is not installed globally with npm (${here}) — there is no PATH to fix.`);
     console.log("  Install it with: npm install -g @tiens.nguyen/gu-cli");
+    await scanEnvironment();
     process.exit(0);
   }
+  const { stableBinDir } = await import("./env-check.mjs");
   const binDir = join(prefix, "bin");
-  if ((process.env.PATH || "").split(":").includes(binDir)) {
+  if ((process.env.PATH || "").split(":").some((d) => d === binDir || d === stableBinDir(binDir))) {
     console.log(`  Nothing to fix — ${binDir} is already on PATH.`);
+    await scanEnvironment();
     process.exit(0);
   }
   const { spawnSync } = await import("node:child_process");
@@ -1143,9 +1175,10 @@ if (args[0] === "fix-path") {
     if (has) console.log(`  Your shell profile already adds ${binDir} to PATH — open a new terminal.`);
     else {
       console.log(`  ${binDir} is not on your PATH and was not added to a shell profile. Add this line to it:`);
-      console.log(`  export PATH="${binDir}:$PATH"`);
+      console.log(`  export PATH="${stableBinDir(binDir)}:$PATH"`);
     }
   }
+  await scanEnvironment();
   process.exit(r.status ?? 0);
 }
 
@@ -1159,91 +1192,111 @@ if (args[0] === "fix-powershell") {
     process.exit(0);
   }
   const { execFileSync } = await import("node:child_process");
-  const ps = (script) =>
-    execFileSync("powershell", ["-NoProfile", "-Command", script], { encoding: "utf8" }).trim();
-
-  let profilePath = "";
-  try {
-    profilePath = ps("$PROFILE");
-  } catch (e) {
-    console.error(`  Could not ask PowerShell where your profile is: ${e.message}`);
-    process.exit(1);
-  }
-  const { readFileSync, writeFileSync, mkdirSync, existsSync } = await import("node:fs");
-  const current = existsSync(profilePath) ? readFileSync(profilePath, "utf8") : "";
-  const next = pa.profileWithFix(current);
-  // ASKED IN EVERY PATH, because "already fixed" was reported on the very machine whose policy
-  // stops the profile loading — the same "said Done, changed nothing" mistake one branch along.
-  const blockedBy = () => {
+  const runPs = (host, script) =>
+    execFileSync(host, ["-NoProfile", "-Command", script], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+
+  // EVERY installed PowerShell has its OWN profile: Windows PowerShell 5.1 (`powershell`) and
+  // PowerShell 7 (`pwsh`, VS Code's usual terminal) read different files. Asking only
+  // `powershell` wrote the fix where a pwsh terminal never looked.
+  const found = [];
+  for (const host of pa.POWERSHELL_HOSTS) {
     try {
-      return pa.profileBlockedBy(ps("Get-ExecutionPolicy"));
+      found.push({ host, profilePath: runPs(host, "$PROFILE.CurrentUserAllHosts") });
     } catch {
-      return "";
-    }
-  };
-  if (next === null) {
-    console.log(`  Already fixed — ${profilePath} removes the alias.`);
-    const blocked = blockedBy();
-    if (blocked) {
-      console.log("");
-      for (const l of pa.policyAdvice(blocked)) console.log("  " + l);
-      process.exit(1);
+      /* that PowerShell is not installed */
     }
-    console.log("  Open a NEW PowerShell window for it to take effect.");
-    process.exit(0);
-  }
-  if (args.includes("--check")) {
-    console.log("  Not fixed yet. `gu` in PowerShell is still Get-Unique.");
-    const blocked = blockedBy();
-    if (blocked) for (const l of pa.policyAdvice(blocked)) console.log("  " + l);
-    console.log(`  Run:  gu-cli fix-powershell    (edits ${profilePath})`);
-    process.exit(1);
   }
-  console.log("");
-  for (const l of pa.shadowedAdvice()) console.log("  " + l);
-  console.log("");
-  console.log(`  This appends ONE line to ${profilePath}:`);
-  console.log("    " + pa.PROFILE_LINE);
-  const rlp = (await import("node:readline")).createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-  const answer = await new Promise((r) => rlp.question("\n  Append it? [y/N]: ", r));
-  rlp.close();
-  if (!/^y(es)?$/i.test(String(answer).trim())) {
-    console.log("  " + pa.MEANWHILE);
-    process.exit(0);
-  }
-  try {
-    const dir = profilePath.replace(/[\\/][^\\/]*$/, "");
-    if (dir && !existsSync(dir)) mkdirSync(dir, { recursive: true });
-    writeFileSync(profilePath, next, "utf8");
-  } catch (e) {
-    console.error(`  Could not write ${profilePath}: ${e.message}`);
+  const targets = pa.uniqueProfiles(found);
+  if (targets.length === 0) {
+    console.error("  Could not ask PowerShell where your profile is (neither `powershell` nor `pwsh` answered).");
     process.exit(1);
   }
-  console.log(`  Done — ${profilePath} updated.`);
-  // VERIFY THE FIX CAN ACTUALLY RUN. Writing the line is not the same as PowerShell loading it:
-  // under Restricted or AllSigned the profile is a script it refuses to execute, and the first
-  // real run of this said "Done" to a machine where `gu` stayed shadowed.
-  const policy = blockedBy();
-  if (policy) {
+  const { readFileSync, writeFileSync, mkdirSync, existsSync } = await import("node:fs");
+  const checkOnly = args.includes("--check");
+  let rlp = null;
+  let worst = 0;
+
+  for (const { host, profilePath } of targets) {
     console.log("");
-    for (const l of pa.policyAdvice(policy)) console.log("  " + l);
-    process.exit(1);
+    console.log(`  ${pa.hostLabel(host)} — ${profilePath}`);
+    const current = existsSync(profilePath) ? readFileSync(profilePath, "utf8") : "";
+    const next = pa.profileWithFix(current);
+    // ASKED IN EVERY PATH, because "already fixed" was reported on the very machine whose policy
+    // stops the profile loading — the same "said Done, changed nothing" mistake one branch along.
+    const blockedBy = () => {
+      try {
+        return pa.profileBlockedBy(runPs(host, "Get-ExecutionPolicy"));
+      } catch {
+        return "";
+      }
+    };
+    if (next === null) {
+      console.log("  Already fixed — the profile removes the alias.");
+      const blocked = blockedBy();
+      if (blocked) {
+        for (const l of pa.policyAdvice(blocked)) console.log("  " + l);
+        worst = 1;
+      }
+      continue;
+    }
+    if (checkOnly) {
+      console.log("  Not fixed yet. `gu` in this PowerShell is still Get-Unique.");
+      const blocked = blockedBy();
+      if (blocked) for (const l of pa.policyAdvice(blocked)) console.log("  " + l);
+      worst = 1;
+      continue;
+    }
+    for (const l of pa.shadowedAdvice()) console.log("  " + l);
+    console.log(`  This appends ONE line to ${profilePath}:`);
+    console.log("    " + pa.PROFILE_LINE);
+    rlp ??= (await import("node:readline")).createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    const answer = await new Promise((r) => rlp.question("\n  Append it? [y/N]: ", r));
+    if (!/^y(es)?$/i.test(String(answer).trim())) {
+      console.log("  " + pa.MEANWHILE);
+      continue;
+    }
+    try {
+      const dir = profilePath.replace(/[\\/][^\\/]*$/, "");
+      if (dir && !existsSync(dir)) mkdirSync(dir, { recursive: true });
+      writeFileSync(profilePath, next, "utf8");
+    } catch (e) {
+      console.error(`  Could not write ${profilePath}: ${e.message}`);
+      worst = 1;
+      continue;
+    }
+    console.log(`  Done — ${profilePath} updated.`);
+    // VERIFY THE FIX CAN ACTUALLY RUN. Writing the line is not the same as PowerShell loading it:
+    // under Restricted or AllSigned the profile is a script it refuses to execute, and the first
+    // real run of this said "Done" to a machine where `gu` stayed shadowed.
+    const policy = blockedBy();
+    if (policy) {
+      for (const l of pa.policyAdvice(policy)) console.log("  " + l);
+      worst = 1;
+    }
   }
-  console.log("  Open a NEW PowerShell window, then `gu` runs this CLI.");
-  process.exit(0);
+  rlp?.close();
+  if (worst === 0 && !checkOnly) console.log("\n  Open a NEW PowerShell window (in VS Code too), then `gu` runs this CLI.");
+  process.exit(worst);
 }
 
 if (args[0] === "support") {
-  // One redacted report for the support team (see support-report.mjs). Changes nothing but its own file.
-  const sr = await import("./support-report.mjs");
-  const { lines, file } = await sr.writeSupportReport({ version: WORKER_VERSION });
-  for (const l of lines) console.log(l);
-  console.log("");
-  console.log(`  Saved to ${file} — send that file (or this text) to the support team. Secrets are masked.`);
-  process.exit(0);
+  // #220: the masked logs + health report as one zip, shown, then sent to the support team with a
+  // reference back (support-command.mjs). `--report` is the old text-only report.
+  const { runSupportCommand } = await import("./support-command.mjs");
+  let rl = null;
+  const ask = async (q) => {
+    rl ??= (await import("node:readline/promises")).createInterface({ input: process.stdin, output: process.stdout });
+    return rl.question(q).catch(() => "");
+  };
+  const code = await runSupportCommand({ args: args.slice(1), version: WORKER_VERSION, ask });
+  rl?.close();
+  process.exit(code);
 }
 
 if (args[0] === "clear" || args[0] === "reset") {

package/gu-repl.mjs

@@ -105,6 +105,8 @@ import {
   physicalRows,
   inputPhysicalRows,
   buildFooterRows,
+  buildFooter,
+  SUPPORT_LINK_TEXT,
   pasteHint,
   hintRows as questionHintRows,
   footerDrawSeq,
@@ -707,6 +709,33 @@ let openPresetsAtStart = false;
 // #132 follow-up: a hosted provider picked in first-run setup; its key and model are asked once the terminal exists.
 let addProviderAtStart = null;
 
+// #220: a gu that STOPS ON AN ERROR says where help is — a start that failed (exit 1 before the
+// prompt: no key, API unreachable, MongoDB down…) or a crash. One dim line, never during a session
+// that started fine, where /support is in the command list.
+let supportHintAtExit = true;
+const SUPPORT_HINT = "Need help? Run `gu support` — it sends the support team gu's logs (secrets masked).";
+process.on("exit", (code) => {
+  if (code !== 1 || !supportHintAtExit) return;
+  try {
+    process.stderr.write("\n" + dim(SUPPORT_HINT) + "\n");
+  } catch {
+    /* stderr gone: nothing to tell */
+  }
+});
+function crashed(e) {
+  try {
+    releaseScreenAtExit();
+  } catch {
+    /* the screen may not be ours yet */
+  }
+  console.error(e?.stack || String(e));
+  supportHintAtExit = true;
+  process.exit(1);
+}
+process.on("uncaughtException", crashed);
+process.on("unhandledRejection", crashed);
+
+
 if (!workerKey || !apiBase) {
   if (process.stdin.isTTY && process.stdout.isTTY) {
     try {
@@ -977,6 +1006,7 @@ const COMMANDS = [
   { name: "/shells", desc: "long commands the agent left running in the background — status, runtime, command, output; stop one" },
   { name: "/budget", desc: "short view of your API provider budgets and balances (Pro) — the same items as the web /providers page" },
   { name: "/tokens", desc: "break down the last prompt sent to the coding model — how much of it was RAG" },
+  { name: "/support", desc: "send the gu support team a request with gu's logs attached (secrets masked) — shows what goes first, then asks" },
   { 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
@@ -1573,6 +1603,12 @@ function applyClick({ row, col }) {
     void runClearLogs();
     return;
   }
+  // The footer's "? support" link (#220): the footer is the last rows of the screen, so count from the bottom.
+  if (supportLinkTarget && !zonePanel && row === viewportRows() - supportLinkTarget.fromEnd + 1 &&
+      col - 1 >= supportLinkTarget.from && col - 1 < supportLinkTarget.to) {
+    void runSupport();
+    return;
+  }
   if (agentsRowTarget && row === updateRowAbs &&
       col - 1 >= agentsRowTarget.from && col - 1 < agentsRowTarget.to) {
     void showOtherAgents(); // async now — it offers stop / switch-to (task #211)
@@ -2488,6 +2524,8 @@ async function refreshAvailableUpdates() {
  * paid to see the warning go.
  */
 let tokenNotice = null;
+/** #219: true while the token question is on screen — the bar must not repeat its warning. */
+let tokenQuestionOpen = false;
 let tokenBusy = false;
 let startupRenewDone = false;
 /**
@@ -2866,8 +2904,12 @@ const compactLockNote = () =>
         at: lastPromptBreakdown?.compactedAt,
       })
     : "";
-const footerRows = () =>
-  buildFooterRows({
+// #220: where the footer's "? support" link is on screen (set by frozenZone, read by applyClick).
+let supportLinkTarget = null;
+const footerBuilt = () =>
+  buildFooter({
+    link: SUPPORT_LINK_TEXT,
+    linkPaint: (t) => dim("\x1b[4m" + t + "\x1b[24m"),
     width: process.stdout.columns || 80,
     gutter: GUTTER,
     rag: REPL_VERBOSE && (lastRagFile || lastRagState) ? ragLineText() : "",
@@ -2893,6 +2935,7 @@ const footerRows = () =>
     // where the red rows above mean something is not set up at all.
     missing: [...missingNoticeRows().map((r) => red(r)), ...fallbackNoticeRows().map((r) => yellow(r))],
   });
+const footerRows = () => footerBuilt().rows;
 // An ask()'s hint lines (#305), drawn in yellow under its input while it waits. Plain text.
 let askHint = [];
 const askHintRows = (width) => questionHintRows(askHint, { width, gutter: GUTTER, paint: yellow });
@@ -3006,9 +3049,11 @@ function zoneNotice(width) {
     const up = updateRow({ ...availableUpdates, width: 400 });
     if (up) items.push({ key: "update", clickable: true, paint: accent, text: up.text.slice(up.from) });
   }
-  if (priceUpdate) items.push({ key: "prices", clickable: true, paint: accent, text: `${priceUpdateText()} (click)` });
-  if (limitsUpdate) items.push({ key: "limits", clickable: true, paint: accent, text: `${limitsUpdate.label} (click)` });
-  if (tokenNotice?.text) items.push({ key: "token", paint: tokenNotice.urgent ? yellow : dim, text: tokenNotice.text });
+  // While the token question is open it is the ONLY thing on the screen (#222): the housekeeping
+  // notices (new prices, new token limits) wait, and the token notice would repeat the question.
+  if (priceUpdate && !tokenQuestionOpen) items.push({ key: "prices", clickable: true, paint: accent, text: `${priceUpdateText()} (click)` });
+  if (limitsUpdate && !tokenQuestionOpen) items.push({ key: "limits", clickable: true, paint: accent, text: `${limitsUpdate.label} (click)` });
+  if (tokenNotice?.text && !tokenQuestionOpen) 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)` });
   const shells = shellsNotice(shellEntries, { cwd: process.cwd() });
@@ -3123,7 +3168,10 @@ function frozenZone() {
     selection: secretInput ? null : inputSelection,
     highlight: highlightRow,
   });
-  const rows = status.concat(notice ? [notice.row] : [], zone.rows, askHintRows(width), footerRows());
+  const footer = footerBuilt();
+  const rows = status.concat(notice ? [notice.row] : [], zone.rows, askHintRows(width), footer.rows);
+  // The footer is the LAST rows of the zone, so the link's row counts from the end.
+  supportLinkTarget = footer.link ? { fromEnd: footer.rows.length - footer.link.rowIndex, from: footer.link.from, to: footer.link.to } : null;
   // The separator is `status.length (+1 for the notice row)` rows down — everything that writes to
   // or hit-tests a row by index counts from here.
   const sep = status.length + (notice ? 1 : 0);
@@ -8585,6 +8633,83 @@ async function refreshLogsSize() {
   }
 }
 
+// /support (#220): gu's logs, masked and zipped, sent to the support team with a reference back.
+// What is collected and how it is sent is support-bundle.mjs; this is the terminal half only.
+let supportBusy = false;
+async function runSupport() {
+  if (following) {
+    console.log("\n" + GUTTER + dim("A turn is running - /support is available when it finishes (Ctrl-C stops it)."));
+    return;
+  }
+  if (supportBusy || listPickerActive || approvalActive || askWaiting) return;
+  supportBusy = true;
+  try {
+    const sb = await import("./support-bundle.mjs");
+    const width = Math.max(20, process.stdout.columns || 80);
+    const tilde = (p) => (p.startsWith(homedir()) ? "~" + p.slice(homedir().length) : p);
+    const note = (l) => console.log(GUTTER + l);
+    console.log("\n" + GUTTER + dim("Collecting gu's logs (secrets are masked)…"));
+    const bundle = await sb.prepareSupportBundle({ version: REPL_VERSION });
+    const where = tilde(bundle.file);
+    const fallback = (opts = {}) => sb.supportFallbackLines({ file: where, ...opts });
+    console.log("");
+    note(bold("What would be sent") + dim(`  · ${sb.bundleSize(bundle)} zip`));
+    for (const row of sb.bundleSummaryLines(bundle)) note("  " + dim(row));
+    note(dim("saved at ") + dim(where));
+    console.log("");
+    // The answers are typed in the input row, which empties after Enter: echo them so the
+    // scrollback still shows what was sent.
+    const typedMessage = (await ask("What went wrong? (Enter to skip): ")).trim();
+    const message = sb.supportMessage(typedMessage);
+    note(dim("what went wrong: ") + (typedMessage || dim("(not said)")));
+    let email = await sb.defaultReplyEmail();
+    const typed = (await ask(`Email for the answer${email ? ` [${email}]` : ""}: `)).trim();
+    if (typed) email = typed;
+    if (!sb.isEmail(email)) {
+      note(yellow("No reply email — the support team could not answer you. Nothing sent."));
+      for (const l of fallback()) note(dim(l));
+      console.log("");
+      return;
+    }
+    note(dim("answer to: ") + email);
+    // A question never wraps: at 80 columns over SSH the picker hint goes on a row of its own.
+    const q = `Send it to the gu support team (${sb.SUPPORT_EMAIL})?`;
+    const hint = `(${PICK_HINT}):`;
+    console.log("");
+    if (3 + q.length + 2 + hint.length < width) console.log(dim(`   ${q}  ${hint}`));
+    else console.log(dim(`   ${q}\n   ${hint}`));
+    const go = await pickFromList(["Yes — send the request and the logs", "No — keep the zip, I will email it myself"], 0);
+    if (go !== 0) {
+      for (const l of fallback()) note(dim(l));
+      console.log("");
+      return;
+    }
+    note(dim("Sending…"));
+    const r = await sb.sendSupportRequest({ base: sb.supportApiBase(), message, email, version: REPL_VERSION, zip: bundle.zip });
+    if (!r.ok) {
+      const [first, ...rest] = fallback({ why: r.why });
+      note(yellow(first));
+      for (const l of rest) note(l);
+      console.log("");
+      return;
+    }
+    note(accent(`✓ Sent — your reference is ${bold(r.ref)}`));
+    note(dim(`the answer goes to ${email}`));
+    if (r.uploaded) note(dim(`logs attached · to add more, email ${sb.SUPPORT_EMAIL} with ${r.ref}`));
+    else {
+      note(yellow(`The logs did not go with it (${r.uploadWhy}).`));
+      for (const l of fallback({ ref: r.ref })) note(l);
+    }
+    console.log("");
+  } catch (e) {
+    if (wasPromptCancelled(e)) console.log(dim("   (cancelled — nothing sent)\n"));
+    else console.log(GUTTER + red(`couldn't finish — ${e?.message ?? e}`) + "\n");
+  } finally {
+    supportBusy = false;
+    if (barPinned()) paintBar();
+  }
+}
+
 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).
@@ -11744,12 +11869,12 @@ async function localScaffoldState() {
 /** Print the startup scaffold line — deferred while a turn owns the transcript. */
 function announceScaffold() {
   if (!scaffoldNotice || following) return;
-  const { kind, text, steps } = scaffoldNotice;
+  const { kind, text } = scaffoldNotice;
   scaffoldNotice = null;
   if (kind === "link") {
     // A setup step, said calmly (#292): the headline, then the steps on their own lines.
+    // ONE yellow line (#222): the steps are the token question's own, behind "?" there.
     console.log(GUTTER + yellow("! " + text));
-    for (const s of steps ?? []) console.log(GUTTER + "  " + dim(s));
   } else {
     console.log(GUTTER + (kind === "ok" ? accent("✓ " + text) : kind === "warn" ? yellow("⚠ " + text) : red("✗ " + text)));
   }
@@ -11780,13 +11905,15 @@ async function ensureTokenForTurn() {
  * (Esc does nothing), one Backspace clears the default for a paste, and a valid token turns the
  * row back into ">> ". → true once a token is saved.
  */
-async function askForCliToken(ct, dir, { why = "", overLimit = false } = {}) {
+async function askForCliToken(ct, dir, { why = "", overLimit = false, short = "" } = {}) {
   console.log("");
   tokenPromptActive = true; // Ctrl+C now quits gu (see onInterrupt) — task #17
+  tokenQuestionOpen = true;
   try {
-    return await askForCliTokenInner(ct, dir, why, overLimit);
+    return await askForCliTokenInner(ct, dir, why, overLimit, short);
   } finally {
     tokenPromptActive = false;
+    tokenQuestionOpen = false;
   }
 }
 
@@ -11804,7 +11931,7 @@ function quitFromTokenPrompt() {
   process.exit(0);
 }
 
-async function askForCliTokenInner(ct, dir, why, overLimit = false) {
+async function askForCliTokenInner(ct, dir, why, overLimit = false, short = "") {
   const hostedBase = await tokenHostedBase();
   const pk = ct.publicKey();
   const site = ct.siteUrl();
@@ -11816,6 +11943,7 @@ async function askForCliTokenInner(ct, dir, why, overLimit = false) {
     hostedBase,
     why,
     overLimit, // #209: the computer limit, not a missing plan — no "paste a Pro token"
+    short, // #219: the one short yellow line; the rest is behind "?"
     // #315: a token is only good if THIS computer may use it — renew it from here (the server then
     // says how much free time the computer has), save what came back, and run the licence rule.
     accept: async (token) => {
@@ -11893,7 +12021,7 @@ async function askTokenAtStart() {
       return;
     }
   }
-  await askForCliToken(ct, dir, { why: d.why, overLimit: d.reason === "over-limit" });
+  await askForCliToken(ct, dir, { why: d.why, overLimit: d.reason === "over-limit", short: d.short ?? "" });
 }
 /** The token refresh started at launch — askTokenAtStart waits for it (see there). */
 let startupTokenRefresh = null;
@@ -14220,6 +14348,15 @@ async function main() {
     process.exit(1);
   }
   console.log(wrapGutter("Ask about this repo. Type / to see commands (Tab completes). Ctrl-C aborts a running turn.", dim) + "\n");
+  // #221: gu runs, but its own npm folder is not on PATH (npm skipped the postinstall that adds it).
+  try {
+    const { pathNoticeLine } = await import("./env-check.mjs");
+    const note = pathNoticeLine({ prefix: globalPrefixOf(DIR), pathEnv: process.env.PATH || "", ci: Boolean(process.env.CI) });
+    if (note) console.log(wrapGutter(note, yellow) + "\n");
+  } catch {
+    /* a hint, never a reason to fail to start */
+  }
+  supportHintAtExit = false; // started: from here /support is in the command list
   // Ask whether anything is newer — in the BACKGROUND, so a slow registry never delays the
   // prompt (task #181). The answer paints itself onto the separator row when it arrives, and
   // the interval keeps a long-lived session honest. unref'd: a pending timer must not be the
@@ -14788,6 +14925,10 @@ async function main() {
       await runClearLogs();
       continue;
     }
+    if (line === "/support") {
+      await runSupport();
+      continue;
+    }
     if (line === "/budget") {
       // #205: the short terminal version of web-v2's /providers budgets. The server judges Pro,
       // the account email and "has items" (api/src/providers/terminalBudget.ts).

package/install-path.mjs

@@ -21,7 +21,7 @@
  *   - NEVER fail the install. Every path through this file ends in exit 0; npm treats a
  *     postinstall failure as a failed install and the user gets nothing.
  *   - NEVER run on Windows (PATH there lives in the registry, and `gu`'s PowerShell
- *     alias problem is powershell-alias.mjs's job, explicitly interactive).
+ *     alias problem is install.ps1's job (asks once) and `gu-cli fix-powershell`'s, both interactive).
  *   - NEVER touch an rc file twice: the marker pair makes re-runs no-ops.
  *   - Under `sudo npm i -g`, write to the REAL user's home (SUDO_USER) and chown the
  *     file back, or the user's next login shell reads a root-owned rc file.
@@ -30,6 +30,7 @@ import { appendFileSync, existsSync, readFileSync, chownSync, writeFileSync } fr
 import { homedir, platform, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { stableBinDir } from "./env-check.mjs";
 
 const BEGIN = "# >>> gu-cli PATH >>>";
 const END = "# <<< gu-cli PATH <<<";
@@ -121,12 +122,15 @@ function main() {
   const binDir = join(prefix, "bin");
   if (resolve(binDir).startsWith(resolve(tmpdir()))) return; // preflight's throwaway prefix
 
-  const onPath = (process.env.PATH || "").split(":").some((p) => p === binDir);
+  // On PATH under EITHER spelling: Homebrew's npm can report its prefix as the versioned Cellar
+  // folder while PATH holds the stable <brew prefix>/bin — the same folder (#221).
+  const stable = stableBinDir(binDir);
+  const onPath = (process.env.PATH || "").split(":").some((p) => p === binDir || p === stable);
   if (onPath) return;                                  // nothing to fix — most installs
 
   const home = realUserHome();
   const targets = rcFilesFor(home);
-  const block = `${BEGIN}\n# npm's global bin dir was not on PATH; added by @tiens.nguyen/gu-cli postinstall.\nexport PATH="${binDir}:$PATH"\n${END}\n`;
+  const block = `${BEGIN}\n# npm's global bin dir was not on PATH; added by @tiens.nguyen/gu-cli postinstall.\nexport PATH="${stable}:$PATH"\n${END}\n`;
 
   let wrote = null;
   for (const rc of targets) {
@@ -134,12 +138,12 @@ function main() {
   }
 
   if (wrote) {
-    console.log(`gu-cli: added ${binDir} to PATH in ${wrote}.`);
+    console.log(`gu-cli: added ${stable} to PATH in ${wrote}.`);
     console.log(`gu-cli: open a NEW terminal to use \`gu\`, or run this once in the current one:`);
-    console.log(`  export PATH="${binDir}:$PATH"`);
+    console.log(`  export PATH="${stable}:$PATH"`);
   } else if (targets.length === 0) {
-    console.log(`gu-cli: ${binDir} is not on your PATH and no shell profile was found to update.`);
-    console.log(`  export PATH="${binDir}:$PATH"`);
+    console.log(`gu-cli: ${stable} is not on your PATH and no shell profile was found to update.`);
+    console.log(`  export PATH="${stable}:$PATH"`);
   }
 }
 

package/mongo-native.mjs

@@ -246,6 +246,21 @@ export function captureOutput(cmd, args, timeoutMs = 10000) {
   });
 }
 
+/**
+ * Which of Homebrew's output lines are worth showing (#221). A MongoDB install prints ~100 lines
+ * (every library it pours, a mug per bottle) over several minutes; shown whole they bury the one
+ * that matters. Kept: the `==>` stage lines ("Installing mongodb-community", "Downloading…"), what
+ * gu itself prints (`$ brew …`), and anything that looks like a failure or warning.
+ */
+export function brewLineWorthShowing(line) {
+  const l = String(line ?? "").trim();
+  if (!l) return false;
+  if (l.startsWith("$ ")) return true;
+  if (/\b(error|fail(ed|ure)?|warning|cannot|denied|not found|conflict)\b/i.test(l)) return true;
+  if (l.startsWith("==>")) return !/^==> (Pouring|Fetching downloads? for)\b/.test(l);
+  return false;
+}
+
 /**
  * Homebrew steps, one after another, output shown. → true when all succeeded. HOMEBREW_NO_AUTO_UPDATE
  * keeps `brew install` from first updating every formula on the machine — minutes nobody asked for.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.862",
+  "version": "1.0.864",
   "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",
@@ -89,6 +89,9 @@
     "node-version.mjs",
     "clear-state.mjs",
     "support-report.mjs",
+    "env-check.mjs",
+    "support-bundle.mjs",
+    "support-command.mjs",
     "clear-logs.mjs",
     "platform-tools.mjs",
     "job-pools.mjs",