@tiens.nguyen/gu-cli 1.0.792 → 1.0.794

package/gonext_agent_chat.py

@@ -992,6 +992,80 @@ def _web_search_impl(query, max_results=5, searxng_url="",
 # the text still reaches both UIs, the prefix tells them it is a failure, not a reply.
 TURN_FAILED = "__TURN_FAILED__::"
 
+# ANOTHER MODEL STOOD IN (task #343). Reported live: the coding model had a problem, a different
+# model answered, and nothing on screen said so — the turn "worked", only with a model nobody
+# picked. Every place in this file where one model takes over from another now says so with ONE
+# event, a step carrying this prefix and a JSON body, so the terminal can hold it in yellow on the
+# bottom bar. A step, like __RAGSTATE__::, so it rides the job's chunk stream and still arrives
+# when the agent runs on a different machine than the terminal.
+#
+# What is NOT a fallback and must never be reported as one: a retry on the SAME model, and the
+# 429 / 502 exits below — those end the turn as failed, no other model answers.
+MODEL_FALLBACK = "__MODELFALLBACK__::"
+
+
+def _fallback_reason(err) -> str:
+    """Why a model was given up on, in a few words that fit a status bar — never a stack of
+    exception text (an nginx error is a whole HTML page). The status code when there is one,
+    else the kind of failure, else the first line clipped."""
+    if err is None:
+        return ""
+    status = _http_status_of(err)
+    text = str(err)
+    low = text.lower()
+    if status in (401, 403):
+        return f"{status} key refused"
+    if status == 404:
+        return "404 model not found"
+    if status == 429 or "overloaded" in low or "rate limit" in low:
+        return "429 overloaded"
+    if status and status >= 500:
+        return f"{status} server error"
+    if "timed out" in low or "timeout" in low:
+        return "timed out"
+    if "empty response" in low:
+        return "empty reply"
+    if "context" in low and ("length" in low or "window" in low or "too long" in low or "exceed" in low):
+        return "context too large"
+    if "connection" in low or "connect" in low or "refused" in low or "unreachable" in low:
+        return "could not connect"
+    if status:
+        return f"HTTP {status}"
+    first = next((ln.strip() for ln in text.splitlines() if ln.strip()), "")
+    first = re.sub(r"<[^>]+>", " ", first)
+    first = re.sub(r"\s+", " ", first).strip()
+    return first if len(first) <= 48 else first[:47].rstrip() + "…"
+
+
+def _fallback_event(role, from_model, to_model, reason, *, tools=True, answered=True) -> str:
+    """The step text for one fallback. Pure.
+
+      role      "coder" — the coding model was given up on;  "chat" — the chat model was
+      from/to   the model that had the problem, and the one used instead
+      reason    a few words (see _fallback_reason)
+      tools     False when the stand-in answered as a bare chat reply — no files, no commands
+      answered  False when the stand-in failed too: "fell back" is only said when it answered
+    """
+    body = {
+        "role": "chat" if role == "chat" else "coder",
+        "from": str(from_model or "").strip(),
+        "to": str(to_model or "").strip(),
+        "reason": str(reason or "").strip(),
+        "tools": bool(tools),
+        "answered": bool(answered),
+    }
+    return MODEL_FALLBACK + json.dumps(body, ensure_ascii=False)
+
+
+def _report_fallback(role, from_model, to_model, reason, *, tools=True, answered=True) -> None:
+    """Tell the terminal another model stood in. Logged too, so a run log shows it."""
+    _log(
+        f"model fallback: {role} {from_model!r} -> {to_model!r} ({reason or 'no reason'})"
+        f"{'' if tools else ' — no tools'}{'' if answered else ' — it failed too'}"
+    )
+    _emit({"type": "step", "text": _fallback_event(
+        role, from_model, to_model, reason, tools=tools, answered=answered)})
+
 
 class _AgentConfigError(RuntimeError):
     """Deterministic setup error (e.g. wrong model name/URL). Not retryable and not
@@ -1473,6 +1547,24 @@ def _resolve_coding_target(agent_base_url, agent_model_id, raw_coding_base, raw_
     return agent_base_url, agent_model_id
 
 
+def _coder_fell_back_to_chat(agent_base_url, raw_coding_base, resolved_base) -> bool:
+    """Did _resolve_coding_target give the chat model a job a DIFFERENT coding server was chosen
+    for? Pure. False when no coder is set, and false for a coder on the chat model's own server
+    with no name — that is "use the chat model", chosen, not a fallback."""
+    raw = (raw_coding_base or "").rstrip("/")
+    if not raw or raw == (agent_base_url or "").rstrip("/"):
+        return False
+    return (resolved_base or "").rstrip("/") != raw
+
+
+def _coder_label(model_id, base_url) -> str:
+    """What to call a coder on the bar: its name, or — when it never told us one — its host."""
+    if (model_id or "").strip():
+        return model_id.strip()
+    host = re.sub(r"^[a-z]+://", "", (base_url or "").strip(), flags=re.I).split("/")[0]
+    return host or "the coding model"
+
+
 def _coding_backend_flags(backend):
     """Everything the resolved backend decides, derived in ONE place (task #117 → #123).
 
@@ -2943,6 +3035,7 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str,
         targets.append((fallback_base_url, fallback_model_id, fallback_api_key or api_key))
 
     last_err = None
+    first_err = None
     for i, (b, mid, key) in enumerate(targets):
         emitted_here = False
 
@@ -2981,12 +3074,22 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str,
             last_err = RuntimeError(f"{mid} returned an empty response")
         except Exception as e:  # noqa: BLE001
             last_err = e
+        if i == 0:
+            first_err = last_err  # why the model that was ASKED gave nothing
+        else:
+            # The stand-in did not answer either (#343) — take back "it answered".
+            _report_fallback("chat", targets[0][1], mid, _fallback_reason(first_err),
+                             tools=False, answered=False)
         if emitted_here:
             # Part of THIS attempt's answer already streamed to the user — don't
             # silently splice a DIFFERENT model's output after a partial one.
             break
         if i + 1 < len(targets):
             nb, nmid, _ = targets[i + 1]  # the model we're about to try next
+            # SAID AT THE SWITCH (#343), before the stand-in streams: a step that arrived after
+            # its answer would reopen the reasoning block under the reply. Corrected just above
+            # if it fails too.
+            _report_fallback("chat", mid, nmid, _fallback_reason(last_err), tools=False)
             _log(f"plain reply: {mid} @ {b} failed ({last_err}); "
                  f"falling back to {nmid} @ {nb}")
     # Every target failed or returned nothing — raise rather than return a sentinel
@@ -7671,6 +7774,11 @@ def run_agent_chat(cfg):
         agent_base_url, agent_model_id, raw_coding_base, raw_coding_model,
         agent_api_key=agent_api_key, coding_api_key=coding_api_key,
     )
+    # A coder WAS chosen and the chat model is doing its work (#343): its server would not say
+    # which model it serves. Said when the agent path starts — a plain chat turn does no coding,
+    # so there is nothing to have fallen back from.
+    _coder_unresolved = _coder_fell_back_to_chat(
+        agent_base_url, raw_coding_base, coding_base_url)
     # Task #108: an OpenAI-compatible coder REQUIRES an explicit model name (its
     # /v1/chat/completions needs a `model` id, and we won't silently reuse the MLX chat
     # model's name against a cloud endpoint). Fail with a clear, actionable message.
@@ -8490,6 +8598,9 @@ def run_agent_chat(cfg):
     # Agent path — from here all step events go into <think>.
     _log("router: agent (HTTP tool use needed)")
     _emit({"type": "step", "text": "Choosing a tool…"})
+    if _coder_unresolved:
+        _report_fallback("coder", _coder_label(raw_coding_model, raw_coding_base), agent_model_id,
+                         "its server named no model")
 
     # Prepend explicit tool instructions so small models pick the right tool, never
     # fabricate URLs/responses, and always terminate with final_answer().
@@ -11293,12 +11404,19 @@ def run_agent_chat(cfg):
                 # No usable tool output (e.g. every step's code failed to parse).
                 # Don't dead-end on a canned apology — answer from the conversation.
                 _log("max-steps fallback → plain reply over conversation")
+                # Every step was unusable and the chat model now answers from the conversation
+                # alone (#343). Said BEFORE it streams — a step after the answer would reopen
+                # the reasoning block under it — and corrected below if it fails too.
+                _report_fallback("coder", coding_model_id, agent_model_id,
+                                 "no usable step", tools=False)
                 try:
                     text = _plain_reply(
                         messages, agent_base_url, agent_api_key, agent_model_id
                     ).strip()
                 except Exception as e:  # noqa: BLE001
                     _log(f"plain-reply fallback error: {e}")
+                    _report_fallback("coder", coding_model_id, agent_model_id,
+                                     "no usable step", tools=False, answered=False)
                     text = ""
                 if not text:
                     text = ("I couldn't complete that within the step budget. Please "
@@ -13427,10 +13545,16 @@ def run_agent_chat(cfg):
         # answer from the conversation rather than surfacing a raw error to the user —
         # but only when the fallback ACTUALLY has something useful to say.
         _log(f"agent error: {e} — degrading to plain reply")
+        # The tool-capable loop failed and the chat model answers instead, with no tools (#343).
+        # Said BEFORE it streams; corrected in the except if it fails too.
+        _report_fallback("coder", coding_model_id, agent_model_id, _fallback_reason(e), tools=False)
         try:
             fallback = _plain_reply(messages, agent_base_url, agent_api_key, agent_model_id).strip()
         except Exception as e2:  # noqa: BLE001
             _log(f"plain-reply degrade error: {e2}")
+            # The stand-in failed too (#343): say THAT, never "fell back".
+            _report_fallback("coder", coding_model_id, agent_model_id, _fallback_reason(e),
+                             tools=False, answered=False)
             # Nothing useful to say — re-raise the ORIGINAL (more relevant) agent
             # failure so this becomes a genuine job failure: a red error the REPL/web
             # already handle correctly, NOT persisted to conversation history. Emitting

package/gu-cli.mjs

@@ -134,6 +134,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 fix-path                          # macOS/Linux: put npm's global bin folder on PATH
+                                               #   (what the install does, if npm skipped it)
   gu-cli fix-powershell [--check]          # Windows: drop PowerShell's built-in \`gu\` alias
                                                #   (it is Get-Unique and shadows this CLI)
   gu-cli rag plan [path]                   # is RAG worth it here? files/chars/chunks → estimated index time
@@ -1054,6 +1056,42 @@ if (args[0] === "token-usage" || args[0] === "tokens") {
   process.exit(0);
 }
 
+// `gu-cli fix-path` — put npm's global bin folder on PATH (task #333). The same repair the
+// postinstall does, for when npm did not run it: run through install-path.mjs itself, with the
+// prefix worked out from where this file is installed, so there is one implementation.
+if (args[0] === "fix-path") {
+  if (process.platform === "win32") {
+    console.log("  Nothing to fix here — on Windows npm's folder is on PATH through the registry.");
+    console.log("  If `gu` is not found in PowerShell: gu-cli fix-powershell");
+    process.exit(0);
+  }
+  const { globalPrefixOf } = await import("./install-path.mjs");
+  const { fileURLToPath } = await import("node:url");
+  const { dirname, join } = await import("node:path");
+  const here = dirname(fileURLToPath(import.meta.url));
+  const prefix = globalPrefixOf(here);
+  if (!prefix) {
+    console.log(`  This gu is not a global npm install (${here}) — there is no PATH to fix.`);
+    process.exit(0);
+  }
+  const binDir = join(prefix, "bin");
+  if ((process.env.PATH || "").split(":").includes(binDir)) {
+    console.log(`  Nothing to fix — ${binDir} is already on PATH.`);
+    process.exit(0);
+  }
+  const { spawnSync } = await import("node:child_process");
+  const { CI: _ci, ...env } = process.env;
+  const r = spawnSync(process.execPath, [join(here, "install-path.mjs")], {
+    encoding: "utf8",
+    env: { ...env, npm_config_prefix: prefix, npm_config_global: "true" },
+  });
+  const said = `${r.stdout ?? ""}${r.stderr ?? ""}`.trim();
+  // It prints only when it wrote something. Silence means the line is already in the profile
+  // and this terminal simply predates it.
+  console.log(said || `  Your shell profile already adds ${binDir} to PATH — open a new terminal.`);
+  process.exit(r.status ?? 0);
+}
+
 // `gu-cli fix-powershell` — drop PowerShell's built-in `gu` alias so the command works there.
 // ASKS FIRST and never runs as part of an install: a PowerShell profile is the user's file, and
 // a CLI that edits it unannounced is one that surprises people. --check only reports.

package/gu-repl.mjs

@@ -110,6 +110,8 @@ import {
   workspaceScopeWarning,
   isLocalApiBase,
   modeRow,
+  nothingToAnswerWith,
+  NO_MODEL_LINES,
   resizeRepaintTarget,
   workspaceSyncQuestion,
   workspaceSyncLabel,
@@ -136,6 +138,11 @@ import { unapprovedProjectServers } from "./mcp-command.mjs";
 import { readHooks } from "./hooks-config.mjs";
 import { readSkillSource, sourceLabel, SKILL_SOURCE_KEY } from "./skill-source.mjs";
 import { codingBannerLabel, isOllamaCloudUrl, SECRET_KEY_HINT } from "./coding-key-prompt.mjs";
+import { thoughtPrintSeq } from "./terminal-layout.mjs";
+import {
+  MODELFALLBACK_PREFIX, fallbackAfterTurn, fallbackHistoryLine, fallbackNotice, keyMissingNotice,
+  parseModelFallback,
+} from "./model-fallback.mjs";
 import { codingChoiceTags, coderDisplayName, coderWhere, whereOfActiveCoder } from "./coding-choice-tags.mjs";
 import { IMAGE_NEEDS_CLAUDE, coderTakesImagesFor, clipboardImageToFile, fitImageNotice, imageMarkersForDisplay, createImageStore, imagePasteKey, imagePathFromPaste, isClaudeCoderUrl, isImagePasteKey, storeImageFile } from "./image-paste.mjs";
 import {
@@ -665,6 +672,26 @@ if (!workerKey || !apiBase) {
         input: process.stdin,
         output: process.stdout,
       });
+      // Ctrl+C AND Ctrl+D MUST END THE RUN CLEANLY (task #333). readline swallows Ctrl+C in raw
+      // mode: with no listener it only pauses, the pending question never settles, and Node
+      // exits with "Warning: Detected unsettled top-level await" and a stack line — at the
+      // models menu of a first install. It also meant the "stopped during <step>" record
+      // (markInterruptedOnExit listens on the PROCESS) never fired for a Ctrl+C typed here.
+      let rl0Done = false;
+      const { stopFirstRun } = await import("./first-run-steps.mjs");
+      const endFirstRun = (reason) =>
+        stopFirstRun({
+          reason,
+          hasProcessListener: process.listenerCount("SIGINT") > 0,
+          emitSigint: () => process.emit("SIGINT"),
+          log: (t) => console.log(t),
+          exit: (code) => process.exit(code),
+          style: { yellow, dim },
+        });
+      rl0.on("SIGINT", () => endFirstRun("interrupt"));
+      rl0.on("close", () => {
+        if (!rl0Done) endFirstRun("eof");
+      });
       const ask0 = (q) =>
         new Promise((res) => rl0.question(accent(q), (a) => res(String(a || ""))));
       let typed = "";
@@ -682,7 +709,7 @@ if (!workerKey || !apiBase) {
         const {
           probeMachine, askMode, runClientExpertSetup, loadState, saveState,
         } = await import("./client-expert-run.mjs");
-        const { clientExpertAvailable, parseLicenseFlag, resolveFirstRunMode, promptForLicenseToken } =
+        const { clientExpertAvailable, parseLicenseFlag, resolveFirstRunMode, licenseUnverifiedLine, promptForLicenseToken } =
           await import("./client-expert-setup.mjs");
         const machine0 = await probeMachine();
         const gate0 = clientExpertAvailable({ workerEnvExists: false, ...machine0 });
@@ -701,7 +728,9 @@ if (!workerKey || !apiBase) {
           // (task #13). Format is checked first (no network), then offline signature, then the
           // live API. Empty Enter declines → the private default. Unreachable API still opens
           // the menu (soft licence: an outage never blocks a paid user).
+          const { setupPrompts: tokenPrompts } = await import("./setup-prompts.mjs");
           const pick = await promptForLicenseToken(ask0, licenseToken0, {
+            askSecret: tokenPrompts(rl0, { style: accent }).askSecret,
             validateOpts: {
               hostedBase: String(process.env.GU_TOKEN_API_BASE ?? "").trim() || DEFAULT_API_BASE,
             },
@@ -710,7 +739,7 @@ if (!workerKey || !apiBase) {
           if (pick.declined || !pick.token) {
             plan0 = resolveFirstRunMode({ licenseToken: "", expertAvailable: gate0.available });
           } else if (pick.result && pick.result.reason === "unverified") {
-            console.log(dim("\n  Couldn't reach the license server to confirm the token — showing the menu anyway."));
+            console.log(dim("\n  " + licenseUnverifiedLine(pick.result.detail)));
           }
         }
         let mode0;
@@ -782,6 +811,7 @@ if (!workerKey || !apiBase) {
           typed = (await ask0("  worker key (or Enter to sign in): ")).trim();
         }
       } finally {
+        rl0Done = true;
         rl0.close();
       }
       if (stopAfterSetup) {
@@ -1599,6 +1629,9 @@ let imageNoticeTimer = null;
 // its own model is unset, and choosing that model (/agent-model, /embed-model, /setup, or the
 // API seeding one) clears only that one.
 let agentMissing = false; // no agent model chosen → agent falls back to the coding model
+// NO MODEL AT ALL (#99): neither an agent model nor a coder — there is no server to send a
+// question to. Seeded from the startup payload; re-checked before a question is refused.
+let noModelAtAll = false;
 let embedMissing = false; // no embed model chosen → RAG is off until /embed-model picks one
 // One footer row; the two halves are independent so a model that IS set is never named.
 // ONE SHORT ROW EACH (#317): joined, they ran past 80 columns and were cut mid-word.
@@ -1607,6 +1640,28 @@ const missingNoticeRows = () => [
   ...(embedMissing ? ["⚠ no embed model — RAG is off · /embed-model"] : []),
 ];
 
+// ANOTHER MODEL STOOD IN (task #343). The agent reports it as a __MODELFALLBACK__:: step; it is
+// held here and shown in YELLOW on the bar — from the moment it happens, through the rest of the
+// turn, and on while it stays true: until a turn is answered with no fallback (the model works
+// again) or another model is picked. `turnFallback` is the one reported during the CURRENT turn.
+let modelFallback = null;
+let turnFallback = null;
+function setModelFallback(fb) {
+  modelFallback = fb;
+  if (barPinned()) paintBar();
+}
+// Its rows: the reported fallback, and — the one fallback the agent cannot report, because it
+// never sees the coder the API dropped — a coding model with no API key (task #222).
+const fallbackNoticeRows = () => {
+  const width = process.stdout.columns || 80;
+  return [
+    ...(modelFallback ? [fallbackNotice(modelFallback, { width, gutter: GUTTER })] : []),
+    ...(codingKeyMissingKnown === true
+      ? [keyMissingNotice({ coder: activeCodingModelId(), width, gutter: GUTTER })]
+      : []),
+  ];
+};
+
 // #307: the calm note after a quick change of mind — dim, not the ⚠ orange of a warning, and in the
 // bar rather than the transcript (which the whole point is to leave untouched).
 let stopNotice = "";
@@ -2277,7 +2332,7 @@ async function refreshCliToken() {
     let state = await ct.readState(dir);
     const now = new Date();
     const noticeNow = () =>
-      ct.barNotice({ token: state.token, publicKeyB64: pk, mode, now: new Date(), attempted: Boolean(state.lastAttemptAt), site });
+      ct.barNotice({ token: state.token, publicKeyB64: pk, mode, now: new Date(), attempted: Boolean(state.lastAttemptAt), site, why: state.lastAttemptWhy ?? "" });
     tokenNotice = noticeNow();
 
     const early = Boolean(tokenNotice) && !startupRenewDone;
@@ -2296,7 +2351,8 @@ async function refreshCliToken() {
       // A reply is only kept if it checks out here — a proxy's HTML page or another server's token
       // must not replace a good one.
       const fresh = r.ok && ct.verifyCliToken(r.token, pk).ok ? r.token : state.token;
-      state = { token: fresh, lastAttemptAt: now.toISOString() };
+      // WHY it failed is kept with the attempt, for the bar (#102).
+      state = { token: fresh, lastAttemptAt: now.toISOString(), lastAttemptWhy: r.ok ? "" : String(r.why ?? "") };
       await ct.writeState(dir, state).catch(() => {});
       tokenNotice = noticeNow();
     }
@@ -2568,7 +2624,9 @@ const footerRows = () =>
         ? dim(clipVisible(stopNotice, (process.stdout.columns || 80) - visibleLen(GUTTER) - 1))
         : "",
     // Task #14: the skipped-setup warning — persistent (not a timed notice), red, its own row.
-    missing: missingNoticeRows().map((r) => red(r)),
+    // …then the fallback rows (#343), YELLOW: a different model is doing the work — a warning,
+    // where the red rows above mean something is not set up at all.
+    missing: [...missingNoticeRows().map((r) => red(r)), ...fallbackNoticeRows().map((r) => yellow(r))],
   });
 // An ask()'s hint lines (#305), drawn in yellow under its input while it waits. Plain text.
 let askHint = [];
@@ -3328,7 +3386,7 @@ const thoughtWidth = () =>
  * Progress recedes and the answer is the only full-bright thing on screen — a page of bright
  * reasoning per step would bury the deliverable it is supposed to lead up to.
  */
-function printThoughtBlock(raw, before) {
+function printThoughtBlock(raw, before, { gap = false } = {}) {
   if (!sessionShowThought) return false;
   const prose = thoughtProse(raw);
   if (!prose) return false; // a bare tool label or pure code — not what anyone means by a thought
@@ -3375,8 +3433,14 @@ function printThoughtBlock(raw, before) {
     }
     // Scrolled out of the buffer — fall through and print a new block rather than lose it.
   }
-  process.stdout.write(rows.map((r) => GUTTER + dim(r)).join("\n") + "\n");
-  // Record where it landed. Measured AFTER the write so a trim during it cannot skew the
+  // ONE EMPTY LINE ABOVE A NEW THOUGHT (#344) when the row above it is not already blank.
+  // Reported with a screenshot: "The download is moving…" sat directly under "✓ Command finished
+  // → python3 -c …" and read as that command's OUTPUT — and under a bright "✗ Command failed" row,
+  // as its error text. A thought is printed when its step's reasoning ends, BEFORE that step's
+  // tools report: it introduces what comes next, it does not belong to the row above. Only for a
+  // NEW block — a continuation is merged into the previous one above and never gets here.
+  process.stdout.write(thoughtPrintSeq(rows.map((r) => GUTTER + dim(r)), { gap }));
+  // Record where it landed. The blank is above `from`, so the block is still exactly its rows. Measured AFTER the write so a trim during it cannot skew the
   // range: the last completed line is length-2 (the final entry is the still-open line).
   const endAbs = transcript.dropped() + transcript.length() - 2;
   thoughtBlocks.push({ from: endAbs - rows.length + 1, to: endAbs, prose, collapsed: true });
@@ -6692,6 +6756,7 @@ async function useCoderInThisFolder({ ps, rows, beforeChoices, url, host, locali
     console.log(GUTTER + dim("restart it with `gu api restart`, then add that provider again.\n"));
   }
   sessionCodingModel = offered.id;
+  setModelFallback(null); // #343
   sessionCodingLabel = model;
   sessionCodingUrl = url;
   // …and the host the bar puts in front of it (#263): left alone, the PREVIOUS coder's
@@ -6831,6 +6896,7 @@ async function chooseModel() {
   // Empty override means "use the account default" — so don't send an override when the
   // user picks the default (keeps the payload clean and lets a later default change win).
   sessionCodingModel = chosen.id === def ? "" : chosen.id;
+  setModelFallback(null); // #343: the warning named the coder that was just replaced
   // Remember the friendly name for the token footer, which should never show a raw
   // "<kind>::<model>" wire id.
   sessionCodingLabel = chosen.id === def ? "" : chosen.model;
@@ -10453,8 +10519,13 @@ async function tryStartLocalApi() {
     );
     const version = versions.pop();
     if (!version) return false; // nothing installed — setup never got that far
+    const portBefore = ce.LOCAL_API_PORT;
     await ce.startLocalApi({ apiDir: join(base, version) });
-    return (await ce.waitForApi({ timeoutMs: 30_000 })).ok;
+    const up = (await ce.waitForApi({ timeoutMs: 30_000 })).ok;
+    // The port can move here (#337: the saved one now belongs to another program). worker.env
+    // was re-pointed; THIS terminal still holds the old address until it reads the file again.
+    if (ce.LOCAL_API_PORT !== portBefore) reloadWorkerEnv();
+    return up;
   } catch {
     return false;
   }
@@ -10786,6 +10857,22 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   // from the gu service with it. Asked for HERE, before anything is sent, with the steps — rather
   // than letting the turn fail and leaving the user to decode why.
   if (!skipAsk && !(await ensureTokenForTurn())) return;
+  // NOTHING TO ANSWER WITH (#99). On an account with no models at all the question used to be
+  // sent, sat at "queued — waiting for the worker…", and ended in "✗ Job not found." — the job
+  // had no model server in it, so nothing could read or claim it. Say what is missing instead.
+  // Asked again first: /model or /agent-model may have set one since gu started.
+  if (!skipAsk && noModelAtAll) {
+    try {
+      noModelAtAll = nothingToAnswerWith((await fetchAgentPayload([{ role: "user", content: "." }]))?.payload);
+    } catch {
+      /* cannot ask → keep what startup saw */
+    }
+    if (noModelAtAll) {
+      for (const l of NO_MODEL_LINES) console.log(GUTTER + (l === NO_MODEL_LINES[0] ? red("✗ ") + l : dim("  " + l)));
+      console.log("");
+      return;
+    }
+  }
   inputVisible = false; // the frozen zone shows an empty prompt for the duration (#141)
   // Something on screen from the FIRST moment (task #140): Enter has just wiped the bar, and
   // the next thing to draw itself is the turn's ticker — which stays silent until the daemon
@@ -11010,7 +11097,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     if (heldThought === null) return;
     const raw = heldThought;
     heldThought = null;
-    if (printThoughtBlock(raw, onContent)) lastWasBlank = false;
+    if (printThoughtBlock(raw, onContent, { gap: !lastWasBlank })) lastWasBlank = false;
   };
   let hoverRow = -1; // last mouse viewport row (from motion events) → highlight when it's on the thought line
   let thoughtRow = -1; // absolute viewport row of the thought line (line 1), learned via \x1b[6n
@@ -11435,10 +11522,13 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   // changed since is the VOLUME: a long turn now prints dozens of bullets interleaved with
   // collapsed thought prose, and with no blanks anywhere the two run together into a wall.
   //
-  // Above rather than below, for two reasons: a trailing blank would collide with the seam the
-  // caller owns before the bright answer (LINE_SPACING), and leading the group means the
-  // thought prose that FOLLOWS a bullet still sits tight against it — which is right, since
-  // that prose is the bullet's own reasoning, not the next step.
+  // Above rather than below: a trailing blank would collide with the seam the caller owns
+  // before the bright answer (LINE_SPACING).
+  //
+  // A THOUGHT GETS THE SAME BLANK ABOVE IT (#344, see printThoughtBlock). This comment used to say
+  // the prose after a bullet "sits tight against it — which is right, since that prose is the
+  // bullet's own reasoning". It is not: the thought is printed when the NEXT step's reasoning
+  // ends, so glued under "Command finished → …" it read as that command's output.
   //
   // `lastWasBlank` makes it idempotent: nothing doubles a blank that is already there.
   const openBullet = () => {
@@ -11459,7 +11549,10 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
     const at = thoughtBlocks.indexOf(stepGroup);
     if (at < 0) return false; // dropped from the registry (it is capped): no longer ours to rewrite
     for (let i = at + 1; i < thoughtBlocks.length; i++) {
-      if (thoughtBlocks[i].from !== end + 1) return false;
+      // Directly under, or under the ONE blank a thought now opens with (#344) — the look-up
+      // group must stay open across it, or every thought would start a new counted row.
+      const step = thoughtBlocks[i].from - end;
+      if (step !== 1 && step !== 2) return false;
       end = thoughtBlocks[i].to;
     }
     return end === transcriptTail();
@@ -11562,6 +11655,18 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
         lastContentAt = Date.now();
         continue;
       }
+      // Task #343: another model took over. Swallowed from the action list — it goes on the
+      // BAR, now, in yellow — and the turn leaves one line about it once it has ended (see the
+      // caller), so a fallback that lasted a single step can still be found afterwards.
+      if (line.startsWith(MODELFALLBACK_PREFIX)) {
+        const fb = parseModelFallback(line);
+        if (fb) {
+          turnFallback = fb;
+          setModelFallback(fb);
+        }
+        lastContentAt = Date.now();
+        continue;
+      }
       // A fence opening starts a fresh step's raw stream → reset the harvested Thought
       // so the blinking line doesn't carry last step's clause into this one.
       if (isFenceLine(line)) {
@@ -11575,7 +11680,7 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
           // says what it intends, then the actions it took appear under it.
           if (!REPL_VERBOSE && stepThought.trim() && !stepHasCode(stepThought)) {
             heldThought = stepThought; // #45: decided by the next line — see releaseHeldThought
-          } else if (printThoughtBlock(stepThought, onContent)) {
+          } else if (printThoughtBlock(stepThought, onContent, { gap: !lastWasBlank })) {
             lastWasBlank = false;
           }
           stepThought = "";
@@ -12274,6 +12379,7 @@ async function main() {
         // private (task #13); empty Enter declines to the private default.
         const { DEFAULT_API_BASE } = await import("./device-login.mjs");
         const pick1 = await promptForLicenseToken(ask, licenseToken1, {
+          askSecret,
           validateOpts: {
             hostedBase: String(process.env.GU_TOKEN_API_BASE ?? "").trim() || DEFAULT_API_BASE,
           },
@@ -12503,6 +12609,7 @@ async function main() {
     // the local setup answers — OR them in, never clear a local "missing" on a maybe, because
     // private mode's local API can itself be unconfigured.
     if (p.agentMissing === true) agentMissing = true;
+    noModelAtAll = nothingToAnswerWith(p);
     if (p.ragEnabled !== true) embedMissing = true;
     // A RESTORED PICK MUST STILL EXIST. The stored id names a model on the box this folder was
     // last pointed at — and the box can change (`/model` → change the Ollama server), a model
@@ -12596,7 +12703,14 @@ async function main() {
         // Task #136/#154: mode changes WHERE things run — too important to leave implicit.
         // The precedence lives in modeRow() with its tests; see the note there.
         ...(() => {
-          const m = modeRow({ clientExpert: isClientExpert(), clientMode: clientModeBanner });
+          const m = modeRow({
+            clientExpert: isClientExpert(),
+            clientMode: clientModeBanner,
+            modelUrls: [p.agentBaseURL],
+            // The coder IN USE in this folder, not the account default (the raw payload field
+            // is the default only — key-choice-regression.test.mjs).
+            coderWhere: activeCoderWhere,
+          });
           if (!m) return [];
           const name = m.label === "client expert" ? accent(m.label + " ") : m.label + " ";
           return [lbl("mode") + name + dim(m.detail)];
@@ -12693,6 +12807,8 @@ async function main() {
                 confirm: (q, defYes) => askYesNo(q, defYes),
                 // A client installs ONLY the framework — never mlx-lm/hf.
                 modelHost: clientModeBanner ? false : undefined,
+                // The yes two lines up IS the answer — do not ask the same thing again (#333).
+                agreed: ["agentLibs"],
               });
               // The worker reads worker.env ONCE at startup, so a daemon that is already
               // running still has the OLD python — the packages would look "not installed"
@@ -13294,6 +13410,7 @@ async function main() {
     if (line === "/agent-model") {
       await chooseAgentModel();
       agentMissing = false; // Task #14: an agent model was just chosen → clear its warning
+      setModelFallback(null); // #343: so is the stand-in a fallback warning named
       continue;
     }
     if (line === "/embed-model") {
@@ -13645,6 +13762,7 @@ async function main() {
       // #323: priced by the coder this turn STARTS on — a /model switch afterwards must not put
       // another model's price on it.
       const turnCoder = { url: activeCodingUrl(), model: activeCodingModelId() };
+      turnFallback = null; // #343: nothing has fallen back in THIS turn yet
       if (reattach) console.log(GUTTER + dim("following the turn that was running when the connection went…\n"));
       const turn = await runAgentTurn(history, reattach ? { attachJobId: reattach.jobId, ownJob: true } : {});
       // NOT SENT (licence block, or the token prompt declined): runAgentTurn already said so.
@@ -13659,6 +13777,15 @@ async function main() {
       // Detached: the agent keeps running on the worker, so the question is neither answered
       // nor stopped — leave it untagged, and say nothing contradicting "the job keeps running".
       if (detached) continue;
+      // #343: the bar after this turn — a fallback reported in it stays; an answered turn with
+      // none means the model works again and the warning goes; a failed or stopped turn proves
+      // nothing and leaves it.
+      const fellBack = turnFallback;
+      setModelFallback(fallbackAfterTurn({
+        current: modelFallback,
+        reportedThisTurn: fellBack,
+        answered: Boolean(answer) && !answer.startsWith(TURN_FAILED_PREFIX),
+      }));
       // Feed the bottom bar's token row (task #104). Assigned for EVERY turn — including one
       // that ended without an answer — so the row never shows a stale count from an older
       // turn. It replaces the print-once-per-turn footer that used to live here: the bar is
@@ -13688,6 +13815,7 @@ async function main() {
           failures: noteTaskFailure(taskLine, classifyTurnFailure(_failText)),
           authored: true,
         });
+        if (fellBack) printFallbackLine(fellBack);
       } else if (answer) {
         noteTaskSuccess();
         history.push({ role: "assistant", content: answer });
@@ -13731,6 +13859,9 @@ async function main() {
           // builder, so a change to the block's shape can no longer leave this behind.
           registerCopyBlock(block.rows, plain, 1);
         }
+        // #343: the turn's own record of the fallback, under its answer — the bar's row can be
+        // gone by the next turn, and the scrollback is where "which model wrote this?" is asked.
+        if (fellBack) printFallbackLine(fellBack);
       } else {
         // A turn that ended WITHOUT an answer (Ctrl+C cancel, or an abort/failure) must not
         // silently launch another turn. Any keystrokes the user typed DURING the dead turn
@@ -13780,6 +13911,12 @@ async function main() {
   process.exit(0);
 }
 
+/** One yellow line in the transcript saying which model stood in for which (task #343). */
+function printFallbackLine(fb) {
+  const rows = wrapBlock(fallbackHistoryLine(fb), GUTTER, process.stdout.columns || 80);
+  console.log(rows.map((r) => GUTTER + yellow(r)).join("\n") + "\n");
+}
+
 /**
  * Give the screen back to the shell with its prompt RIGHT UNDER the last output (#314). unpinBar()
  * parks the caret at the zone's top row, which is where the shell then printed its prompt: seven