@tiens.nguyen/gu-cli 1.0.730 → 1.0.732

package/add-server.mjs

@@ -14,7 +14,7 @@
  * server kind ("dialect": an Ollama's /api/tags vs an OpenAI-compatible /v1/models) lives in
  * serverTarget() and listRequest().
  */
-import { defaultProviderUrl, ensureV1Root, hostLocality, isCancelWord, normalizeProviderUrl, parseProviderModels, MAX_MODELS_PER_SERVER } from "./coding-provider-setup.mjs";
+import { defaultProviderUrl, ensureV1Root, hostLocality, isAnthropicUrl, isCancelWord, modelListRequest, normalizeProviderUrl, parseProviderModels, MAX_MODELS_PER_SERVER } from "./coding-provider-setup.mjs";
 
 // Re-exported: the add-server screen's own name for the rule every URL prompt shares.
 export { isCancelWord };
@@ -112,10 +112,28 @@ export function serverTarget(dialect, typed) {
     host: r.host,
     locality: r.locality,
     cloud: false,
+    // The Claude API (#261): an OpenAI-compatible chat endpoint whose model LIST is Anthropic's own.
+    claude: isAnthropicUrl(r.url),
     roleUrl: () => r.url,
   };
 }
 
+/**
+ * A server this role cannot use → the lines that say why, or [] when it can (#261). The Claude API
+ * serves no embedding models — Anthropic's own docs send embeddings to Voyage AI — so saving it as
+ * the embedder would only fail at the first index, several steps into a turn.
+ */
+export function roleRefusal(role, target) {
+  if (role === "embed" && target?.claude) {
+    return [
+      "the Claude API has no embedding models — nothing saved.",
+      "Anthropic points to Voyage AI for embeddings (https://api.voyageai.com/v1),",
+      "or use an Ollama embedder such as nomic-embed-text.",
+    ];
+  }
+  return [];
+}
+
 /**
  * Does this server need a key? "required" | "optional" | "none".
  *   · An Ollama on this machine or the LAN answers anonymously — "none", not even asked.
@@ -129,8 +147,13 @@ export function keyRequirement(target) {
   return target.locality === "loopback" || target.locality === "private" ? "optional" : "required";
 }
 
-/** The request that lists a server's models: its URL and headers (a Bearer only when keyed). */
+/**
+ * The request that lists a server's models: its URL and headers. An Ollama's /api/tags takes a
+ * Bearer when keyed (the cloud); an OpenAI-compatible root goes through modelListRequest, which
+ * knows the Claude API lists with x-api-key + anthropic-version instead (#261).
+ */
 export function listRequest(target, key = "") {
+  if (target?.dialect !== "ollama") return modelListRequest(target.root ?? target.url, key);
   const k = String(key ?? "").trim();
   return { url: target.listUrl, headers: k && k !== "local" ? { Authorization: `Bearer ${k}` } : {} };
 }

package/agent-model-command.mjs

@@ -17,7 +17,7 @@
  * empty reads as "there are no models", which is never what a network error means.
  */
 
-import { modelRetired, ensureV1Root } from "./coding-provider-setup.mjs";
+import { modelRetired, ensureV1Root, isAnthropicUrl, modelListRequest } from "./coding-provider-setup.mjs";
 import { isOllamaCloudUrl } from "./coding-key-prompt.mjs";
 
 
@@ -243,8 +243,9 @@ export function agentListSource(settings) {
     (b) => b && ensureV1Root(String(b.url ?? "")).toLowerCase() === want
   );
   if (row && String(row.kind ?? "").trim() === "openai") {
-    // The row's url already ends at the /v1 root, so the models endpoint hangs directly off it.
-    return { url: `${ensureV1Root(String(row.url ?? ""))}/models`, dialect: "openai", row };
+    // The row's url already ends at the /v1 root, so the models endpoint hangs directly off it
+    // (with the Claude API's page size — #261, see modelListRequest).
+    return { url: modelListRequest(ensureV1Root(String(row.url ?? ""))).url, dialect: "openai", row };
   }
   return { url: agentTagsUrl(settings), dialect: "ollama", row: row ?? null };
 }
@@ -277,8 +278,12 @@ export function agentSourceNeedsKey(source) {
   return source.dialect === "openai" || isOllamaCloudUrl(String(row.url ?? ""));
 }
 
-/** The headers a model-list request needs — the bearer only when there is a key to send. */
-export function agentListHeaders(key) {
+/**
+ * The headers a model-list request needs — the bearer only when there is a key to send. The Claude
+ * API lists with x-api-key + anthropic-version instead (#261), so the URL is passed too.
+ */
+export function agentListHeaders(key, url = "") {
+  if (isAnthropicUrl(url)) return modelListRequest(url.replace(/\/models(\?.*)?$/, ""), key).headers;
   const k = String(key ?? "").trim();
   return k ? { Authorization: `Bearer ${k}` } : {};
 }

package/coding-provider-setup.mjs

@@ -198,6 +198,54 @@ export function modelsUrlFor(url) {
   return `${String(url ?? "").replace(/\/+$/, "")}/models`;
 }
 
+/**
+ * THE CLAUDE API (task #261). Chat goes through Anthropic's OpenAI-compatible endpoint — base
+ * https://api.anthropic.com/v1, the key as the usual Bearer — so a Claude row is an ordinary
+ * "openai" row everywhere a turn runs. Only LISTING differs (Anthropic docs, api/models/list):
+ * GET /v1/models takes `x-api-key` + `anthropic-version`, not a Bearer, and pages (default 20,
+ * max 1000). Decided by the host, which is Anthropic's own API — not a guess from a name.
+ */
+export const CLAUDE_API_URL = "https://api.anthropic.com/v1";
+export const ANTHROPIC_VERSION = "2023-06-01";
+
+export function isAnthropicUrl(url) {
+  try {
+    return new URL(String(url ?? "")).hostname.toLowerCase().replace(/\.$/, "") === "api.anthropic.com";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The request that lists a /v1 root's models → { url, headers }. Anthropic: its two headers and
+ * one page of up to 1000 (it lists a few dozen). Everyone else: a Bearer only when keyed — "local"
+ * is the placeholder a keyless local server is given, never a key.
+ */
+export function modelListRequest(url, key = "") {
+  const k = String(key ?? "").trim();
+  const keyed = Boolean(k) && k !== "local";
+  if (isAnthropicUrl(url)) {
+    return {
+      url: `${modelsUrlFor(url)}?limit=1000`,
+      headers: { "anthropic-version": ANTHROPIC_VERSION, ...(keyed ? { "x-api-key": k } : {}) },
+    };
+  }
+  return { url: modelsUrlFor(url), headers: keyed ? { Authorization: `Bearer ${k}` } : {} };
+}
+
+/**
+ * The hosted providers offered by name when adding one (#261), before "another URL". Claude has
+ * no embedding models (Anthropic points to Voyage AI), so it is not offered for the embedder.
+ */
+export function providerPresets(role = "coding") {
+  const all = [
+    { name: "Claude API (Anthropic)", url: CLAUDE_API_URL, roles: ["coding", "agent"] },
+    { name: "OpenAI", url: DEFAULT_PROVIDER_URL, roles: ["coding", "agent", "embed"] },
+    { name: "Kimi (Moonshot)", url: "https://api.moonshot.ai/v1", roles: ["coding", "agent"] },
+  ];
+  return all.filter((p) => p.roles.includes(role));
+}
+
 /** mlx_lm's placeholder, which is a mapping and not a model anyone can pick. */
 export const PLACEHOLDER_MODEL = "default_model";
 

package/daemon-control.mjs

@@ -321,8 +321,49 @@ export async function readBusyState() {
   }
 }
 
+/**
+ * WHOSE DAEMON IS IT (task #257)? The `ps` scan sees every gu worker on the machine, but a worker
+ * belongs to ONE ~/.gonext: it polls that home's API with that home's key. Counting another
+ * home's worker as ours meant gu never started its own, and every turn sat "queued — waiting for
+ * the worker". Ours = OUR pidfile names it, or its HOME is ours. HOME unknown (Windows, or not
+ * readable) → counted, exactly as before: a second poller on a guess is the worse mistake.
+ */
+export function ownsDaemon({ pid, pidFilePid, home, myHome = homedir() }) {
+  if (pidFilePid != null && pid === pidFilePid) return true;
+  if (home == null) return true;
+  const norm = (p) => String(p).replace(/[\\/]+$/, "");
+  return norm(home) === norm(myHome);
+}
+
+/** The HOME a process runs under → a path, or null when it cannot be read (Windows, gone, denied). */
+export async function daemonHome(pid) {
+  if (!pid || !Number.isFinite(pid)) return null;
+  if (process.platform === "linux") {
+    try {
+      const env = await readFile(join("/proc", String(pid), "environ"), "utf8");
+      const hit = env.split("\0").find((kv) => kv.startsWith("HOME="));
+      return hit ? hit.slice(5) : null;
+    } catch {
+      return null;
+    }
+  }
+  if (process.platform !== "darwin") return null;
+  // macOS: `ps eww` appends the environment to the command line (own processes only).
+  return new Promise((resolve) => {
+    execFile("ps", ["eww", "-o", "command=", "-p", String(pid)], { maxBuffer: 4 * 1024 * 1024 }, (err, stdout) => {
+      if (err) return resolve(null);
+      const m = / HOME=(\S+)/.exec(String(stdout || ""));
+      resolve(m ? m[1] : null);
+    });
+  });
+}
+
 export async function daemonStatus() {
-  const [pids, pidFilePid] = await Promise.all([findRunningDaemonPids(), readPidFile()]);
+  const [found, pidFilePid] = await Promise.all([findRunningDaemonPids(), readPidFile()]);
+  const pids = [];
+  for (const pid of found) {
+    if (ownsDaemon({ pid, pidFilePid, home: await daemonHome(pid) })) pids.push(pid);
+  }
   const pidFileIsDaemon =
     pidFilePid != null && (pids.includes(pidFilePid) || (await pidIsGuDaemon(pidFilePid)));
   const allPids = pidFileIsDaemon && !pids.includes(pidFilePid) ? [...pids, pidFilePid] : pids;

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

@@ -1013,16 +1013,229 @@ def _host_of(url) -> str:
         return str(url or "")
 
 
+def _is_anthropic_url(url: str) -> bool:
+    """The Claude API (task #261): OpenAI-compatible chat, but its /v1/models takes x-api-key +
+    anthropic-version rather than a Bearer, and pages. Decided by Anthropic's own host."""
+    from urllib.parse import urlparse
+    return (urlparse(url or "").hostname or "").lower().rstrip(".") == "api.anthropic.com"
+
+
+def _model_list_request(base_url: str, api_key: str = ""):
+    """(url, headers) that list the models of a /v1 root — same rule as the terminal's
+    modelListRequest (coding-provider-setup.mjs)."""
+    url = (base_url or "").rstrip("/") + "/models"
+    headers = {"Accept": "application/json"}
+    keyed = bool(api_key) and api_key != "local"
+    if _is_anthropic_url(base_url):
+        headers["anthropic-version"] = "2023-06-01"
+        if keyed:
+            headers["x-api-key"] = api_key
+        return url + "?limit=1000", headers
+    if keyed:
+        headers["Authorization"] = f"Bearer {api_key}"
+    return url, headers
+
+
+# ---- the Claude API, natively, for prompt caching (task #262) ----------------------------------
+#
+# Anthropic's OpenAI-compatible endpoint (#261) does NOT cache: every agent step re-sent the whole
+# prompt at full price, and measured over 1,308 steps 96.4% of what a step reads is repetition. The
+# native Messages API caches a PREFIX, but only where the request marks it. So the coding model on
+# api.anthropic.com talks to the native API through this adapter, which speaks the one interface the
+# rest of the agent already uses — client.chat.completions.create(), streamed or not, returning
+# OpenAI-shaped chunks — so streaming, the runaway guards, token counts and the cache counters work
+# unchanged. Our prompt order is already stable-first (#86); the adapter only marks it:
+#   1. the system prompt (the scaffold — identical for the whole gu session);
+#   2. the end of the STATIC tool reference inside the first user message, split off the volatile
+#      tail at "----- YOUR TASK -----" (date, deploy target, folder overview, the task);
+#   3. top-level automatic caching for the step history that grows inside a turn.
+# Default 5-minute TTL: steps inside a turn are well under 5 minutes apart.
+
+_TASK_SPLIT_MARKER = "\n----- YOUR TASK -----\n"
+
+
+def _anthropic_image_block(url: str):
+    """An OpenAI image_url → an Anthropic image block (data: URLs as base64, else by URL)."""
+    m = re.match(r"^data:([^;,]+);base64,(.*)$", url or "", re.S)
+    if m:
+        return {"type": "image", "source": {"type": "base64", "media_type": m.group(1), "data": m.group(2)}}
+    return {"type": "image", "source": {"type": "url", "url": url}}
+
+
+def _anthropic_blocks(content) -> list:
+    """OpenAI message content (a string or a list of parts) → Anthropic content blocks.
+    Empty text is dropped: the Messages API rejects an empty text block."""
+    if isinstance(content, str):
+        return [{"type": "text", "text": content}] if content.strip() else []
+    out = []
+    for part in content or []:
+        if not isinstance(part, dict):
+            continue
+        if part.get("type") == "text" and str(part.get("text") or "").strip():
+            out.append({"type": "text", "text": str(part["text"])})
+        elif part.get("type") == "image_url":
+            url = (part.get("image_url") or {}).get("url") if isinstance(part.get("image_url"), dict) else part.get("image_url")
+            if url:
+                out.append(_anthropic_image_block(str(url)))
+    return out
+
+
+def _anthropic_request(kw: dict) -> dict:
+    """OpenAI chat.completions kwargs → Anthropic messages.create kwargs, with the cache marks."""
+    ephemeral = {"type": "ephemeral"}
+    system_blocks, messages = [], []
+    for m in kw.get("messages") or []:
+        role = m.get("role") if isinstance(m, dict) else getattr(m, "role", "")
+        content = m.get("content") if isinstance(m, dict) else getattr(m, "content", "")
+        role = str(getattr(role, "value", role) or "")
+        blocks = _anthropic_blocks(content)
+        if not blocks:
+            continue
+        if role in ("system", "developer"):
+            system_blocks.extend(b for b in blocks if b["type"] == "text")
+            continue
+        role = "assistant" if role == "assistant" else "user"
+        if messages and messages[-1]["role"] == role:
+            messages[-1]["content"].extend(blocks)  # the API would merge them anyway; be explicit
+        else:
+            messages.append({"role": role, "content": blocks})
+    if not messages or messages[0]["role"] != "user":
+        messages.insert(0, {"role": "user", "content": [{"type": "text", "text": "(start)"}]})
+    # No assistant prefill: current Claude models reject a conversation that ENDS on the assistant.
+    if messages[-1]["role"] == "assistant":
+        messages.append({"role": "user", "content": [{"type": "text", "text": "Continue."}]})
+
+    # Mark 2: the static reference at the head of the first user message.
+    first = messages[0]["content"]
+    for i, b in enumerate(first):
+        if b["type"] == "text" and _TASK_SPLIT_MARKER in b["text"]:
+            head, tail = b["text"].split(_TASK_SPLIT_MARKER, 1)
+            first[i:i + 1] = [
+                {"type": "text", "text": head, "cache_control": ephemeral},
+                {"type": "text", "text": _TASK_SPLIT_MARKER.lstrip("\n") + tail},
+            ]
+            break
+    # Mark 1: the system prompt.
+    if system_blocks:
+        system_blocks[-1] = {**system_blocks[-1], "cache_control": ephemeral}
+
+    stops = [s for s in (kw.get("stop") or []) if isinstance(s, str) and s.strip()]
+    req = {
+        "model": kw.get("model"),
+        "max_tokens": int(kw.get("max_tokens") or kw.get("max_completion_tokens") or 32000),
+        "messages": messages,
+        # Mark 3: automatic caching for the growing tail (the step history).
+        "cache_control": ephemeral,
+    }
+    if system_blocks:
+        req["system"] = system_blocks
+    if stops:
+        req["stop_sequences"] = stops[:8]
+    # NO temperature / top_p: current Claude models reject sampling parameters with a 400, and
+    # the thinking / effort settings are left at the model's defaults so they never vary per
+    # request (a change there invalidates the cache).
+    return req
+
+
+_ANTHROPIC_FINISH = {"end_turn": "stop", "stop_sequence": "stop", "max_tokens": "length",
+                     "refusal": "stop", "pause_turn": "stop", "tool_use": "tool_calls"}
+
+
+def _anthropic_usage(u) -> "types.SimpleNamespace":
+    """Anthropic usage → the OpenAI-shaped usage the agent reads. prompt_tokens is the WHOLE prompt
+    (input_tokens is only the uncached remainder), and the cache counts ride along under their own
+    names — _cached_tokens_from_usage already reads cache_read_input_tokens."""
+    import types
+    g = (lambda n: int(_usage_field(u, n) or 0))
+    cr, cw, inp = g("cache_read_input_tokens"), g("cache_creation_input_tokens"), g("input_tokens")
+    return types.SimpleNamespace(prompt_tokens=inp + cr + cw, completion_tokens=g("output_tokens"),
+                                 cache_read_input_tokens=cr, cache_creation_input_tokens=cw)
+
+
+class _AnthropicChatAdapter:
+    """client.chat.completions.create() backed by Anthropic's native Messages API (task #262)."""
+
+    def __init__(self, api_key: str = "", base_url: str = "", timeout=None, sdk_client=None):
+        if sdk_client is None:
+            import anthropic  # the caller checked it imports
+            kwargs = {"api_key": api_key or None, "max_retries": 0}
+            root = re.sub(r"/v1/?$", "", (base_url or "").rstrip("/"))
+            if root:
+                kwargs["base_url"] = root
+            if timeout:
+                kwargs["timeout"] = timeout
+            if _PROXY_URL:
+                kwargs["http_client"] = anthropic.DefaultHttpxClient(proxy=_PROXY_URL)
+            sdk_client = anthropic.Anthropic(**kwargs)
+        self._sdk = sdk_client
+        import types
+        self.chat = types.SimpleNamespace(completions=types.SimpleNamespace(create=self._create))
+
+    def _create(self, **kw):
+        req = _anthropic_request(kw)
+        if kw.get("stream"):
+            return self._stream(req)
+        msg = self._sdk.messages.create(**req)
+        import types
+        text = "".join(getattr(b, "text", "") or "" for b in (msg.content or []) if getattr(b, "type", "") == "text")
+        return types.SimpleNamespace(
+            choices=[types.SimpleNamespace(
+                message=types.SimpleNamespace(role="assistant", content=text, tool_calls=None),
+                finish_reason=_ANTHROPIC_FINISH.get(getattr(msg, "stop_reason", "") or "", "stop"))],
+            usage=_anthropic_usage(getattr(msg, "usage", None)))
+
+    def _stream(self, req):
+        import types
+
+        def chunk(content=None, reasoning=None, finish=None, usage=None):
+            delta = types.SimpleNamespace(content=content, reasoning=reasoning, reasoning_content=None,
+                                          role=None, tool_calls=None)
+            choices = [] if (content is None and reasoning is None and finish is None) else [
+                types.SimpleNamespace(delta=delta, finish_reason=finish, index=0)]
+            return types.SimpleNamespace(choices=choices, usage=usage)
+
+        usage = {}
+        stop_reason = ""
+        with self._sdk.messages.stream(**req) as events:
+            for ev in events:
+                et = getattr(ev, "type", "")
+                if et == "message_start":
+                    u = getattr(getattr(ev, "message", None), "usage", None)
+                    for n in ("input_tokens", "cache_read_input_tokens", "cache_creation_input_tokens", "output_tokens"):
+                        usage[n] = int(_usage_field(u, n) or 0)
+                elif et == "content_block_delta":
+                    d = getattr(ev, "delta", None)
+                    dt = getattr(d, "type", "")
+                    if dt == "text_delta" and getattr(d, "text", ""):
+                        yield chunk(content=d.text)
+                    elif dt == "thinking_delta" and getattr(d, "thinking", ""):
+                        yield chunk(reasoning=d.thinking)
+                elif et == "message_delta":
+                    stop_reason = getattr(getattr(ev, "delta", None), "stop_reason", "") or stop_reason
+                    out = _usage_field(getattr(ev, "usage", None), "output_tokens")
+                    if out is not None:
+                        usage["output_tokens"] = int(out)
+        if stop_reason == "refusal":
+            _log("claude: the model declined this request (stop_reason=refusal)")
+        yield chunk(content="", finish=_ANTHROPIC_FINISH.get(stop_reason, "stop"))
+        yield chunk(usage=_anthropic_usage(usage))
+
+
+def _anthropic_sdk_available() -> bool:
+    try:
+        import anthropic  # noqa: F401
+        return True
+    except Exception:  # noqa: BLE001
+        return False
+
+
 def _list_model_ids(base_url, api_key=""):
     """Return the model ids an OpenAI-compatible server reports at {base_url}/models.
 
     `base_url` already ends with /v1. Returns [] on any failure so callers can
     fall back.
     """
-    url = base_url.rstrip("/") + "/models"
-    headers = {"Accept": "application/json"}
-    if api_key and api_key != "local":
-        headers["Authorization"] = f"Bearer {api_key}"
+    url, headers = _model_list_request(base_url, api_key)
     req = urllib.request.Request(url, method="GET", headers=headers)
     try:
         with urllib.request.urlopen(req, timeout=10, context=_ssl_context_insecure()) as resp:
@@ -2880,7 +3093,7 @@ def _provider_reason(err, limit: int = 180) -> str:
 _CTX_WINDOW_CACHE: dict = {}
 
 
-def _model_context_window(base_url: str, model_id: str) -> int:
+def _model_context_window(base_url: str, model_id: str, api_key: str = "") -> int:
     """The coding model's REAL context window, or 0 when it cannot be known.
 
     Ollama knows this exactly and will tell us for free (no GPU work): /api/show returns the
@@ -2946,14 +3159,17 @@ def _model_context_window(base_url: str, model_id: str) -> int:
     #    say keeps win at 0 and the caller falls back with its eyes open.
     if win <= 0:
         try:
-            req = urllib.request.Request(f"{root}/v1/models", method="GET")
+            list_url, list_headers = _model_list_request(f"{root}/v1", api_key)
+            req = urllib.request.Request(list_url, method="GET", headers=list_headers)
             with urllib.request.urlopen(req, timeout=10, context=_ssl_context()) as resp:
                 data = json.loads(resp.read().decode("utf-8", "replace"))
             for row in (data.get("data") or []):
                 if str(row.get("id") or "") != str(model_id):
                     continue
+                # max_input_tokens: the Claude API's own field (#261) — its input cap, which is
+                # exactly the number this protects (see _KNOWN_CTX_WINDOWS on why input, not window).
                 for field in ("max_model_len", "context_length", "context_window",
-                              "max_context_length"):
+                              "max_context_length", "max_input_tokens"):
                     v = row.get(field)
                     if isinstance(v, int) and v > 4096:
                         win = v
@@ -3042,6 +3258,11 @@ _KNOWN_CTX_WINDOWS: list = [
     # Kimi K3's own README states 1048576. An earlier version of this table said 256,000 — off by
     # a factor of four, on the model this feature was built for.
     (r"^kimi-k3", 1_048_576, "https://github.com/MoonshotAI/Kimi-K3/blob/main/README.md"),
+    # Claude (#261). The Models API reports max_input_tokens itself (read above), so these only
+    # matter when the list cannot be read. Haiku 4.5 first: the general row would give it 1M.
+    (r"^claude-haiku-4-5", 200_000, "https://platform.claude.com/docs/en/about-claude/models/overview"),
+    (r"^claude-(opus|sonnet|fable|mythos)-(5|4-[678])", 1_000_000,
+     "https://platform.claude.com/docs/en/about-claude/models/overview"),
     (r"^kimi-k2", 256_000, "https://platform.kimi.ai/docs/api/chat.en-US"),
     (r"^kimi-k1", 128_000, "unverified — no vendor page found; corrected on first refusal"),
     # These three state their size in the name, which is its own citation.
@@ -4160,64 +4381,6 @@ def _ssl_context():
         return ssl.create_default_context()
 
 
-def _pdf_upload_via_api(api_base: str, worker_key: str, file_name: str,
-                        pdf_bytes: bytes) -> str:
-    """Ask the API to presign an S3 upload, PUT the PDF bytes, return the download URL.
-
-    Keeps all AWS credentials on the API/Lambda — the worker only holds its worker key.
-    """
-    import urllib.request as _u
-    import urllib.error as _ue
-
-    ctx = _ssl_context()
-    base = (api_base or "").rstrip("/")
-    if not base or not worker_key:
-        raise RuntimeError("PDF upload is not available: worker API base/key missing.")
-
-    # 1) Presign.
-    req = _u.Request(
-        f"{base}/api/worker/pdf-upload-url",
-        data=json.dumps({"fileName": file_name}).encode("utf-8"),
-        headers={
-            "Content-Type": "application/json",
-            "X-Worker-Key": worker_key,
-        },
-        method="POST",
-    )
-    try:
-        with _u.urlopen(req, timeout=30, context=ctx) as resp:
-            ref = json.loads(resp.read().decode("utf-8"))
-    except _ue.HTTPError as e:  # noqa: PERF203
-        detail = e.read().decode("utf-8", "replace")[:300]
-        raise RuntimeError(f"Could not get a PDF upload URL (HTTP {e.code}): {detail}")
-    except _ue.URLError as e:
-        raise RuntimeError(
-            f"Could not reach the API at {base} to presign the upload "
-            f"({getattr(e, 'reason', e)}). Is the worker API deployed/online?"
-        )
-    put_url = ref.get("putUrl")
-    get_url = ref.get("getUrl")
-    if not put_url or not get_url:
-        raise RuntimeError("PDF upload URL response was incomplete.")
-
-    # 2) Upload the bytes to the presigned PUT URL.
-    put_req = _u.Request(
-        put_url, data=pdf_bytes,
-        headers={"Content-Type": "application/pdf"},
-        method="PUT",
-    )
-    try:
-        with _u.urlopen(put_req, timeout=60, context=ctx) as up:
-            if up.status not in (200, 201, 204):
-                raise RuntimeError(f"S3 upload failed (HTTP {up.status}).")
-    except _ue.HTTPError as e:  # noqa: PERF203
-        detail = e.read().decode("utf-8", "replace")[:200]
-        raise RuntimeError(f"S3 upload failed (HTTP {e.code}): {detail}")
-    except _ue.URLError as e:
-        raise RuntimeError(f"S3 upload could not connect ({getattr(e, 'reason', e)}).")
-    return get_url
-
-
 # Generic download support (task #102) — deliver ANY workspace file/folder as a download.
 _DOWNLOAD_MAX_BYTES = 100 * 1024 * 1024  # 100 MB cap on what we'll upload for download
 
@@ -4249,8 +4412,20 @@ def _artifact_local_path(file_name: str) -> str:
     return candidate
 
 
+def _save_artifact_locally(file_name: str, data: bytes, summary: str, why: str = "") -> str:
+    dest = _artifact_local_path(file_name)
+    with open(dest, "wb") as fh:
+        fh.write(data)
+    _emit({"type": "step", "text": f"Saved → {dest}"})
+    _log(f"artifact saved locally path={_c(dest)} bytes={len(data)}")
+    return (f"✅ \"{os.path.basename(dest)}\" is ready ({summary}).\n"
+            + (f"{why}\n" if why else "")
+            + f"Saved on this machine:\n{dest}")
+
+
 def _deliver_artifact(file_name: str, data: bytes, content_type: str, summary: str,
-                      *, local: bool, api_base: str = "", worker_key: str = "") -> str:
+                      *, local: bool, api_base: str = "", worker_key: str = "",
+                      ask_s3_setup=None) -> str:
     """Hand a finished artifact to the user — as a FILE ON THIS MACHINE, or as a link.
 
     LOCAL IS THE DEFAULT IN CLIENT EXPERT and it is not a degraded fallback: when the user is
@@ -4262,14 +4437,26 @@ def _deliver_artifact(file_name: str, data: bytes, content_type: str, summary: s
     the delivery itself.
     """
     if local:
-        dest = _artifact_local_path(file_name)
-        with open(dest, "wb") as fh:
-            fh.write(data)
-        _emit({"type": "step", "text": f"Saved → {dest}"})
-        _log(f"artifact saved locally path={dest!r} bytes={len(data)}")
-        return (f"✅ \"{os.path.basename(dest)}\" is ready ({summary}).\n"
-                f"Saved on this machine:\n{dest}")
-    url = _artifact_upload_via_api(api_base, worker_key, file_name, data, content_type)
+        return _save_artifact_locally(file_name, data, summary)
+    # PRIVATE MODE WITHOUT THE USER'S OWN S3 (task #252): the API says so instead of uploading to
+    # anyone else's bucket. Ask whether to set S3 up now; otherwise the file stays on this computer.
+    try:
+        url = _artifact_upload_via_api(api_base, worker_key, file_name, data, content_type)
+    except _S3NotSetUp:
+        chose = False
+        try:
+            chose = bool(ask_s3_setup and ask_s3_setup())
+        except Exception as e:  # noqa: BLE001 — asking must never lose the file
+            _log(f"s3 setup question failed: {type(e).__name__}")
+        if not chose:
+            return _save_artifact_locally(
+                file_name, data, summary,
+                "S3 is not set up, so it was not uploaded anywhere (run /s3 in gu to use your own bucket).")
+        try:
+            url = _artifact_upload_via_api(api_base, worker_key, file_name, data, content_type)
+        except _S3NotSetUp:
+            return _save_artifact_locally(
+                file_name, data, summary, "S3 is still not set up, so it was not uploaded anywhere.")
     _emit({"type": "step", "text": f"Download ready → {file_name}"})
     _log(f"artifact uploaded name={file_name!r} bytes={len(data)}")
     return (f"✅ \"{file_name}\" is ready ({summary}).\n"
@@ -4292,10 +4479,15 @@ def _content_type_for(name: str) -> str:
     return _DOWNLOAD_CONTENT_TYPES.get(ext, "application/octet-stream")
 
 
+class _S3NotSetUp(RuntimeError):
+    """Private mode, and the user has no S3 of their own (task #252). The API refused to sign —
+    without touching the network — so the caller asks the user, or saves the file on disk."""
+
+
 def _artifact_upload_via_api(api_base: str, worker_key: str, file_name: str,
                              data: bytes, content_type: str = "") -> str:
     """Presign a GENERIC S3 upload (any file type), PUT the bytes, return the download URL.
-    Like _pdf_upload_via_api but preserves the real extension + Content-Type. The PUT
+    Like the old PDF-only uploader, but preserves the real extension + Content-Type. The PUT
     Content-Type MUST match what the presign signed, so we send content_type in the presign
     request and PUT with the value the API echoes back (task #102)."""
     import urllib.error as _ue
@@ -4316,6 +4508,8 @@ def _artifact_upload_via_api(api_base: str, worker_key: str, file_name: str,
             ref = json.loads(resp.read().decode("utf-8"))
     except _ue.HTTPError as e:  # noqa: PERF203
         detail = e.read().decode("utf-8", "replace")[:300]
+        if e.code == 409 and "S3_NOT_SET_UP" in detail:
+            raise _S3NotSetUp(detail) from None
         raise RuntimeError(f"Could not get an upload URL (HTTP {e.code}): {detail}")
     except _ue.URLError as e:
         raise RuntimeError(
@@ -6448,7 +6642,7 @@ def _ws_request_approval(api_base, worker_key, job_id, command, reason, deadline
     the coder can be slow, so it passes a much larger deadline (#110): the REPL now
     dismisses the picker the instant this job ends, and the worker's own job-cap kills a
     truly-abandoned run, so a long wait here is safe and lets a real "Yes" actually land.
-    Mirrors _pdf_upload_via_api's worker-key auth — no new creds on the worker."""
+    Same worker-key auth as _artifact_upload_via_api — no new creds on the worker."""
     import urllib.request as _u
     import uuid as _uuid
     import time as _t
@@ -6485,6 +6679,8 @@ def _ws_request_approval(api_base, worker_key, job_id, command, reason, deadline
         _emit({"type": "step", "text": "Awaiting your choice: continue past the step budget?"})
     elif command.startswith("__COMPACT__::"):
         _emit({"type": "step", "text": "Awaiting your choice: compact the context?"})
+    elif command.startswith("__S3SETUP__::"):
+        _emit({"type": "step", "text": "Awaiting your choice: set up S3, or save on this computer?"})
     else:
         _emit({"type": "step", "text": f"Awaiting your approval to run: {command[:70]}"})
     deadline = _t.time() + max(30, int(deadline_s))  # per-call; risky=180s, __MAXSTEP__ long
@@ -6863,6 +7059,17 @@ def run_agent_chat(cfg):
     # risky command and asks the user via the API instead of hard-blocking it.
     _job_id = (cfg.get("jobId") or "").strip()
     _interactive_approval = bool(cfg.get("interactiveApproval"))
+
+    def _ask_s3_setup() -> bool:
+        """Private mode, a file to hand over, no S3 of the user's own (task #252): ask in the
+        terminal whether to set it up now. True only when it is set up AND tested. No terminal to
+        ask → False, and the file is saved on this computer. The wait covers typing the setup."""
+        if not (_interactive_approval and _job_id):
+            return False
+        return _ws_request_approval(
+            worker_api_base, worker_api_key, _job_id,
+            "__S3SETUP__::S3 is not set up for your files. Set it up now, or save this file on this computer?",
+            "", deadline_s=900)
     # "accept edits on/off" from the terminal's bar (task #179). DEFAULTS TO TRUE, and has to:
     # an older terminal, the web, and any caller that does not know about the flag send nothing,
     # and reading a missing flag as "off" would put a Yes/No question in front of every command
@@ -7770,6 +7977,7 @@ def run_agent_chat(cfg):
                 out = _deliver_artifact(
                     f"{doc_title}.pdf", pdf_bytes, "application/pdf", "PDF",
                     local=local_artifacts, api_base=worker_api_base, worker_key=worker_api_key,
+                    ask_s3_setup=_ask_s3_setup,
                 )
             except Exception as e:  # noqa: BLE001
                 _log(f"PDF fast-path delivery error: {type(e).__name__}: {e!r}\n{traceback.format_exc()}")
@@ -8696,23 +8904,22 @@ def run_agent_chat(cfg):
             _last_obs["text"] = msg
             return msg
 
-        # 3) Upload via the API-presigned PUT (no AWS creds on the worker).
+        # 3) Hand it over: a link via the API-presigned PUT (no AWS creds on the worker), or — in
+        #    private mode without the user's own S3 — on this computer (task #252, same path as the
+        #    PDF fast-path and create_download).
         _emit({"type": "step", "text": "Uploading PDF…"})
         file_name = f"{doc_title}.pdf"
         try:
-            download_url = _pdf_upload_via_api(
-                worker_api_base, worker_api_key, file_name, pdf_bytes
+            out = _deliver_artifact(
+                file_name, pdf_bytes, "application/pdf", "PDF",
+                local=local_artifacts, api_base=worker_api_base, worker_key=worker_api_key,
+                ask_s3_setup=_ask_s3_setup,
             )
         except Exception as e:  # noqa: BLE001 — network / API errors must not crash the tool
             _log(f"create_pdf upload error: {type(e).__name__}: {e!r}\n{traceback.format_exc()}")
             msg = f"PDF was created but could not be uploaded: {str(e)[:200]}"
             _last_obs["text"] = msg
             return msg
-
-        out = (
-            f"✅ Your PDF \"{doc_title}\" is ready.\n"
-            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={_c(doc_title, r=True)} bytes={len(pdf_bytes)}")
         _pdf_state["last"] = {
@@ -8810,6 +9017,7 @@ def run_agent_chat(cfg):
             out = _deliver_artifact(
                 file_name, data, content_type, summary,
                 local=local_artifacts, api_base=worker_api_base, worker_key=worker_api_key,
+                    ask_s3_setup=_ask_s3_setup,
             )
             _last_obs["text"] = out
             return out
@@ -8838,7 +9046,7 @@ def run_agent_chat(cfg):
     # Per-turn, like _compact_state above: the high-water mark that decides when a trim
     # pass is worth breaking the prefix cache for. See _trim_due.
     _trim_state: dict = {"next_at": _TRIM_FIRST_AT_CHARS}
-    _ctx_window = _model_context_window(coding_base_url, coding_model_id)
+    _ctx_window = _model_context_window(coding_base_url, coding_model_id, coding_api_key)
     _compact_at = _compact_threshold(_ctx_window)
     if _ctx_window:
         # SAY WHICH SOURCE ANSWERED. A measured window and a remembered one are not the same
@@ -9239,6 +9447,22 @@ def run_agent_chat(cfg):
             self._no_code_streak = 0
             super().__init__(*a, **kw)
 
+        def create_client(self):
+            """The Claude API goes native, for prompt caching (task #262); everything else — and
+            the Claude API when Anthropic's SDK is not installed — keeps the OpenAI client."""
+            ck = self.client_kwargs or {}
+            base = str(ck.get("base_url") or "")
+            if _is_anthropic_url(base):
+                if _anthropic_sdk_available():
+                    _log("claude: native Messages API with prompt caching")
+                    return _AnthropicChatAdapter(api_key=str(ck.get("api_key") or ""), base_url=base,
+                                                 timeout=ck.get("timeout"))
+                _log("claude: the anthropic package is not installed — using the OpenAI-compatible "
+                     "endpoint, which does not cache")
+                _emit({"type": "step", "text": "Claude without prompt caching — every step pays full "
+                                               "price. Install it once: pip install anthropic"})
+            return super().create_client()
+
         def _stream_key(self):
             """(server, model) — the pair the streaming memo is keyed on. `api_base` is a
             constructor ARGUMENT in smolagents, not an attribute: it survives only inside

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).
@@ -5067,10 +5088,13 @@ async function startLogPolicy() {
     };
     await housekeep();
     let ticks = 0;
+    const { REFRESH_FLAG } = await import("./full-log-command.mjs");
     setInterval(() => {
       ticks++;
       void (async () => {
-        if (ticks % Math.round(lp.REFRESH_MS / 60_000) === 0) await logPolicy.refresh();
+        // `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();

package/gu-repl.mjs

@@ -532,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
@@ -800,12 +800,13 @@ const COMMANDS = [
   { name: "/host-mode", desc: "undo client mode — run agent turns on THIS machine again" },
   { name: "/server", desc: "pick a deployment server (host/user) for this session" },
   { name: "/proxy", usage: "/proxy [show|set|on|off|clear|test]", desc: "route MODEL calls through an HTTP proxy (local calls always go direct)" },
-  { name: "/s3", usage: "/s3 [test]", desc: "set up the S3 bucket the RAG index lives in, and check the AWS keys work" },
+  { name: "/s3", usage: "/s3 [test]", desc: "set up YOUR S3 bucket (RAG index, and the PDFs/downloads gu makes) and check the AWS keys work — without it, files are saved on this computer" },
   { name: "/context-window", usage: "/context-window [tokens|auto]", desc: "tell gu how big the coding model's context is — hosted models cannot be probed" },
   { name: "/save-settings", usage: "/save-settings [name|path]", desc: "write this account's providers, models and key NAMES to a file in your home folder (no secrets) — asks for a name, Enter keeps gu-settings.json" },
   { 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" },
 ];
@@ -1514,6 +1515,11 @@ rl.on("line", (l) => {
   if (following) {
     rl.line = "";
     rl.cursor = 0;
+    // No frozen row to carry the notice (piped, or a window too short to pin one): say it once
+    // here, on the Enter that would have sent it (#258).
+    if (typedDuringTurn && !barPinned()) {
+      process.stdout.write(dim(`\n  ${TYPED_DURING_TURN_NOTICE.trim()}\n`));
+    }
     return;
   }
   // Enter left the cursor on the row where the live slash-hint started — erase it so the
@@ -2262,7 +2268,12 @@ function frozenZone() {
   const zone = inputZoneRows({
     headControl,
     width,
-    prompt: secretInput && secretPrompt ? accent(secretPrompt) : inlinePrompt ? accent(inlinePrompt) : PROMPT,
+    // #258: typing during a turn is not sent — the row says so (an ask() label still comes first).
+    prompt: secretInput && secretPrompt
+      ? accent(secretPrompt)
+      : following && typedDuringTurn && !inlinePrompt
+        ? yellow(typedNotice(width))
+        : inlinePrompt ? accent(inlinePrompt) : PROMPT,
     // WHILE A SECRET IS OPEN, THIS ROW IS THE PROMPT — "kimi-k3 API key: ••••" rather than
     // ">> ••••". Same row, same masking; what changes is that it now says what it wants. The
     // width is measured, not assumed: the label is caller-supplied and every offset in here
@@ -2270,9 +2281,11 @@ function frozenZone() {
     promptCols:
       secretInput && secretPrompt
         ? visibleLen(secretPrompt)
-        : inlinePrompt
-          ? visibleLen(inlinePrompt)
-          : PROMPT_COLS,
+        : following && typedDuringTurn && !inlinePrompt
+          ? visibleLen(typedNotice(width))
+          : inlinePrompt
+            ? visibleLen(inlinePrompt)
+            : PROMPT_COLS,
     // A SECRET IS MASKED HERE, NOT HIDDEN (task #191, and a #127 hole the frozen zone opened).
     // askSecret mutes readline's echo, but this zone does not go through readline — gu
     // renders it from rl.line — so while the key prompt was up, the characters being typed
@@ -3620,6 +3633,13 @@ if (process.stdin.isTTY) {
       // so the switch did nothing while the agent was thinking — which is exactly when a user
       // watching it reach for commands wants to change it.
       if (key && key.name === "tab" && key.shift) switchEditMode();
+      // A printable key (or Enter after one) means the user is typing a question that will not
+      // be sent — say so in the input row now, not after they have typed the whole thing (#258).
+      const printable = typeof _ch === "string" && _ch.length > 0 && !/[\x00-\x1f\x7f]/.test(_ch) && !key?.ctrl && !key?.meta;
+      if (printable && !typedDuringTurn) {
+        typedDuringTurn = true;
+        if (barPinned()) paintBar();
+      }
       rl.line = "";
       rl.cursor = 0;
       rl.historyIndex = -1;
@@ -5445,7 +5465,9 @@ async function changeProviderModel(ps, rows, p) {
   // will refuse, and then the id is typed, which always works.
   const probe = await withPendingStatus(`asking ${p.host} what it has`, async () => {
     try {
-      const res = await proxyFetch(ps.modelsUrlFor(p.url), { signal: AbortSignal.timeout(10_000) });
+      // Keyless, as above — but in the list's own dialect (the Claude API's headers, #261).
+      const lr = ps.modelListRequest(p.url);
+      const res = await proxyFetch(lr.url, { headers: lr.headers, signal: AbortSignal.timeout(10_000) });
       if (!res.ok) return { status: res.status };
       return { body: await res.json().catch(() => null) };
     } catch (err) {
@@ -5667,7 +5689,21 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
       console.log(red(`  "${presetUrl}" is ${target.why} — nothing changed.\n`));
       return;
     }
-  } else {
+  } else if (dialect === "openai") {
+    // THE HOSTED PROVIDERS BY NAME (#261): Claude, OpenAI, Kimi — then any other URL. One picker in
+    // the one add flow, so every role that adds a provider offers the same list (the embedder
+    // without Claude, which serves no embeddings).
+    const presets = ps.providerPresets(role);
+    const rowsShown = [...presets.map((p) => `${p.name}${dim(`  · ${p.url}`)}`), "another URL…"];
+    console.log(dim(`  Which provider?  (${PICK_HINT})`));
+    const pi = await pickFromList(rowsShown, 0);
+    if (pi < 0) {
+      console.log(dim("  (nothing saved)\n"));
+      return;
+    }
+    if (pi < presets.length) target = as.serverTarget("openai", presets[pi].url);
+  }
+  if (!target && !presetUrl) {
     const dflt = as.defaultServerUrl(role, dialect, settings, existing);
     console.log(dim(dialect === "ollama"
       ? "  An Ollama server: this machine, a box on your network, or https://ollama.com (needs a key)."
@@ -5696,6 +5732,16 @@ async function addServer({ role = "coding", dialect = "openai", url: presetUrl =
     return;
   }
   const host = target.host;
+  const refusal = as.roleRefusal(role, target);
+  if (refusal.length) {
+    for (const l of refusal) console.log(GUTTER + yellow(l));
+    console.log("");
+    return;
+  }
+  // Claude as the CODER: prompt caching needs Anthropic's SDK (#262) — offer it once, here.
+  if (target.claude && role === "coding") {
+    await md.ensureClaudeSdk({ log: (l) => console.log(GUTTER + dim(l.trim())), confirm: (q) => askYesNo(`  ${q}`, true) });
+  }
 
   // --- 2. the server's key --------------------------------------------------------------
   // AN EXISTING SERVER IS REUSED, never stored twice (two rows for one URL would be two picker
@@ -6674,7 +6720,7 @@ async function chooseAgentModel() {
       // terminal that ignored the command. The host is named in the label because on a slow
       // one that IS the useful information while you wait.
       const r = await withPendingStatus(`asking ${hostOf(url)} for its models`, () =>
-        proxyFetch(url, { headers: am.agentListHeaders(listKey), signal: AbortSignal.timeout(10000) })
+        proxyFetch(url, { headers: am.agentListHeaders(listKey, url), signal: AbortSignal.timeout(10000) })
       );
       if (!r.ok) failure = `HTTP ${r.status}`;
       if (!r.ok && needsKey && (r.status === 401 || r.status === 403)) keyProblem = true;
@@ -6981,7 +7027,7 @@ async function runS3Command(line) {
   };
 
   console.log("");
-  console.log(GUTTER + dim("RAG S3 — where the knowledge index is stored"));
+  console.log(GUTTER + dim("S3 — your own bucket: the RAG knowledge index, and the files gu makes (PDFs, downloads)"));
   for (const row of s3.s3SummaryRows(current)) console.log(GUTTER + dim(`  ${row}`));
   console.log("");
 
@@ -7082,7 +7128,29 @@ async function runS3Command(line) {
   console.log(GUTTER + accent("✓ saved.") + dim(" now checking it actually works…\n"));
   // Tested with what was just SAVED (no body) rather than what was typed: that proves the
   // stored config works, which is the thing every later turn will use.
-  await runTest({});
+  return 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) {
@@ -8054,6 +8122,16 @@ async function probeWithRecovery() {
 // gu-cli daemon claims + executes it — its terminal shows the full
 // [gu-agent] logs. We poll the job here and stream the persisted chunks live.
 let following = false;
+// SOMETHING WAS TYPED DURING THIS TURN (task #258). Input mid-turn is dropped on purpose (#92) — and
+// it used to be dropped SILENTLY: the row stayed blank and Enter did nothing, so a whole question
+// typed while the previous one was still queued simply vanished. Now the input row says so the
+// moment a key lands, and keeps saying it until the turn ends. Nothing is queued or sent.
+let typedDuringTurn = false;
+const TYPED_DURING_TURN_NOTICE = "(a turn is running — typing is not sent; type it again when it finishes) ";
+const TYPED_DURING_TURN_SHORT = "(turn running — not sent) ";
+/** The notice that fits: the input row must never wrap because of its label (#109/#132). */
+const typedNotice = (width) =>
+  visibleLen(TYPED_DURING_TURN_NOTICE) + 12 <= width ? TYPED_DURING_TURN_NOTICE : TYPED_DURING_TURN_SHORT;
 // Is the turn we are following one this terminal STARTED, or another terminal's that we merely
 // attached to (task #211)? `attached` is local to runAgentTurn, and onInterrupt — which lives in
 // main() — had no way to ask. So Ctrl+C while watching somebody else's agent took the "cancel my
@@ -8137,6 +8215,9 @@ const RUNTOOL_PREFIX = "__RUNTOOL__::";
 const MAXSTEP_PREFIX = "__MAXSTEP__::";
 const TIMEOUT_PREFIX = "__TIMEOUT__::";
 const COMPACT_PREFIX = "__COMPACT__::";
+// Private mode, a file to hand over, and no S3 of the user's own (task #252): set it up now, or
+// save the file on this computer. Allow = S3 is now set up AND passed its test.
+const S3SETUP_PREFIX = "__S3SETUP__::";
 async function approvalPrompt(command) {
   // Wipe the live "thinking" status block BEFORE any picker draws, and stop the ticker from
   // redrawing it (the tick early-returns while a picker is active) — otherwise the block
@@ -8156,6 +8237,31 @@ async function approvalPrompt(command) {
     );
     return { allow: idx === 0, dontAsk: false };
   }
+  if (command.startsWith(S3SETUP_PREFIX)) {
+    const label = command.slice(S3SETUP_PREFIX.length);
+    if (!process.stdin.isTTY) return { allow: false, dontAsk: false };
+    process.stdout.write("\n" + yellow("📦 " + label) + dim("  (no answer in 2 min = save on this computer)") + "\n");
+    const idx = await pickFromList(
+      ["Set up S3 now — my own bucket", "No — save it on this computer"],
+      0,
+      { timeoutMs: 120_000, timeoutIndex: 1 }
+    );
+    if (idx !== 0) return { allow: false, dontAsk: false };
+    // /s3 asks ordinary questions. During a turn `following` swallows every key and drives the
+    // live status block, so the turn is paused on screen for the length of the setup, then resumed.
+    const wasFollowing = following;
+    following = false;
+    let ok = false;
+    try {
+      ok = (await runS3Command("/s3")) === true;
+    } catch (e) {
+      if (!wasPromptCancelled(e)) throw e;
+      console.log(dim("  (cancelled — the file is saved on this computer)\n"));
+    } finally {
+      following = wasFollowing;
+    }
+    return { allow: ok, dontAsk: false };
+  }
   // Time-budget prompt (task #81): the agent hit its wall-clock budget. Ask whether to
   // keep waiting; auto-answer No after 60s of no input so the run can't hang forever.
   if (command.startsWith(TIMEOUT_PREFIX)) {
@@ -8963,6 +9069,7 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
   setPendingStatus(attached ? "attaching — reading its progress" : "queued — waiting for the worker");
   following = true;
   followingAttached = attached;
+  typedDuringTurn = false;
   followAborted = false;
   currentJobId = jobId;
   jobIdForApprovalRace = jobId; // so an approval picker can watch THIS job for early end (#110)
@@ -10120,6 +10227,7 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
     if (process.stdin.isTTY) process.stdin.removeListener("data", onMouseData);
     following = false;
     followingAttached = false;
+    typedDuringTurn = false;
     currentJobId = null;
     // Drop anything typed (but not submitted) during the turn — echo was muted, so it's
     // invisible; without this it would surface on the next prompt.
@@ -11065,6 +11173,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;

package/model-doctor.mjs

@@ -1197,6 +1197,31 @@ export async function hasLocalOllama({ timeoutMs = 1200 } = {}) {
  * imports no mlx/torch/transformers and reaches the model over HTTP, exactly as it already
  * reaches a cloud coder.
  */
+/**
+ * Anthropic's Python SDK — optional, and only for the Claude API (task #262). With it the coding
+ * model uses the native Messages API with prompt caching; without it, the OpenAI-compatible
+ * endpoint, which caches nothing, so every agent step pays full price for a prompt that is ~96%
+ * repetition. Not part of ensureAgentDeps: making it required would re-prompt every install, and
+ * most never use Claude. → "present" | "installed" | "skipped" | "failed".
+ */
+export async function ensureClaudeSdk({ log, confirm }) {
+  if (await pyHasModule("anthropic")) return "present";
+  const yes = await confirm(
+    "Install Anthropic's Python SDK? It turns on prompt caching for Claude — without it every step pays full price."
+  );
+  if (!yes) {
+    log("  skipped — Claude still works, without caching. Later: pip install anthropic");
+    return "skipped";
+  }
+  try {
+    await pipInstall(["anthropic"], log);
+  } catch (e) {
+    log(`  couldn't install it (${e?.message ?? e}) — Claude still works, without caching.`);
+    return "failed";
+  }
+  return (await pyHasModule("anthropic")) ? "installed" : "failed";
+}
+
 export async function ensureAgentDeps({ log, confirm, modelHost = canHostMlxModels() }) {
   const out = {};
   log("");

package/package.json

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