@tiens.nguyen/gu-cli 1.0.726 → 1.0.728

package/cli-token.mjs

@@ -291,7 +291,11 @@ export function barNotice({ token, publicKeyB64, mode, now = new Date(), attempt
     if (Number.isInteger(p.activeDevices) && p.activeDevices > p.deviceLimit) {
       return {
         kind: "over-limit",
-        text: `gu is active on ${p.activeDevices} devices — ${p.plan === "pro" ? "Pro" : "Free"} covers ${p.deviceLimit}`,
+        // PLAIN WORDS (asked: "make it simple to understand"). It read "gu is active on 4 devices —
+        // Free covers 1", which leaves the reader to work out that "active" means "used gu in the
+        // last 30 days" and "covers" means "the plan allows". Kept short: the bar drops it entirely
+        // when it does not fit the terminal's width.
+        text: `${planName(p.plan)} allows ${computers(p.deviceLimit)} — you've used gu on ${p.activeDevices} this month`,
       };
     }
     const age = now.getTime() - Date.parse(p.issuedAt);
@@ -305,6 +309,11 @@ export function barNotice({ token, publicKeyB64, mode, now = new Date(), attempt
     : { kind: "stale", text: "Sign in to keep getting gu updates — run gu login" };
 }
 
+/** "Free plan" / "Pro plan" — the name a person uses. */
+const planName = (plan) => (plan === "pro" ? "Pro plan" : "Free plan");
+/** "1 computer" / "4 computers" — "computer", not "device": a device is also a phone. */
+const computers = (n) => `${n} ${n === 1 ? "computer" : "computers"}`;
+
 /** What `gu token` prints about a valid token — plain lines, no colour, for the command to style. */
 export function tokenSummary(payload, now = new Date()) {
   const lines = [];
@@ -317,7 +326,7 @@ export function tokenSummary(payload, now = new Date()) {
   }
   if (Number.isInteger(payload.activeDevices)) {
     const n = payload.activeDevices;
-    lines.push(`Active on ${n} ${n === 1 ? "device" : "devices"} in the last 30 days — ${payload.plan === "pro" ? "Pro" : "Free"} covers ${payload.deviceLimit}.`);
+    lines.push(`Used on ${computers(n)} in the last 30 days — the ${planName(payload.plan)} allows ${payload.deviceLimit}.`);
   }
   lines.push(`Issued ${shortDate(payload.issuedAt)}.`);
   return lines;
@@ -370,8 +379,8 @@ export function enforcementDecision({ token, publicKeyB64, now = new Date(), sit
       enforced: true,
       allowed: false,
       why:
-        `This account is active on ${p.activeDevices} devices and Pro covers ${p.deviceLimit}. ` +
-        `Sign out of one, or remove it at ${accountUrl}.`,
+        `This account has used gu on ${computers(p.activeDevices)} in the last 30 days, and the ` +
+        `${planName(p.plan)} allows ${p.deviceLimit}. Sign out of one, or remove it at ${accountUrl}.`,
     };
   }
   return { enforced: true, allowed: true, why: "" };

package/gonext_agent_chat.py

@@ -1757,15 +1757,15 @@ def _load_prompt_scaffold(api_base: str, worker_key: str):
     file is NOT quietly replaced by the database version, or an edit that broke it would look like
     it had no effect."""
     if os.path.isfile(_LOCAL_SCAFFOLD_PATH):
-        where = "~/.gonext/prompt-scaffolds/code-agent.txt"
+        where = _psc.LOCAL_SCAFFOLD_LABEL  # never the path — see prompt_scaffold_check.py
         try:
             with open(_LOCAL_SCAFFOLD_PATH, encoding="utf-8") as f:
                 text = f.read()
         except Exception as e:  # noqa: BLE001
             raise _AgentConfigError(
-                f"The agent couldn't start: your local scaffold {where} could not be read "
+                f"The agent couldn't start: {where} could not be read "
                 f"({type(e).__name__}). Fix it, or delete it to use the gu service's.") from None
-        problem = _scaffold_problem(text, f"your local scaffold {where}")
+        problem = _scaffold_problem(text, where)
         if problem:
             raise _AgentConfigError(
                 f"The agent couldn't start: {problem}. Fix it, or delete it to use the gu service's.")
@@ -2356,7 +2356,8 @@ def _render_prompt(messages, max_chars: int = 400_000) -> str:
             # the API and shown on the token-usage page — so it would hand the hidden text to
             # anyone who opens a step. Its size stays visible, the text does not.
             v = _PROMPT_SCAFFOLD_VERSION["v"]
-            label = " (your local file)" if v == "local" else (f" v{v}" if v is not None else "")
+            # The same words whatever the source — a local file is never announced (the user's call).
+            label = f" v{v}" if isinstance(v, int) else ""
             text = (f"[prompt scaffold{label} with the tool signatures — "
                     f"{len(text)} characters, not shown]")
         out.append(f"───── {role or 'message'} ─────\n{text}")
@@ -12177,10 +12178,8 @@ def run_agent_chat(cfg):
             # TURN_FAILED) instead of quietly running on a different prompt. The version is
             # logged; the text never is.
             _scaffold, _scaffold_version, _scaffold_source = _load_prompt_scaffold(worker_api_base, worker_api_key)
-            if _scaffold_source != "api":
-                # SAID, every turn it applies: an old file left lying around must never quietly
-                # change the agent. One line in the thinking area, not a banner.
-                _emit({"type": "step", "text": f"using your local prompt scaffold ({_scaffold_source})"})
+            # A LOCAL FILE IS USED SILENTLY — no line, no location (the user's call: "if it is on
+            # .gonext location, not say anything"). Only a BROKEN one speaks, and without the path.
             try:
                 import yaml as _yaml
                 import os as _os

package/gu-cli.mjs

@@ -679,7 +679,6 @@ const currentApiVersion = async () => {
     // machine that was already paired, i.e. every machine that could need an upgrade, had no
     // path to one. A published API fix reached nobody.
     const run = await import("./client-expert-run.mjs");
-    const { isNewer } = await import("./version-check.mjs");
     const running = await currentVersion();
 
     // TOP UP THE SEEDED SETTINGS FIRST, AND UNCONDITIONALLY.
@@ -719,8 +718,19 @@ const currentApiVersion = async () => {
     const dir = run.apiInstallDir(manifest.version);
     const depsIn = await ce.apiDepsInstalled(dir);
     const present = (await run.probeApiInstall(manifest.version)).installed;
-    if (!isNewer(manifest.version, running) && depsIn) {
-      console.log(`\n  Already on ${running} — nothing newer published.\n`);
+    // DECIDED FROM WHAT IS RUNNING, not only what is on disk (see upgradePlan). A build already
+    // downloaded but never started used to answer "Already on 1.0.161 — nothing newer published"
+    // and leave yesterday's 1.0.153 process serving. Reported from the startup scaffold line.
+    const { upgradePlan } = await import("./version-check.mjs");
+    const liveVersion = String((await ce.probeLocalApi()).body?.version ?? "").trim();
+    const plan = upgradePlan({
+      published: manifest.version,
+      installed: running,
+      running: liveVersion,
+      ready: present && depsIn,
+    });
+    if (plan.action === "none") {
+      console.log(`\n  ${plan.say}\n`);
       process.exit(0);
     }
     // A version already on disk but unusable is a RESUME, not an upgrade — someone whose
@@ -730,12 +740,12 @@ const currentApiVersion = async () => {
     // Caught by running it: "Finishing an interrupted install of 1.0.30" on a box going
     // cleanly from 1.0.29.
     console.log(
-      present && !depsIn
+      plan.action === "install" && present && !depsIn
         ? `\n  Finishing an interrupted install of ${manifest.version}`
-        : `\n  Upgrading the API: ${running || "none"} → ${manifest.version}`
+        : `\n  ${plan.say}`
     );
     try {
-      if (!present || !depsIn) {
+      if (plan.action === "install" && (!present || !depsIn)) {
         await run.downloadApiPackage(manifest, { onProgress: (l) => console.log(`    ${l}`) });
         await ce.installApiDeps(dir, {
           onLine: (l) => l && l.length < 160 && console.log(`    ${l}`),
@@ -760,12 +770,19 @@ const currentApiVersion = async () => {
     console.log(`  Starting ${version}…`);
     await ce.startLocalApi({ apiDir: run.apiInstallDir(version) });
     const health = await ce.waitForApi({});
+    // "An API answers" is not "the NEW API answers": an old process that never stopped answers
+    // too, and this line once reported the new version while the old one kept serving.
+    const serving = String((await ce.probeLocalApi()).body?.version ?? "").trim();
+    const wrong = health.ok && Boolean(serving) && serving !== version;
     console.log(
-      health.ok
-        ? `  API is up on ${ce.LOCAL_API_BASE} (${version})\n`
-        : `  API did not come up: ${health.why}\n  Log: ${ce.API_LOG_FILE}\n`
+      !health.ok
+        ? `  API did not come up: ${health.why}\n  Log: ${ce.API_LOG_FILE}\n`
+        : wrong
+          ? `  ${serving} is still the one answering on ${ce.LOCAL_API_BASE}, not ${version}.\n` +
+            `  Stop it (gu-cli api stop), then: gu-cli api start\n`
+          : `  API is up on ${ce.LOCAL_API_BASE} (${serving || version})\n`
     );
-    process.exit(health.ok ? 0 : 1);
+    process.exit(health.ok && !wrong ? 0 : 1);
   }
 
   if (sub === "stop") {

package/gu-repl.mjs

@@ -8744,14 +8744,14 @@ const wrapThought = (s, width, maxLines) => {
  * own conversation.
  */
 /**
- * WHERE THIS SESSION'S SCAFFOLD COMES FROM, said at `gu` start (task #246) — "scaffold loaded" from
- * the user's own ~/.gonext/prompt-scaffolds/code-agent.txt, or "scaffold fetched" from the gu
- * service. Background: startup never waits on it (an offline private-mode machine would otherwise
+ * WHERE THIS SESSION'S SCAFFOLD COMES FROM, said at `gu` start (task #246) — "scaffold fetched" from
+ * the gu service; NOTHING at all when it is the user's own local file (by request — its location is
+ * never printed), unless that file is broken. Background: startup never waits on it (an offline private-mode machine would otherwise
  * sit for 10s); the line prints when the answer arrives, or at the next prompt if a turn is running.
  *
  *   · A LOCAL FILE is checked with the worker's OWN checker (prompt_scaffold_check.py — size,
- *     placeholders, a trial render), so "loaded" means it passed, not merely that it exists. The API
- *     is not asked: turns use the file.
+ *     placeholders, a trial render); a good one is silent, a broken one is reported. The API is not
+ *     asked: turns use the file.
  *   · Otherwise the API is asked to REFRESH — the fetch that the rest of the session then reuses
  *     ("keep in cache until the user type gu").
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.726",
+  "version": "1.0.728",
   "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",

package/prompt_scaffold_check.py

@@ -6,9 +6,9 @@ at startup (`python3 prompt_scaffold_check.py`) so the "scaffold loaded" line it
 file really passed — not just that a file exists. Needs only jinja2 (a smolagents dependency), so
 the startup check is quick.
 
-    python3 prompt_scaffold_check.py [path]   → one JSON line: {"exists", "path", "chars", "problem"}
+    python3 prompt_scaffold_check.py [path]   → one JSON line: {"exists", "chars", "problem"}
 
-It never prints the scaffold text.
+It never prints the scaffold text, nor where the file is.
 """
 import json
 import os
@@ -19,7 +19,10 @@ import sys
 # file — the scaffold stays off users' disks unless they put it there themselves — so it is an
 # override for trying a wording before inserting it into production, not a cache.
 LOCAL_SCAFFOLD_PATH = os.path.join(os.path.expanduser("~"), ".gonext", "prompt-scaffolds", "code-agent.txt")
-LOCAL_SCAFFOLD_LABEL = "~/.gonext/prompt-scaffolds/code-agent.txt"
+# How the file is NAMED in anything a person reads: never its location. Asked for: "dont say out loud
+# where is the location of the scaffold file … not say anything". The deploy app's own Commands
+# window is the one place the path is written down, for its owner.
+LOCAL_SCAFFOLD_LABEL = "your local scaffold file"
 
 # What a scaffold must keep — the same list the API and the deploy app use.
 SCAFFOLD_REQUIRED = (
@@ -97,18 +100,18 @@ def scaffold_problem(template, source: str) -> str:
 def check_file(path: str = LOCAL_SCAFFOLD_PATH, label: str = LOCAL_SCAFFOLD_LABEL) -> dict:
     """The local override's state, for `gu` at startup. Never includes the text."""
     if not os.path.isfile(path):
-        return {"exists": False, "path": label}
+        return {"exists": False}
     try:
         with open(path, encoding="utf-8") as f:
             text = f.read()
     except Exception as e:  # noqa: BLE001
-        return {"exists": True, "path": label, "chars": 0,
-                "problem": f"your local scaffold {label} could not be read ({type(e).__name__})"}
-    return {"exists": True, "path": label, "chars": len(text),
-            "problem": scaffold_problem(text, f"your local scaffold {label}")}
+        return {"exists": True, "chars": 0,
+                "problem": f"{label} could not be read ({type(e).__name__})"}
+    return {"exists": True, "chars": len(text),
+            "problem": scaffold_problem(text, label)}
 
 
 if __name__ == "__main__":
     target = sys.argv[1] if len(sys.argv) > 1 else LOCAL_SCAFFOLD_PATH
-    label = LOCAL_SCAFFOLD_LABEL if len(sys.argv) <= 1 else target
+    label = LOCAL_SCAFFOLD_LABEL
     print(json.dumps(check_file(target, label)))

package/terminal-layout.mjs

@@ -1770,20 +1770,22 @@ export function lazyModuleNames(text) {
 
 /**
  * The one line `gu` prints at startup about the agent's prompt scaffold (task #246) — asked for so
- * the user KNOWS where this session's scaffold came from: "scaffold is loaded" (their own file) or
- * "scaffold is fetched" (the gu service). Pure; gu-repl gathers the facts.
+ * the user knows where this session's scaffold came from — the gu service ("fetched") — and hears
+ * NOTHING when it is their own local file (by request). Pure; gu-repl gathers the facts.
  *
  *   local   — prompt_scaffold_check.py's answer: { exists, path, chars, problem } (null = not run)
  *   refresh — POST /api/worker/prompt-scaffold/refresh: { status, ok, version, error, kept }
  *   private — private mode (the local API), which decides what "update" advice means
- * Returns { kind: "ok" | "warn" | "err", text }.
+ * Returns { kind: "ok" | "warn" | "err", text }, or null when there is nothing to say.
  */
 export function scaffoldStartupNotice({ local = null, refresh = null, private: privateMode = false } = {}) {
-  const n = (x) => Number(x ?? 0).toLocaleString("en-US");
+  // YOUR LOCAL FILE, WORKING: nothing is said — no line, no location (the user's call: "dont say
+  // out loud where is the location of the scaffold file … not say anything"). null = print nothing.
+  // A BROKEN one still speaks, without the path: otherwise every turn fails with no explanation.
   if (local?.exists) {
     return local.problem
       ? { kind: "err", text: `scaffold: ${local.problem} — fix it, or delete it to use the gu service's` }
-      : { kind: "ok", text: `scaffold loaded from ${local.path} (${n(local.chars)} chars)` };
+      : null;
   }
   if (!refresh) return { kind: "warn", text: "scaffold: couldn't ask the API — the first turn will try again" };
   if (refresh.status === 404) {

package/version-check.mjs

@@ -70,3 +70,37 @@ export function updatesAvailable({ cliRunning, cliLatest, apiRunning, apiLatest
   const api = isNewer(apiLatest, apiRunning) ? String(apiLatest) : "";
   return { cli, api, any: Boolean(cli || api) };
 }
+
+/**
+ * WHAT `gu api upgrade` SHOULD DO — decided from the version that is RUNNING, not only the one on
+ * disk. Pure, so every case is tested.
+ *
+ * REPORTED: the startup line said "your local gu API is older than this gu — run gu api upgrade",
+ * and upgrading did nothing. 1.0.161 was already downloaded (by the in-app updater), so the old
+ * check compared "published 1.0.161" with "installed 1.0.161", answered "Already on 1.0.161 —
+ * nothing newer published" and exited — while a process started the day before from 1.0.153 kept
+ * serving. `gu api status` had learnt this difference long ago; `upgrade` had not.
+ *
+ *   published — the manifest's version     installed — the newest usable build on disk
+ *   running   — what /api/health reports ("" when the API is down or too old to say)
+ *   ready     — `installed` has its dependencies (a runnable install)
+ * Returns { action: "none" | "install" | "restart", say }:
+ *   install → download/finish the published build, then restart onto it;
+ *   restart → nothing to download, but the running process is not the installed build.
+ */
+export function upgradePlan({ published = "", installed = "", running = "", ready = false } = {}) {
+  const target = published && (!installed || isNewer(published, installed)) ? published : installed;
+  if (target === published && published && (!ready || installed !== published)) {
+    return { action: "install", say: `Upgrading the API: ${running || installed || "none"} → ${published}` };
+  }
+  if (running && (running === target || isNewer(running, target))) {
+    // Running something at least as new as anything here — never "restart" onto an older build.
+    return { action: "none", say: `Already on ${running} — nothing newer published.` };
+  }
+  return {
+    action: "restart",
+    say: running
+      ? `${target} is installed but ${running} is still running — restarting onto ${target}`
+      : `Starting ${target}`,
+  };
+}