@tiens.nguyen/gu-cli 1.0.729 → 1.0.731

package/full-log-command.mjs

@@ -0,0 +1,219 @@
+/**
+ * `gu full-log on|off|status [account]` and `/full-log` in the terminal (task #250) — ONE code path.
+ *
+ * An administrator turns "Enable Full Log" (#249) on or off for an account from a terminal. The
+ * command asks for an ADMIN TOKEN first — minted on the web admin page (Admin → Full Log → Create
+ * CLI token), 15 minutes, one use — and sends it to this machine's own API, which (hosted) decides
+ * or (Client Expert) forwards to the hosted API. The ordinary gu CLI token cannot do this: every
+ * account has one.
+ *
+ * THE TOKEN IS A SECRET HERE TOO: typed masked, never echoed, never printed, never logged, never
+ * saved. It lives in one local variable for one request.
+ *
+ * `status` for THIS machine's account needs no token (reading your own setting is harmless, and
+ * the worker reads it every 5 minutes anyway). Another account's status needs one.
+ */
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export const USAGE = "gu full-log on|off|status [email or account id]";
+/** The daemon's minute tick sees this and re-reads the policy at once (see gu-cli.mjs startLogPolicy). */
+export const REFRESH_FLAG = join(homedir(), ".gonext", "log-policy.refresh");
+export const TOKEN_PROMPT = "Admin token (Admin → Full Log → Create CLI token), hidden:";
+
+/** → { action: "on"|"off"|"status", account? } | { error } */
+export function parseFullLogArgs(words) {
+  const w = (words ?? []).map((s) => String(s).trim()).filter(Boolean);
+  const action = (w[0] ?? "status").toLowerCase();
+  if (!["on", "off", "status"].includes(action)) return { error: `unknown "${w[0]}" — ${USAGE}` };
+  if (w.length > 2) return { error: `too many words — ${USAGE}` };
+  return w[1] ? { action, account: w[1] } : { action };
+}
+
+const onOff = (b) => (b ? "ON" : "OFF");
+
+/** Tell a running worker on this machine to re-read its policy now, instead of within 5 minutes. */
+export async function requestLocalRefresh(file = REFRESH_FLAG) {
+  try {
+    await mkdir(dirname(file), { recursive: true });
+    await writeFile(file, new Date().toISOString() + "\n", "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(res) {
+  return (await res.json().catch(() => null)) ?? {};
+}
+
+/**
+ * Run it. `askSecret(label)` → the typed token ("" = cancelled). `print(line)` writes one line.
+ * → an exit code: 0 done, 1 refused / failed, 2 usage.
+ */
+export async function runFullLog({
+  action,
+  account,
+  apiBase,
+  workerKey,
+  askSecret,
+  print = (l) => console.log(l),
+  fetchImpl = fetch,
+  requestRefresh = requestLocalRefresh,
+}) {
+  const base = String(apiBase ?? "").trim().replace(/\/+$/, "");
+  const key = String(workerKey ?? "").trim();
+  if (!base || !key) {
+    print("This computer is not signed in to gu yet — run `gu login` first.");
+    return 1;
+  }
+  const who = account ? account : "this computer's account";
+
+  // Your own status: no token.
+  if (action === "status" && !account) {
+    let res;
+    try {
+      res = await fetchImpl(`${base}/api/worker/log-policy`, {
+        headers: { "X-Worker-Key": key },
+        signal: AbortSignal.timeout(10_000),
+      });
+    } catch {
+      print(`Could not reach ${base} — try again in a moment.`);
+      return 1;
+    }
+    const body = await readJson(res);
+    if (res.status === 404) {
+      print("Full Log is not available on this gu service yet — this computer keeps full logs until it is.");
+      return 0;
+    }
+    if (!res.ok || typeof body.fullLog !== "boolean") {
+      print(`Could not read the log setting: ${body.error ?? `HTTP ${res.status}`}.`);
+      return 1;
+    }
+    print(
+      body.fullLog
+        ? "Full Log: ON for this computer's account — its logs include what was asked and answered."
+        : "Full Log: OFF for this computer's account — its logs carry no conversation content (the default)."
+    );
+    print(`To change it (administrators): ${USAGE.replace("on|off|status", "on|off")}`);
+    return 0;
+  }
+
+  let token = "";
+  try {
+    token = String((await askSecret(TOKEN_PROMPT)) ?? "").trim();
+  } catch {
+    token = "";
+  }
+  if (!token) {
+    print("No token entered — nothing changed.");
+    return 1;
+  }
+
+  const body = action === "status" ? { account } : { account, fullLog: action === "on" };
+  let res;
+  try {
+    res = await fetchImpl(`${base}/api/worker/log-policy/admin`, {
+      method: "POST",
+      headers: { "X-Worker-Key": key, Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(20_000),
+    });
+  } catch {
+    print(`Could not reach ${base} — nothing changed.`);
+    return 1;
+  } finally {
+    token = ""; // one request, then gone
+  }
+  const a = await readJson(res);
+  if (!res.ok) {
+    if (res.status === 404 && typeof a.error !== "string") {
+      print("This computer's gu service does not support `gu full-log` yet — it needs an update. Nothing changed.");
+    } else {
+      const why = a.error ?? `HTTP ${res.status}`;
+      const tail = action === "status" || /nothing (was )?changed/i.test(why) ? "" : " Nothing changed.";
+      print(`${res.status >= 500 ? "Failed" : "Refused"}: ${why}${tail}`);
+    }
+    return 1;
+  }
+  const name = a.email ? `${a.email} (${a.userId})` : a.self ? `this computer's account (${a.userId})` : String(a.userId ?? who);
+  if (action === "status") {
+    print(`Full Log: ${onOff(a.fullLog)} for ${name}.`);
+    if (a.lastChange) {
+      const lc = a.lastChange;
+      print(`Last changed ${String(lc.at).replace("T", " ").slice(0, 16)} UTC by ${lc.by}${lc.via === "cli" ? " from the CLI" : ""}.`);
+    }
+    return 0;
+  }
+  print(
+    a.changed
+      ? `Full Log ${onOff(a.fullLog)} for ${name} — it was ${onOff(a.previous)}.`
+      : `Full Log was already ${onOff(a.fullLog)} for ${name} — nothing changed (recorded).`
+  );
+  if (a.self) {
+    await requestRefresh();
+    print("This computer picks it up within a minute; the account's other computers within 5 minutes.");
+  } else {
+    print("That account's computers pick it up within 5 minutes.");
+  }
+  return 0;
+}
+
+/**
+ * A masked line from a plain terminal (no REPL) — `gu full-log` in a shell. A bullet per
+ * character, nothing of the value on screen; Ctrl+C / Ctrl+D cancel (→ ""). Piped stdin (a
+ * script: `printf '%s\n' "$TOKEN" | gu full-log on`) reads the first line, echoing nothing.
+ */
+export function readHiddenLine(label, { input = process.stdin, output = process.stderr } = {}) {
+  return new Promise((resolve) => {
+    output.write(label + " ");
+    if (!input.isTTY) {
+      let buf = "";
+      const onData = (d) => {
+        buf += d.toString("utf8");
+        const nl = buf.indexOf("\n");
+        if (nl >= 0) finish(buf.slice(0, nl));
+      };
+      const onEnd = () => finish(buf);
+      const finish = (v) => {
+        input.off("data", onData);
+        input.off("end", onEnd);
+        input.pause();
+        output.write("\n");
+        resolve(v.replace(/\r$/, "").trim());
+      };
+      input.on("data", onData);
+      input.on("end", onEnd);
+      input.resume();
+      return;
+    }
+    let value = "";
+    input.setRawMode(true);
+    input.resume();
+    const done = (v) => {
+      input.off("data", onData);
+      input.setRawMode(false);
+      input.pause();
+      output.write("\n");
+      resolve(v);
+    };
+    const onData = (d) => {
+      for (const ch of d.toString("utf8")) {
+        if (ch === "\r" || ch === "\n") return done(value.trim());
+        if (ch === "\u0003" || ch === "\u0004") return done("");
+        if (ch === "\u007f" || ch === "\b") {
+          if (value) {
+            value = value.slice(0, -1);
+            output.write("\b \b");
+          }
+          continue;
+        }
+        if (ch < " ") continue; // other control bytes: ignored, never stored
+        value += ch;
+        output.write("•");
+      }
+    };
+    input.on("data", onData);
+  });
+}

package/gonext_agent_chat.py

@@ -528,7 +528,7 @@ def _get_json(url, timeout=15):
         with urllib.request.urlopen(req, timeout=timeout, context=_ssl_context_insecure()) as resp:
             return json.loads(resp.read().decode("utf-8", errors="replace"))
     except Exception as e:  # noqa: BLE001
-        _log(f"web_search fetch failed {url}: {e}")
+        _log(f"web_search fetch failed {_u(url)}: {e}")
         return None
 
 
@@ -558,7 +558,7 @@ def _get_text(url, timeout=6, ua=None, headers=None):
         with urllib.request.urlopen(req, timeout=timeout, context=_ssl_context_insecure()) as resp:
             return resp.read(600_000).decode("utf-8", errors="replace")
     except Exception as e:  # noqa: BLE001
-        _log(f"web_search GET failed {url[:80]}: {e}")
+        _log(f"web_search GET failed {_u(url, 80)}: {e}")
         return ""
 
 
@@ -1028,7 +1028,7 @@ def _list_model_ids(base_url, api_key=""):
         with urllib.request.urlopen(req, timeout=10, context=_ssl_context_insecure()) as resp:
             payload = json.loads(resp.read().decode("utf-8", errors="replace"))
     except Exception as e:  # noqa: BLE001
-        _log(f"model list failed {url}: {e}")
+        _log(f"model list failed {_u(url)}: {e}")
         return []
     data = payload.get("data") if isinstance(payload, dict) else None
     if not isinstance(data, list):
@@ -2621,7 +2621,7 @@ def _summarize_result(task_text: str, agent_output: str,
             temperature=0.3,
         )
         summary = (resp.choices[0].message.content or "").strip()
-        _log(f"summary: {summary[:120]}")
+        _log(f"summary: {_c(summary, 120)}")
         return summary or agent_output
     except Exception as e:  # noqa: BLE001
         _log(f"summarize error: {e}")
@@ -2655,6 +2655,12 @@ def _plain_reply(messages: list, base_url: str, api_key: str, model_id: str,
             content = _THINK_RE_LOCAL.sub("", content).strip()
             if not content:
                 continue
+        # An unanswered question stays in history (task #247), so two user turns can be
+        # adjacent. Some chat templates (Gemma's, as served by MLX / vLLM) reject a
+        # conversation whose roles do not alternate, so adjacent turns are joined into one.
+        if chat_messages[-1]["role"] == role:
+            chat_messages[-1]["content"] = f"{chat_messages[-1]['content']}\n\n{content}"
+            continue
         chat_messages.append({"role": role, "content": content})
 
     # Each target carries ITS OWN key. They are usually different services — the chat model
@@ -3214,6 +3220,11 @@ def _is_billing_failure(err) -> bool:
         or "out of credit" in s
         or ("suspended" in s and ("balance" in s or "billing" in s or "payment" in s))
         or ("quota" in s and "exhaust" in s)
+        # ollama.com (task #247): "you have reached your monthly usage limit, upgrade … or add
+        # usage credits". A USAGE limit is an allowance for the period, not a request rate — a
+        # "rate limit … per minute" never says "usage limit", so the transient 429s are untouched.
+        or "usage limit" in s
+        or "usage credits" in s
     )
 
 
@@ -6796,6 +6807,12 @@ def _rag_s3_client(region: str, akid: str, secret: str):
 
 
 def run_agent_chat(cfg):
+    # Task #249: what this run may log — set FIRST, before anything is logged (the history and the
+    # current task are logged early, and a real turn caught them leaking when this came later).
+    # "production" (the account has no Enable Full Log): content becomes <content, N chars> and the
+    # model-request dump is only what is new per step. "full" (or absent — an older worker): as before.
+    global _LOG_PRODUCTION
+    _LOG_PRODUCTION = str(cfg.get("logProfile") or "full").strip().lower() == "production"
     # One turn, one ledger (task #142): the process is per-turn today, but a stale entry would
     # credit RAG for tokens it never cost, and a wrong number is worse than none.
     _rag_ledger_reset()
@@ -7023,8 +7040,8 @@ def run_agent_chat(cfg):
         f"(budget {HISTORY_CHAR_BUDGET}) — exact turns sent to the agent below:"
     )
     for j, ln in enumerate(history_lines):
-        _log(f"  history[{j}]: {ln[:240]}")
-    _log(f"current task (latest user message): {task_text.rsplit('Current task: ', 1)[-1][:240]!r}")
+        _log(f"  history[{j}]: {_c(ln, 240)}")
+    _log(f"current task (latest user message): {_c(task_text.rsplit('Current task: ', 1)[-1], 240, r=True)}")
 
     # ---- send_email config (per-user email API, e.g. a Lambda the user set up) ----
     email_enabled = bool(cfg.get("emailEnabled"))
@@ -7715,8 +7732,8 @@ def run_agent_chat(cfg):
         else:
             doc_title = _derive_pdf_title(doc_text)
             _log(
-                f"PDF fast-path: title={doc_title!r} doc_chars={len(doc_text)}"
-                + (f" edit={edit_instruction[:60]!r}" if edit_instruction else "")
+                f"PDF fast-path: title={_c(doc_title, r=True)} doc_chars={len(doc_text)}"
+                + (f" edit={_c(edit_instruction, 60, r=True)}" if edit_instruction else "")
             )
 
             _emit({"type": "step", "text": "Formatting document…"})
@@ -7761,7 +7778,7 @@ def run_agent_chat(cfg):
                 )})
                 return
 
-            _log(f"PDF fast-path ok title={doc_title!r} bytes={len(pdf_bytes)}")
+            _log(f"PDF fast-path ok title={_c(doc_title, r=True)} bytes={len(pdf_bytes)}")
             _emit({"type": "final", "text": out})
             return
     # ---------------------------------------------------------------------------------
@@ -8296,7 +8313,7 @@ def run_agent_chat(cfg):
         sig = f"{tool_name}::{key}"
         prior = _seen_calls.get(sig)
         if prior is not None:
-            _log(f"{tool_name} REPEAT suppressed ({arg[:60]!r}) → nudging model forward")
+            _log(f"{tool_name} REPEAT suppressed ({_c(arg, 60, r=True)}) → nudging model forward")
             return True, (
                 f"You already ran {tool_name}({arg!r}) (or an equivalent query) — the "
                 f"result would be the same as shown above. Do NOT call it again. {next_hint}"
@@ -8332,12 +8349,12 @@ def run_agent_chat(cfg):
         if url_key in _failed_urls:
             msg = f"Error: {url} already failed — try a different URL or use Python stdlib."
             _emit({"type": "step", "text": f"HTTP {method.upper()} {url} → (skipped, already failed)"})
-            _log(f"http_request skipped (already failed): {url_key}")
+            _log(f"http_request skipped (already failed): {_u(url_key)}")
             return msg
         result = _http_request_impl(method, url, parsed_headers, body or None)
         if result.startswith("Error:"):
             # Retry once for flaky connections (e.g. gorok tunnels).
-            _log(f"http_request retry {method.upper()} {url}")
+            _log(f"http_request retry {method.upper()} {_u(url)}")
             result = _http_request_impl(method, url, parsed_headers, body or None)
         if result.startswith("Error:"):
             # Both attempts failed — mark URL as dead so model tries something else.
@@ -8377,7 +8394,7 @@ def run_agent_chat(cfg):
                     "server log above, or call final_answer honestly stating what's failing.]"
                 )
         _emit({"type": "step", "text": f"HTTP {method.upper()} {url} → {status_line}"})
-        _log(f"http_request {method.upper()} {url} → {result[:80]}")
+        _log(f"http_request {method.upper()} {_u(url)} → {_c(result, 80)}")
         _last_obs["text"] = result
         return result
 
@@ -8399,7 +8416,7 @@ def run_agent_chat(cfg):
             now = _dtl.now().astimezone()
         out = now.strftime("%A, %d %B %Y, %H:%M:%S %Z")
         _emit({"type": "step", "text": f"Current date/time → {out}"})
-        _log(f"get_current_datetime({timezone!r}) → {out}")
+        _log(f"get_current_datetime({timezone!r}) → {_c(out)}")
         _last_obs["text"] = out
         return out
 
@@ -8436,7 +8453,7 @@ def run_agent_chat(cfg):
             search_base_url=(cfg.get("searchBaseURL") or "").strip(),
             search_model_id=(cfg.get("searchModelId") or "").strip(),
         )
-        _log(f"web_search {query[:60]!r} → {result[:80]}")
+        _log(f"web_search {_c(query, 60, r=True)} → {_c(result, 80)}")
         _last_obs["text"] = result
         if result and not result.startswith("Error"):
             _gathered.append(result)
@@ -8466,19 +8483,19 @@ def run_agent_chat(cfg):
         status, ctype, raw = _fetch_page_impl(url)
         if status is None:
             msg = f"Error: could not fetch {url}: {raw.decode('utf-8', 'replace')[:200]}"
-            _log(f"fetch_url error {url} → {msg[:80]}")
+            _log(f"fetch_url error {_u(url)} → {msg[:80]}")
             _last_obs["text"] = msg
             return msg
         if isinstance(status, int) and status >= 400:
             msg = f"Error: {url} returned HTTP {status}. Try a different URL or use web_search()."
-            _log(f"fetch_url {url} → HTTP {status}")
+            _log(f"fetch_url {_u(url)} → HTTP {status}")
             _last_obs["text"] = msg
             return msg
         # PDFs / binaries don't strip to useful text.
         if "application/pdf" in ctype or raw[:5].lstrip().startswith(b"%PDF"):
             msg = (f"{url} is a PDF, not an HTML page — fetch_url cannot read PDFs. "
                    "Tell the user this needs a PDF-reading tool.")
-            _log(f"fetch_url {url} → PDF, cannot read")
+            _log(f"fetch_url {_u(url)} → PDF, cannot read")
             _last_obs["text"] = msg
             return msg
         # 8000, not the 3000 default: a research page's real content (fixture tables,
@@ -8488,7 +8505,7 @@ def run_agent_chat(cfg):
         text = (_html_to_text(raw.decode("utf-8", errors="replace"), limit=8000)
                 or "(page had no readable text)")
         out = f"{url}\n{text}"
-        _log(f"fetch_url {url} → {len(text)} chars")
+        _log(f"fetch_url {_u(url)} → {len(text)} chars")
         _last_obs["text"] = out
         _gathered.append(out)
         return out
@@ -8506,7 +8523,7 @@ def run_agent_chat(cfg):
         """
         _emit({"type": "step", "text": f"Calculating → {expression[:80]}"})
         result = _calc_impl(expression)
-        _log(f"calculate({expression!r}) → {result[:80]}")
+        _log(f"calculate({_c(expression, r=True)}) → {_c(result, 80)}")
         _last_obs["text"] = result
         return result
 
@@ -8531,7 +8548,7 @@ def run_agent_chat(cfg):
         if email_allow and not _email_allowed(to_addr, email_allow):
             msg = (f"Error: {to_addr} is not in the allowed recipients list — refusing to "
                    "send. Add it to the allow-list in Settings if this is intended.")
-            _log(f"send_email blocked by allow-list: {to_addr}")
+            _log(f"send_email blocked by allow-list: {_c(to_addr)}")
             _last_obs["text"] = msg
             return msg
         preview = (
@@ -8544,7 +8561,7 @@ def run_agent_chat(cfg):
         # shown — otherwise just preview (never send on the first call).
         if not _email_confirm_pending():
             _emit({"type": "step", "text": f"Email preview → {to_addr} (awaiting confirm)"})
-            _log(f"send_email preview (awaiting confirm) → {to_addr}")
+            _log(f"send_email preview (awaiting confirm) → {_c(to_addr)}")
             _last_obs["text"] = preview
             return preview
         filled = _email_fill_template(email_body_template, {
@@ -8566,7 +8583,7 @@ def run_agent_chat(cfg):
             out = f"✅ Email sent to {to_addr} (Subject: {subject or '(no subject)'})."
         else:
             out = f"Email send failed ({first}). Check the email API settings."
-        _log(f"send_email {to_addr} → {first}")
+        _log(f"send_email {_c(to_addr)} → {_c(first)}")
         _last_obs["text"] = out
         return out
 
@@ -8582,7 +8599,7 @@ def run_agent_chat(cfg):
         """
         _emit({"type": "step", "text": f"Reading PDF → {url[:80]}"})
         result = _extract_pdf_text_impl(url)
-        _log(f"extract_text_from_pdf {url} → {result[:80]}")
+        _log(f"extract_text_from_pdf {_u(url)} → {_c(result, 80)}")
         _last_obs["text"] = result
         return result
 
@@ -8624,7 +8641,7 @@ def run_agent_chat(cfg):
             or (_pdf_state.get("timeout_pending")
                 and _pdf_titles_similar(prev["title"], doc_title))
         ):
-            _log(f"create_pdf retry detected (prev title={prev['title']!r}) "
+            _log(f"create_pdf retry detected (prev title={_c(prev['title'], r=True)}) "
                  "→ returning the existing PDF instead of re-rendering")
             _emit({"type": "step",
                    "text": f"PDF already created → {prev['title']}.pdf (reusing link)"})
@@ -8697,7 +8714,7 @@ def run_agent_chat(cfg):
             f"Download it here (link valid for a limited time):\n{download_url}"
         )
         _emit({"type": "step", "text": f"PDF ready → {doc_title}.pdf"})
-        _log(f"create_pdf ok title={doc_title!r} bytes={len(pdf_bytes)}")
+        _log(f"create_pdf ok title={_c(doc_title, r=True)} bytes={len(pdf_bytes)}")
         _pdf_state["last"] = {
             "sig": _pdf_sig(doc_title, text), "title": doc_title, "msg": out,
         }
@@ -9121,12 +9138,12 @@ def run_agent_chat(cfg):
             raw = getattr(last, "content", "")
             if isinstance(raw, list):
                 raw = " ".join(p.get("text", "") for p in raw if isinstance(p, dict))
-            _log(f"step {step_num} → model input (tail): {str(raw)[:400]}")
+            _log(f"step {step_num} → model input (tail): {_c(raw, 400)}")
 
         # Log what the model generated (the Python code block).
         model_output = getattr(step_log, "model_output", None)
         if model_output:
-            _log(f"step {step_num} ← model output: {str(model_output)[:400]}")
+            _log(f"step {step_num} ← model output: {_c(model_output, 400)}")
 
         try:
             text = _summarise_step(step_log)
@@ -9153,7 +9170,7 @@ def run_agent_chat(cfg):
         if not text or text.rstrip().endswith("| →"):
             _log(f"step {step_num} (empty obs, skipped)")
             return
-        _log(f"step {step_num}: {text[:200]}")
+        _log(f"step {step_num}: {_c(text, 200)}")
         _emit({"type": "step", "text": text})
 
     # Wrap the model so we can see EXACTLY what smolagents posts to the model
@@ -9928,6 +9945,7 @@ def run_agent_chat(cfg):
                                            "text": "Coding model is busy (429) — retrying…"})
                             _log(f"generate {kind} error (attempt {attempt}/{max_attempts}): "
                                  f"{_clip(emsg, 160)} — retrying in {delay:.0f}s")
+                            _DUMP_SEEN["n"] = 0  # the retried request is logged in full (#249)
                             time.sleep(delay)
                         elif timed_out:
                             # Out of attempts on OUR deadline. Nothing about this is a
@@ -10351,8 +10369,11 @@ def run_agent_chat(cfg):
                 _log(f"/no_think inject error: {e}")
             try:
                 msgs = ck.get("messages", []) or []
-                _log(f"=== MODEL REQUEST: {len(msgs)} message(s) sent to the model ===")
+                _start, _suffix = _request_dump_range(len(msgs))
+                _log(f"=== MODEL REQUEST: {len(msgs)} message(s) sent to the model{_suffix} ===")
                 for i, m in enumerate(msgs):
+                    if i < _start:
+                        continue
                     role = m.get("role") if isinstance(m, dict) else getattr(m, "role", "?")
                     content = (
                         m.get("content") if isinstance(m, dict)
@@ -10366,7 +10387,7 @@ def run_agent_chat(cfg):
                     else:
                         text = str(content)
                     text = text.replace("\n", " ")
-                    _log(f"  [{i}] {role} ({len(text)} chars): {text[:600]}")
+                    _log(f"  [{i}] {role} ({len(text)} chars): {_c(text, 600)}")
                 _log("=== END MODEL REQUEST ===")
             except Exception as e:  # noqa: BLE001
                 _log(f"MODEL REQUEST log error: {e}")
@@ -10426,13 +10447,13 @@ def run_agent_chat(cfg):
                     )
                     if isinstance(out, str) and out.startswith("✅"):
                         return ChatMessage(role=MessageRole.ASSISTANT, content=out)
-                    _log(f"deterministic create_pdf did not succeed: {str(out)[:120]}")
+                    _log(f"deterministic create_pdf did not succeed: {_c(out, 120)}")
                 except Exception as e:  # noqa: BLE001
                     _log(f"deterministic create_pdf error: {type(e).__name__}: {e}")
             _maxsteps_partial["hit"] = True
             text = (_last_obs.get("text") or "").strip()
             if text:
-                _log(f"max-steps fallback (last tool obs) → {text[:80]}")
+                _log(f"max-steps fallback (last tool obs) → {_c(text, 80)}")
                 # Summarize WHAT WAS TRIED + the current blocker, not just the last tool
                 # observation (task #79): a bare last obs ('Stopped npm run dev') reads as a
                 # non-answer and hides the loop the run got stuck in. Build a compact bullet
@@ -11067,7 +11088,7 @@ def run_agent_chat(cfg):
                 topk = scored[: (k if k and k > 0 else rag_top_k)]
                 # Log WHAT matched and HOW WELL: a search that returns junk looks identical to
                 # one that returns nothing useful unless the scores and files are visible.
-                _log(f"RAG search {query[:60]!r} over {len(chunks)} chunk(s) "
+                _log(f"RAG search {_c(query, 60, r=True)} over {len(chunks)} chunk(s) "
                      f"in {_t.time() - _s0:.1f}s → top {len(topk)}: "
                      + ", ".join(f"{c.get('file','?')}({score:.2f})" for score, c in topk))
                 if topk and topk[0][0] < 0.25:
@@ -11720,7 +11741,7 @@ def run_agent_chat(cfg):
                 # alternative cost two hour-long turns and a false report to the user.
                 _shell_err = _shell_syntax_error(command, argv)
                 if _shell_err:
-                    _log(f"run_command refused shell syntax: {_clip(command, 120)}")
+                    _log(f"run_command refused shell syntax: {_c(_clip(command, 120))}")
                     _last_obs["text"] = _shell_err
                     return _shell_err
                 # Allow-by-default policy. Match on the runner's basename too, so
@@ -12309,7 +12330,7 @@ def run_agent_chat(cfg):
         _retr = _retrieval_summary(_SEARCH_TALLY, _RAG_STATE.get("s", ""), True, _SEARCH_LOG)
         if _retr:
             _emit({"type": "step", "text": _retr})
-            _log(f"retrieval summary: {_retr}")
+            _log(f"retrieval summary: {_c(_retr)}")
         _emit({"type": "step", "text": "Composing answer…"})
         final_text = _strip_tool_tags(str(result).strip()) or "[No result]"
         _log(f"done (deterministic, no summarizer call): {len(final_text)} chars")
@@ -12434,6 +12455,56 @@ def _log(text: str):
 
 
 _CLIENT_MODE = False  # task #134: agent runs here, models live on another machine
+_LOG_PRODUCTION = False  # task #249: set from cfg.logProfile; False = log as always
+# How many messages of THIS run's model requests are already in the log (task #249, production
+# only). One python process runs one job, so module state is per turn.
+_DUMP_SEEN = {"n": 0}
+
+
+def _c(text, limit=None, r=False) -> str:
+    """Conversation CONTENT inside a log line (task #249).
+
+    Content = the user's words, the model's words, and what tools were given or returned (search
+    queries, expressions, commands, email addresses, page text, observations, document titles).
+    Under the production profile (the account has no "Enable Full Log") it becomes a placeholder
+    that keeps only the size: `<content, 2227 chars>`. Under Full Log it is the text, clipped to
+    `limit` as before, and repr()'d when `r` (what the old `!r` did).
+
+    MARKED AT THE CALL SITE, never filtered afterwards: a pattern that tries to spot content in
+    finished lines misses one eventually, and one miss is a leak.
+    """
+    t = "" if text is None else str(text)
+    if _LOG_PRODUCTION:
+        return f"<content, {len(t)} chars>"
+    t = t[:limit] if limit else t
+    return repr(t) if r else t
+
+
+def _u(url, limit=None) -> str:
+    """A URL inside a log line (task #249): the host only under production — a path or a query
+    string can carry a token or the user's own data — and the URL as before under Full Log."""
+    t = "" if url is None else str(url)
+    if _LOG_PRODUCTION:
+        m = re.match(r"^([a-z][a-z0-9+.-]*://[^/?#]+)", t, re.I)
+        return (m.group(1) + "/…") if m else _c(t)
+    return t[:limit] if limit else t
+
+
+def _request_dump_range(n_msgs: int) -> tuple:
+    """Which messages of a model request to log: (start, header_suffix) — task #249.
+
+    MEASURED: this dump was 94% of a 161 MB worker.log, because every step re-logged EVERY message
+    (the agent's memory only grows), so a turn cost O(steps²). In production each step logs only
+    the messages added since the last request. The whole list is logged again when there is no
+    earlier dump, when the list SHRANK (older steps trimmed or compacted — the old indices no
+    longer line up), and on the request after an error (_DUMP_SEEN is reset there). Full Log logs
+    everything, every step, exactly as before.
+    """
+    prev = _DUMP_SEEN["n"]
+    _DUMP_SEEN["n"] = n_msgs
+    if not _LOG_PRODUCTION or prev <= 0 or n_msgs < prev:
+        return 0, ""
+    return prev, f" — {n_msgs - prev} new; [0]..[{prev - 1}] were logged at an earlier step"
 _EMIT_LOCK = threading.Lock()
 
 

package/gu-cli.mjs

@@ -15,7 +15,7 @@ import { requireSupportedNode } from "./node-version.mjs";
 // The brand accent, shared with the REPL — see accent.mjs.
 import { accent } from "./accent.mjs";
 requireSupportedNode();
-import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { execFile as execFileCallback, spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { createTaskPool, createFolderQueue } from "./job-pools.mjs";
@@ -76,6 +76,9 @@ gu-cli
 Usage:
   gu-cli
   gu-cli login [--api-base <url>]   # browser sign-in → writes ~/.gonext/worker.env
+  gu-cli full-log on|off|status [account] # administrators: Enable Full Log for an account (asks for
+                                           # an admin token from the web admin page first); status
+                                           # alone shows this computer's account, no token needed
   gu-cli token [<token>]                   # show this computer's gu token, or save one pasted from
                                                #   the Account page (Client Expert machines)
   gu-cli set <workerKey> [--api-base <url>]
@@ -220,6 +223,24 @@ if (args[0] === "token") {
   process.exit(0);
 }
 
+if (args[0] === "full-log") {
+  // #250. An administrator switches Enable Full Log (#249) from a terminal — after typing an admin
+  // token minted on the web admin page. Same code as /full-log in the terminal UI.
+  const fl = await import("./full-log-command.mjs");
+  const parsed = fl.parseFullLogArgs(args.slice(1));
+  if (parsed.error) {
+    console.error(parsed.error);
+    process.exit(2);
+  }
+  const code = await fl.runFullLog({
+    ...parsed,
+    apiBase: process.env.GONEXT_API_BASE,
+    workerKey: process.env.GONEXT_WORKER_KEY,
+    askSecret: (label) => fl.readHiddenLine(label),
+  });
+  process.exit(code);
+}
+
 if (args[0] === "login") {
   // Task #127, Phase 1: browser device-pairing → writes worker.env. `--api-base` overrides
   // which API to pair against (defaults to the production API).
@@ -3761,6 +3782,9 @@ async function runAgentChatJob(job) {
       // Session opt-in (task #80): auto-extend past the step budget without re-prompting
       // (the REPL sets this once the user picks "yes, don't ask again").
       alwaysExtendOnMaxStep: payload?.alwaysExtendOnMaxStep === true,
+      // What the agent may log (task #249): "production" = no conversation content, and the
+      // model-request dump only what is new per step. "full" = as it always has.
+      logProfile: logPolicy?.profile() ?? "full",
       // Auto-test mode (/test-auto): the agent verifies its work and fixes until it passes.
       autoTest: payload?.autoTest === true,
       // Deploy target chosen via the terminal /server picker (task #69). Host/user only.
@@ -5033,6 +5057,53 @@ async function pollOnce() {
   }
 }
 
+/**
+ * WHAT THIS MACHINE LOGS (task #249). Read from the account's API at startup and every 5 minutes;
+ * "production" (the default once the setting exists) timestamps every line, rotates worker.log and
+ * prunes run-logs/, and tells each agent run to log no conversation content. "full" (Enable Full
+ * Log, or the setting not readable yet) is exactly today's logging. See log-policy.mjs.
+ */
+let logPolicy = null;
+async function startLogPolicy() {
+  try {
+    const lp = await import("./log-policy.mjs");
+    const { LOG_FILE } = await import("./daemon-control.mjs");
+    logPolicy = lp.createLogPolicy({
+      apiBase,
+      workerKey,
+      onChange: (profile) =>
+        console.log(
+          profile === "production"
+            ? "[gu-worker] log profile: production — Full Log is off for this account (no conversation content, timestamps, rotation)"
+            : "[gu-worker] log profile: full — Enable Full Log is on for this account"
+        ),
+    });
+    lp.installTimestamps(() => logPolicy.profile() === "production");
+    await logPolicy.refresh();
+    const runLogs = join(homedir(), ".gonext", "run-logs");
+    const housekeep = async () => {
+      if (logPolicy.profile() !== "production") return;
+      await lp.rotateIfLarge(LOG_FILE);
+      await lp.pruneRunLogs(runLogs);
+    };
+    await housekeep();
+    let ticks = 0;
+    const { REFRESH_FLAG } = await import("./full-log-command.mjs");
+    setInterval(() => {
+      ticks++;
+      void (async () => {
+        // `gu full-log` just changed this machine's account (#250): re-read now, not in 5 minutes.
+        const asked = await unlink(REFRESH_FLAG).then(() => true, () => false);
+        if (asked || ticks % Math.round(lp.REFRESH_MS / 60_000) === 0) await logPolicy.refresh();
+        await housekeep();
+      })().catch(() => {});
+    }, 60_000).unref();
+  } catch (e) {
+    // Never fatal: without a policy the worker keeps today's logging.
+    console.log(`[gu-worker] log policy unavailable (${e?.message ?? e}) — logging as before`);
+  }
+}
+
 async function main() {
   // Task #127, Phase 2: record our own pidfile so `status`/`stop` find us whether we were
   // launched by `start` (detached), by the REPL's auto-ensure, or run in the foreground.
@@ -5060,6 +5131,7 @@ async function main() {
     /* pidfile is a convenience; polling works without it */
   }
   MY_INSTANCE_ID = await (await import("./daemon-control.mjs")).getInstanceId();
+  await startLogPolicy();
   console.log(
     `[gu-worker] polling ${apiBase} every ${pollMs}ms (local_health concurrency=${localHealthConcurrency}` +
       `, agent concurrency=${agentConcurrency})` +

package/gu-repl.mjs

@@ -47,6 +47,9 @@ import {
   promptTotal,
   resumeTask,
   isResumeWord,
+  isPendingQuestion,
+  interruptStatus,
+  messagesForModel,
   retryAdvice,
   classifyTurnFailure,
   budgetMinutes,
@@ -529,7 +532,7 @@ const argv = process.argv.slice(2);
 // process.argv and exits inside its own subcommand branch, before it ever starts polling.
 const CLI_SUBCOMMANDS = [
   "status", "start", "stop", "restart", "logs", "doctor", "login", "set", "rag",
-  "clear", "reset", "api", "token-usage", "tokens", "token",
+  "clear", "reset", "api", "token-usage", "tokens", "token", "full-log",
 ];
 // `gu logz` USED TO START THE REPL (task #181). Silently: an unrecognised word was not in
 // the list, so it fell through to "no subcommand given" and a full agent session opened in that
@@ -803,6 +806,7 @@ const COMMANDS = [
   { name: "/load-settings", usage: "/load-settings [name|path]", desc: "read that file back on another machine — picks from the settings files in your home folder, asks before it replaces anything" },
   { 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: "/full-log", usage: "/full-log [on|off|status] [account]", desc: "administrators: Enable Full Log for an account — asks for an admin token from the web admin page first" },
   { name: "/help", desc: "list these commands" },
   { name: "/exit", aliases: ["/quit"], desc: "quit" },
 ];
@@ -4405,6 +4409,16 @@ async function updateSessionFile(cwd, mutate) {
   return queued;
 }
 
+/** Tag the unanswered question with how its turn ended and persist it (task #247). */
+async function markInterrupted(cwd, history, task, how) {
+  const last = history[history.length - 1];
+  if (!isPendingQuestion(history, task)) return;
+  const status = interruptStatus(how);
+  if (!status) return;
+  last.status = status;
+  await saveSession(cwd, history, { unfinishedTask: sessionUnfinishedTask || task });
+}
+
 async function rememberUnfinishedTask(cwd, task) {
   // NEVER remember a resume word as the task (task #201). The invariant is enforced at the
   // point of WRITING rather than at each of the three failure paths that call this: storing
@@ -4789,7 +4803,9 @@ async function saveSessionSkip(cwd, key, on) {
   }
 }
 
-async function saveSession(cwd, history) {
+// `unfinishedTask` overrides what goes to DISK only: the question saved before its turn runs
+// (task #247) must read as pending there, while the in-memory resume stays one-shot.
+async function saveSession(cwd, history, { unfinishedTask = sessionUnfinishedTask } = {}) {
   try {
     const trimmed = history.slice(-MAX_PERSISTED_MESSAGES);
     // MERGE, DO NOT REPLACE. This used to write a whole fresh object, which silently dropped
@@ -4806,7 +4822,7 @@ async function saveSession(cwd, history) {
           maxCodeTokens: sessionMaxCodeTokens, // peak per-request tokens (task #84)
           ragStorage: sessionRagStorage, // where this folder's RAG index lives (#133/#180)
           showThought: sessionShowThought, // print the model's reasoning (task #148)
-          unfinishedTask: sessionUnfinishedTask, // what a bare "continue" resumes (#150/#189)
+          unfinishedTask, // what a bare "continue" resumes (#150/#189)
           // The /model pick, so it survives an exit (see loadSessionCoding). Empty means "the
           // account default" and is written as such rather than omitted, so choosing the
           // default again CLEARS a previous override instead of leaving it stored.
@@ -7070,6 +7086,28 @@ async function runS3Command(line) {
   await runTest({});
 }
 
+/**
+ * /full-log (#250) — the same code as `gu full-log`. The admin token goes through askSecret: masked
+ * in the frozen row, dropped from readline history, never echoed (#191).
+ */
+async function runFullLogCommand(line) {
+  const fl = await import("./full-log-command.mjs");
+  const parsed = fl.parseFullLogArgs(line.split(/\s+/).slice(1));
+  if (parsed.error) {
+    console.log(red(parsed.error) + "\n");
+    return;
+  }
+  // A cancelled token prompt (Esc / Ctrl+C) reads as "no token entered" inside runFullLog.
+  await fl.runFullLog({
+    ...parsed,
+    apiBase,
+    workerKey,
+    askSecret: (label) => askSecret(`  ${label}`),
+    print: (l) => console.log(gutterLines(l)),
+  });
+  console.log("");
+}
+
 async function runProxyCommand(line) {
   const cmd = await import("./proxy-command.mjs");
   const store = await import("./proxy-store.mjs");
@@ -8867,7 +8905,8 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
     // cwd = this terminal's folder → agent puts download/unzip output here (when it's
     // a registered workspace). codingModelOverride = the /model choice for this session.
     body: JSON.stringify({
-      messages: history,
+      // Earlier questions that were stopped or failed carry their status tag (task #247).
+      messages: messagesForModel(history),
       cwd: resolve(process.cwd()),
       // The terminal can show a Yes/No picker → the agent PAUSES on a risky command and
       // asks instead of hard-blocking it (interactive command-approval gate).
@@ -8987,6 +9026,9 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
   let pollFailures = 0;
   const MAX_POLL_FAILURES = 6; // ~6 tries with backoff before conceding the follow
   let jobRunning = false; // only tick "thinking…" once the worker has claimed the job
+  // Sticky: the agent RAN, so the coding model was called ("thinking…" was on screen). A
+  // Ctrl+C after this point is "stopped", never "changed my mind" (task #247).
+  let reachedModel = false;
   let answerShownLive = false; // plain-reply content already printed — don't re-print it
   // True once we've SPECIFICALLY seen "→ Chat reply" (the plain-reply/trivial-chat
   // branch), as opposed to "→ Agent mode…" (the tool-use branch). Only the plain-reply
@@ -9833,6 +9875,7 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
         continue;
       }
       jobRunning = job.jobStatus === "running";
+      if (jobRunning) reachedModel = true;
       // Claimed → the turn's own ticker takes the screen from here (task #140). Also drop the
       // pre-turn block for ANY non-pending status, so a job that goes straight to completed
       // (a fast plain reply) can't print its answer over it.
@@ -10055,7 +10098,7 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
         // turn (main() drops it from history).
         clearStatus();
         process.stdout.write("\n" + GUTTER + dim("(cancelled — the agent was stopped)") + "\n");
-        return { text: "", shown: false, cancelled: true };
+        return { text: "", shown: false, cancelled: true, started: reachedModel };
       }
       if (job.jobStatus === "failed") {
         clearStatus();
@@ -11045,6 +11088,10 @@ async function main() {
       await saveSession(cwd, history); // remember the pick for this folder
       continue;
     }
+    if (line === "/full-log" || line.startsWith("/full-log ")) {
+      await runFullLogCommand(line);
+      continue;
+    }
     if (line === "/proxy" || line.startsWith("/proxy ")) {
       await runProxyCommand(line);
       continue;
@@ -11301,10 +11348,32 @@ async function main() {
       const shown = taskLine.length > 80 ? taskLine.slice(0, 80) + "…" : taskLine;
       console.log(GUTTER + dim(`↻ retrying: ${shown}\n`));
     }
-    history.push({ role: "user", content: taskLine });
+    // SAVE THE QUESTION BEFORE THE MODEL IS ASKED (task #247). It stays in history however the
+    // turn ends — answered, failed, cancelled, or the terminal killed — because it WAS asked.
+    // It used to be popped on every failure and kept only as a one-shot resume, so "retry" and
+    // "where were we?" reached the model with no history and it said nothing had been asked.
+    // Only the failure NOTICE stays out of history (task #144). A resume, or the same question
+    // typed again after a failure, is already the last entry and is not pushed a second time.
+    if (isPendingQuestion(history, taskLine)) {
+      delete history[history.length - 1].status; // it is the current task again, not a stopped one
+    } else {
+      history.push({ role: "user", content: taskLine });
+    }
+    await saveSession(cwd, history, { unfinishedTask: isResumeWord(taskLine) ? "" : taskLine });
     try {
-      const { text: answer, shown, cancelled, inputTokens, outputTokens, turnOutputTokens,
-              elapsedMs } = await runAgentTurn(history);
+      const turn = await runAgentTurn(history);
+      // NOT SENT (licence block, or the token prompt declined): runAgentTurn already said so.
+      // Nothing began, and "continue" can send it once the cause is fixed (task #247).
+      if (!turn) {
+        await rememberUnfinishedTask(cwd, taskLine);
+        await markInterrupted(cwd, history, taskLine, "cancelled");
+        continue;
+      }
+      const { text: answer, shown, cancelled, started, detached, inputTokens, outputTokens,
+              turnOutputTokens, elapsedMs } = turn;
+      // 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;
       // 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
@@ -11318,7 +11387,9 @@ async function main() {
       // it as one and DROP it — persisting it would re-send "⚠️ your account is suspended" to
       // the model as an assistant turn for the rest of the session (task #144).
       if (answer && answer.startsWith(TURN_FAILED_PREFIX)) {
-        history.pop(); // …the user's question goes too: nothing answered it
+        // The question stays in history (saved before the turn, task #247); only this notice
+        // is kept out of it. Its status says it was not done, and still stands.
+        await markInterrupted(cwd, history, taskLine, "failed");
         if (_lineQueue.length > 0) _lineQueue.length = 0;
         // …but REMEMBER it, so "continue" retries the real question once the cause is fixed
         // (typically /model to a working coder). Deliberately not the same thing as putting it
@@ -11373,7 +11444,6 @@ async function main() {
           registerCopyBlock(block.rows, plain, 1);
         }
       } else {
-        history.pop(); // aborted/failed/cancelled turn — don't poison the next request
         // 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
         // sit in `_lineQueue` — they land there (not ignored) whenever `following` was still
@@ -11393,13 +11463,17 @@ async function main() {
           // next bare "continue" resumes it — even if it was cancelled during step 1,
           // before any worker-side checkpoint step was written.
           await rememberUnfinishedTask(cwd, taskLine);
+          // Stopped AFTER the model was called = too slow or stuck, never a change of mind: the
+          // request still stands (task #247, the user's rule). Before that, nothing had begun.
+          await markInterrupted(cwd, history, taskLine, started ? "stopped" : "cancelled");
         } else {
+          await markInterrupted(cwd, history, taskLine, "failed");
           // The turn ended cleanly but empty — no exception to summarize, so say exactly that.
           printTurnError("the run ended without an answer (aborted or failed)");
         }
       }
     } catch (err) {
-      history.pop();
+      await markInterrupted(cwd, history, taskLine, "failed");
       // Same reasoning as the no-answer branch (bug #92): don't let input buffered during a
       // turn that just threw auto-fire the next one.
       if (_lineQueue.length > 0) _lineQueue.length = 0;

package/log-policy.mjs

@@ -0,0 +1,206 @@
+/**
+ * WHAT THIS MACHINE LOGS — "Enable Full Log" per account (task #249).
+ *
+ * Two profiles:
+ *   · "full"       — exactly what gu has always logged. For accounts an administrator turned
+ *                    "Enable Full Log" ON for (developers; a customer while their issue is traced).
+ *   · "production" — the default for every account: the model-request dump reduced to what is NEW
+ *                    per step, a timestamp on every worker.log line, worker.log rotated, run-logs/
+ *                    kept 7 days / 200 files, and no conversation content.
+ *
+ * THE ROLLOUT GUARD. Only an explicit `fullLog: false` from the account's API selects "production".
+ * Never asked yet, an API that does not know the route (404 — an older gu service), a network
+ * failure with nothing cached: all keep "full", i.e. TODAY's behaviour. Nothing changes for anyone
+ * until the setting exists and has been read — the owner's rule, so a developer machine does not
+ * silently lose its logs mid-development. Once read, the answer is cached on disk, and a later
+ * failure keeps the last answer (a network hiccup never flips a machine either way).
+ */
+import { copyFile, readdir, readFile, rename, stat, truncate, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const POLICY_FILE = join(homedir(), ".gonext", "log-policy.json");
+export const REFRESH_MS = 5 * 60_000;
+export const ROTATE = { maxBytes: 20 * 1024 * 1024, keep: 3 };
+export const RUN_LOGS = { maxAgeMs: 7 * 86_400_000, maxFiles: 200 };
+
+/** The profile a known-or-unknown `fullLog` selects. Only an explicit false is production. */
+export function profileFor(fullLog) {
+  return fullLog === false ? "production" : "full";
+}
+
+/** Ask this machine's API. → { ok: true, fullLog } | { ok: false, status } — never throws. */
+export async function fetchLogPolicy({ apiBase, workerKey, fetchImpl = fetch, timeoutMs = 8000 }) {
+  const base = String(apiBase ?? "").replace(/\/+$/, "");
+  if (!base || !workerKey) return { ok: false, status: 0 };
+  try {
+    const res = await fetchImpl(`${base}/api/worker/log-policy`, {
+      headers: { "X-Worker-Key": workerKey },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res.ok) return { ok: false, status: res.status };
+    const body = await res.json().catch(() => null);
+    return typeof body?.fullLog === "boolean" ? { ok: true, fullLog: body.fullLog } : { ok: false, status: 502 };
+  } catch {
+    return { ok: false, status: 0 };
+  }
+}
+
+export async function readCachedPolicy(file = POLICY_FILE) {
+  try {
+    const s = JSON.parse(await readFile(file, "utf8"));
+    return typeof s?.fullLog === "boolean" ? s.fullLog : null;
+  } catch {
+    return null;
+  }
+}
+
+async function writeCachedPolicy(file, fullLog, now) {
+  try {
+    const tmp = `${file}.${process.pid}.tmp`;
+    await writeFile(tmp, JSON.stringify({ fullLog, fetchedAt: new Date(now).toISOString() }) + "\n", "utf8");
+    await rename(tmp, file);
+  } catch {
+    /* the cache is a convenience: the next refresh asks again */
+  }
+}
+
+/**
+ * The machine's live policy: `profile()` answers now, `refresh()` asks the API (startup, then every
+ * REFRESH_MS). `onChange(profile)` fires when the profile actually changes.
+ */
+export function createLogPolicy({ apiBase, workerKey, file = POLICY_FILE, fetchImpl = fetch, now = () => Date.now(), onChange = () => {} }) {
+  let fullLog = null; // null = unknown
+  let loaded = false;
+  const set = (value) => {
+    const before = profileFor(fullLog);
+    fullLog = value;
+    const after = profileFor(fullLog);
+    if (after !== before) onChange(after);
+  };
+  return {
+    profile: () => profileFor(fullLog),
+    fullLog: () => fullLog,
+    async refresh() {
+      if (!loaded) {
+        loaded = true;
+        const cached = await readCachedPolicy(file);
+        if (cached !== null) set(cached);
+      }
+      const r = await fetchLogPolicy({ apiBase, workerKey, fetchImpl });
+      if (r.ok) {
+        set(r.fullLog);
+        await writeCachedPolicy(file, r.fullLog, now());
+      }
+      return r;
+    },
+  };
+}
+
+/** "2026-09-24 06:31:02" — local time, sortable, and what a person asks the log about. */
+export function stamp(date = new Date()) {
+  const p = (n) => String(n).padStart(2, "0");
+  return (
+    `${date.getFullYear()}-${p(date.getMonth() + 1)}-${p(date.getDate())} ` +
+    `${p(date.getHours())}:${p(date.getMinutes())}:${p(date.getSeconds())}`
+  );
+}
+
+/** Put the time in front of EVERY line of a message — continuation lines too, so any line can be placed. */
+export function stampLines(text, date = new Date()) {
+  const t = stamp(date);
+  return String(text)
+    .split("\n")
+    .map((line) => (line ? `${t} ${line}` : line))
+    .join("\n");
+}
+
+/**
+ * Timestamp everything the process prints, while `enabled()` says so. worker.log IS this process's
+ * stdout/stderr (the launcher appends them to the file), so this is the one place every line —
+ * [gu-worker] and relayed [gu-agent] alike — passes through.
+ */
+export function installTimestamps(enabled, { out = process.stdout, err = process.stderr, now = () => new Date() } = {}) {
+  const wrap = (stream) => {
+    const write = stream.write.bind(stream);
+    let atLineStart = true;
+    stream.write = (chunk, encoding, cb) => {
+      if (!enabled() || typeof chunk !== "string" && !Buffer.isBuffer(chunk)) return write(chunk, encoding, cb);
+      const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
+      const t = stamp(now());
+      let outText = "";
+      for (const piece of text.split(/(?<=\n)/)) {
+        outText += (atLineStart && piece !== "\n" ? `${t} ` : "") + piece;
+        atLineStart = piece.endsWith("\n");
+      }
+      return write(outText, typeof encoding === "string" ? encoding : undefined, typeof encoding === "function" ? encoding : cb);
+    };
+    return () => {
+      stream.write = write;
+    };
+  };
+  const undoOut = wrap(out);
+  const undoErr = wrap(err);
+  return () => {
+    undoOut();
+    undoErr();
+  };
+}
+
+/**
+ * Rotate `file` once it passes maxBytes: file.2 → file.3, file.1 → file.2, file → file.1, then the
+ * file is TRUNCATED IN PLACE. Copy-then-truncate, not rename, because the launcher holds the file
+ * open for appending: a renamed file would keep receiving every line. Returns true if it rotated.
+ */
+export async function rotateIfLarge(file, { maxBytes = ROTATE.maxBytes, keep = ROTATE.keep } = {}) {
+  let size;
+  try {
+    size = (await stat(file)).size;
+  } catch {
+    return false;
+  }
+  if (size < maxBytes) return false;
+  try {
+    await unlink(`${file}.${keep}`).catch(() => {});
+    for (let i = keep - 1; i >= 1; i--) await rename(`${file}.${i}`, `${file}.${i + 1}`).catch(() => {});
+    await copyFile(file, `${file}.1`);
+    await truncate(file, 0);
+    return true;
+  } catch {
+    // Windows can refuse to truncate a file another process holds; try again next time.
+    return false;
+  }
+}
+
+/** Keep run-logs/ to maxFiles files, none older than maxAgeMs. Returns how many were removed. */
+export async function pruneRunLogs(dir, { maxAgeMs = RUN_LOGS.maxAgeMs, maxFiles = RUN_LOGS.maxFiles, now = Date.now() } = {}) {
+  let names;
+  try {
+    names = await readdir(dir);
+  } catch {
+    return 0;
+  }
+  const files = [];
+  for (const name of names) {
+    if (!name.endsWith(".log")) continue;
+    try {
+      const s = await stat(join(dir, name));
+      if (s.isFile()) files.push({ name, mtime: s.mtimeMs });
+    } catch {
+      /* vanished meanwhile */
+    }
+  }
+  files.sort((a, b) => b.mtime - a.mtime); // newest first
+  let removed = 0;
+  for (const [i, f] of files.entries()) {
+    if (i < maxFiles && now - f.mtime <= maxAgeMs) continue;
+    try {
+      await unlink(join(dir, f.name));
+      removed++;
+    } catch {
+      /* in use or gone */
+    }
+  }
+  return removed;
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.729",
+  "version": "1.0.731",
   "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",
@@ -56,6 +56,8 @@
     "settings-transfer.mjs",
     "device-login.mjs",
     "daemon-control.mjs",
+    "log-policy.mjs",
+    "full-log-command.mjs",
     "poll-errors.mjs",
     "node-version.mjs",
     "clear-state.mjs",

package/terminal-layout.mjs

@@ -1059,7 +1059,9 @@ export function thoughtBlockRows(prose, { width = 76, collapsed = true, lines =
  * with nothing behind it now runs nothing, and `pending` is re-checked here as well — a
  * session file poisoned by the old build must not be able to restart the loop.
  */
-const RESUME_WORDS = /^(continue|resume|go on|keep going|carry on|proceed)\.?$/i;
+// "retry" / "try again" joined in task #247: the reported user typed "retry" after a cancel, it ran
+// as a new task with no history, and the model answered that nothing had ever been asked.
+const RESUME_WORDS = /^(continue|resume|go on|keep going|carry on|proceed|retry|try again)\.?$/i;
 
 /** Is this line a bare resume word? Shared so the guards cannot drift from the reader. */
 export function isResumeWord(line) {
@@ -1075,6 +1077,62 @@ export function resumeTask(line, pending) {
   return { task: real, resumed: true, nothingToResume: false };
 }
 
+/**
+ * Is `task` already the unanswered last turn of `history`? (task #247)
+ *
+ * The question is saved to history BEFORE its turn runs, and a turn that fails leaves it there.
+ * So when the next turn resumes it ("continue", "retry") or the user types it again, it is
+ * already the last entry, and pushing it again would send the model the same request twice.
+ */
+export function isPendingQuestion(history, task) {
+  const last = Array.isArray(history) ? history[history.length - 1] : null;
+  return last?.role === "user" && String(last.content ?? "").trim() === String(task ?? "").trim();
+}
+
+/**
+ * How an unanswered question's turn ended, as stored on its history entry (task #247).
+ *
+ *   stopped   — Ctrl+C AFTER the coding model was called. THE USER'S RULE: that is "too slow or
+ *               stuck", never "I changed my mind", so the request still stands.
+ *   failed    — the backend refused or the turn threw. Also still stands.
+ *   cancelled — Ctrl+C before the model was called: nothing began.
+ */
+const INTERRUPT_STATUSES = new Set(["stopped", "failed", "cancelled"]);
+export function interruptStatus(how) {
+  return INTERRUPT_STATUSES.has(how) ? how : "";
+}
+
+// Every tag starts with RECEIVED (the user's rule, task #247): a question that is in history is one
+// the terminal received from the user. The reported model, seeing no answer, told the user "It looks
+// like the earlier request didn't come through". It did; only the answer is missing.
+const INTERRUPT_TAGS = {
+  stopped:
+    "[RECEIVED by the terminal and started, then STOPPED before it finished: the user interrupted " +
+    "it because it was taking too long, NOT because they changed their mind. It still stands and " +
+    "is not finished; some steps may already have run, so check what exists before redoing anything.]",
+  failed:
+    "[RECEIVED by the terminal, but NOT FINISHED: it failed (the model backend errored) before it " +
+    "was answered. It still stands; some steps may already have run.]",
+  cancelled:
+    "[RECEIVED by the terminal, then cancelled by the user before any work began: nothing was done.]",
+};
+
+/**
+ * The history as the model should see it (task #247): each earlier unanswered question carries a
+ * one-line tag saying how it ended. Without one, an unanswered question reads exactly like an
+ * answered one, and the model may claim it was done.
+ *
+ * The tag goes only into what is SENT; the stored text stays the user's own words. The LAST entry
+ * is the current task and is never tagged. Returns new objects of {role, content} only.
+ */
+export function messagesForModel(history) {
+  if (!Array.isArray(history)) return [];
+  return history.map((m, i) => {
+    const tag = i < history.length - 1 && m?.role === "user" ? INTERRUPT_TAGS[m.status] : "";
+    return { role: m?.role, content: tag ? `${m.content}\n${tag}` : m?.content };
+  });
+}
+
 
 /**
  * Commands that still WORK but are no longer offered (task #153).