@tiens.nguyen/gu-cli 1.0.767 → 1.0.768

package/gonext_agent_chat.py

@@ -10257,8 +10257,12 @@ def run_agent_chat(cfg):
                      f"(fresh {_bd['ragFresh']}, carried {_bd['ragCarried']}) · "
                      f"tools {_bd['tools']} · code {_bd['code']}"
                      + ("" if _RAG_LEDGER else "  [RAG NOT CALLED this turn]"))
+                # `step` (task #298): which model call these figures belong to, so the terminal
+                # can show THIS step's ↑/↓ on the thinking line instead of the turn totals the
+                # bar already shows. Same counter as _RAG_STEP, advanced once per call above.
                 _emit({"type": "tokens", "codeInput": self._code_tokens_total,
                        "codeMax": self._code_tokens_max, "stepInput": _step_est,
+                       "step": self._call_index,
                        "exact": False, "breakdown": _bd})
                 # RECORD WHAT WE ARE ABOUT TO SEND, BEFORE WE SEND IT (task #155).
                 #
@@ -10514,6 +10518,7 @@ def run_agent_chat(cfg):
                         "codeInput": self._code_tokens_total,
                         "codeMax": self._code_tokens_max,
                         "stepInput": exact,
+                        "step": self._call_index,
                         # Task #142: the SAME split, rescaled to the server's authoritative
                         # count — the shares are the shares whether or not our ~4 chars/token
                         # estimate was right, so the breakdown never contradicts the total.
@@ -10547,6 +10552,7 @@ def run_agent_chat(cfg):
                         "codeMax": self._code_tokens_max,
                         "codeOutput": self._code_output_tokens_total,
                         "stepOutput": step_out,
+                        "step": self._call_index,
                         # Absent, not 0, when the server never reported it — the page must be
                         # able to say "not reported" rather than show a 0% hit rate that
                         # would read as a cache problem we do not actually have.

package/gu-cli.mjs

@@ -19,6 +19,7 @@ import { mkdir, mkdtemp, readFile, rm, stat, unlink, writeFile } from "node:fs/p
 import { execFile as execFileCallback, spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { createTaskPool, createFolderQueue } from "./job-pools.mjs";
+import { NO_STEP, foldStepTokens, withStepTokens } from "./step-tokens.mjs";
 import { agentStoppedLine, jobEnded, jobStatusFrom409, stopGracefully } from "./agent-stop.mjs";
 import { ragJobConfig } from "./rag-job-config.mjs";
 import { codingKeyFallbackLine, isOllamaCloudUrl } from "./coding-key-prompt.mjs";
@@ -3960,6 +3961,9 @@ async function runAgentChatJob(job) {
     // ragFresh/ragCarried). Kept so a later token PATCH that carries no breakdown of its own
     // (the output-token event) still re-sends the last one rather than blanking the row.
     let latestPromptBreakdown = null;
+    // Task #298: the CURRENT model call's own ↑ in / ↓ out, for the thinking line (the bar
+    // already shows the totals). Rides on the breakdown — see step-tokens.mjs.
+    let stepTokens = NO_STEP;
     // Raw model-stream tokens (event.type === "stream") are Python code + `Thought:`
     // prose + <code>/<|"|> fragments. The web Thought panel renders reasoning as
     // markdown, which turns `#`-prefixed code comments into <h1> headings and
@@ -4125,11 +4129,19 @@ async function runAgentChatJob(job) {
         const breakdown =
           event.breakdown && typeof event.breakdown === "object" ? event.breakdown : null;
         if (breakdown) latestPromptBreakdown = breakdown;
+        const prevStep = stepTokens;
+        stepTokens = foldStepTokens(stepTokens, event);
+        const stepChanged =
+          stepTokens.step !== prevStep.step ||
+          stepTokens.stepIn !== prevStep.stepIn ||
+          stepTokens.stepOut !== prevStep.stepOut;
+        if (latestPromptBreakdown) latestPromptBreakdown = withStepTokens(latestPromptBreakdown, stepTokens);
         if (
           nextTotal !== latestCodeTokens ||
           nextMax !== latestMaxCodeTokens ||
           nextOut !== latestCodeOutputTokens ||
-          breakdown
+          breakdown ||
+          (stepChanged && latestPromptBreakdown)
         ) {
           latestCodeTokens = nextTotal;
           latestMaxCodeTokens = nextMax;

package/gu-repl.mjs

@@ -24,6 +24,7 @@
  * Commands: /exit  /model  /new  /help   Ctrl-C stops following the current run.
  */
 import { readFile, mkdir, writeFile, unlink, rename } from "node:fs/promises";
+import { readStepTokens } from "./step-tokens.mjs";
 import { existsSync, statSync, readFileSync, writeFileSync, readdirSync, openSync, readSync, closeSync } from "node:fs";
 import { spawn } from "node:child_process";
 // FIRST, before anything that could itself fail on an old runtime: npm only WARNS about
@@ -1943,9 +1944,12 @@ let lastPromptBreakdown = null;
  * never leads it, so the screen never claims output that has not been produced.
  */
 let shownOutputTokens = 0;
-// The same for INPUT (#53): this turn's input so far — the bar's "sent" — shown as "↑ N" before
-// the "↓ N" output figure, so the thinking line reads both directions the way the bar does.
+// The same for INPUT (#53), shown as "↑ N" before the "↓ N" output figure.
 let shownInputTokens = 0;
+// Task #298: both figures are THIS STEP's, not the turn's (the bar has those). Which step the
+// shown values belong to, so a new step starts its count from zero instead of easing on from
+// the previous step's number.
+let shownStepNo = 0;
 // Seconds from Enter to the first full prompt reaching the coding model (prompt assembly +
 // retrieval). Shown by /tokens; 0 until a turn has run.
 let lastPromptAssemblySeconds = 0;
@@ -9634,6 +9638,9 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
   // Task #104: this turn's OUTPUT-token total, read from the job doc each poll. Folded into
   // the lifetime per-workspace + global counters once the turn completes.
   let latestOutputTokens = 0;
+  // Task #298: the current model call's own ↑/↓, read from the polled breakdown. null until
+  // this turn reports a step — never the previous turn's, which the kept breakdown still holds.
+  let liveStepTokens = null;
   let outputTokensPosted = false; // guard: increment the lifetime counters once per turn
   // Task #142: when this turn was submitted, and when its first full prompt reached the coding
   // model. The gap between them is prompt assembly + RAG retrieval — the thing the user asked
@@ -9875,10 +9882,18 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
     // Advanced once per tick — this branch runs ~8x/second while the agent is thinking, which is
     // what makes the climb visible at all. Parked (streaming) the block is not rebuilt, so the
     // figure holds rather than jittering against flowing output.
-    shownOutputTokens = easeCount(shownOutputTokens, latestOutputTokens);
-    shownInputTokens = easeCount(shownInputTokens, latestCodeTokens);
-    // ↑ input (this turn's "sent", every request so far — cached input included: the model read
-    // it) then ↓ output (#53). Each absent until known, never a "0" that claims a measurement.
+    // THIS STEP, NOT THE TURN (task #298). The turn totals were exactly the bar's "sent" and
+    // "↓ out" one row below — the same two numbers twice. ↑ is the current model call's prompt,
+    // ↓ its output (known when the call returns); both start from zero at each new step.
+    const st = liveStepTokens;
+    if (!st || st.step !== shownStepNo) {
+      shownStepNo = st ? st.step : 0;
+      shownInputTokens = 0;
+      shownOutputTokens = 0;
+    }
+    shownOutputTokens = easeCount(shownOutputTokens, st ? st.stepOut : 0);
+    shownInputTokens = easeCount(shownInputTokens, st ? st.stepIn : 0);
+    // ↑ input then ↓ output (#53). Each absent until known, never a "0" that claims a measurement.
     const outLabel =
       (shownInputTokens > 0 ? dim(" · ↑ ") + accent(fmtTokens(shownInputTokens)) : "") +
       (shownOutputTokens > 0 ? dim(" · ↓ ") + accent(fmtTokens(shownOutputTokens)) : "");
@@ -10493,6 +10508,7 @@ async function runAgentTurn(history, { attachJobId = "" } = {}) {
       // what is in the context right now, so it must be allowed to shrink when a trim lands.
       if (job.agentPromptBreakdown && typeof job.agentPromptBreakdown === "object") {
         lastPromptBreakdown = job.agentPromptBreakdown;
+        liveStepTokens = readStepTokens(job.agentPromptBreakdown);
         // Persisted per folder so the next `gu` here starts from the real picture instead
         // of a zero that looks like a failure. Fire-and-forget: a bar value is never worth
         // delaying a turn for, and losing one is harmless. Shown while attached (it is what

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.767",
+  "version": "1.0.768",
   "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",
@@ -49,6 +49,7 @@
     "accent.mjs",
     "gu-cli.mjs",
     "gu-repl.mjs",
+    "step-tokens.mjs",
     "terminal-hover.mjs",
     "terminal-layout.mjs",
     "terminal-viewport.mjs",

package/step-tokens.mjs

@@ -0,0 +1,55 @@
+/**
+ * THIS STEP'S TOKENS, for the thinking line (task #298).
+ *
+ * The thinking line showed "· ↑ 478k · ↓ 4.3k" — the turn's running totals, which are exactly the
+ * bar's "sent 478k" and "↓ out 4.3k" one row below. Same numbers twice. What the line can say that
+ * the bar cannot is what the CURRENT model call is costing: its own prompt (↑) and its own output
+ * (↓), starting from zero at each new step.
+ *
+ * Python already knows both per call (`stepInput`, `stepOutput`) and tags them with `step`. The API
+ * only stores job fields it knows, but it passes agentPromptBreakdown through as-is — so the worker
+ * rides these three figures on that object (liveStep / liveStepIn / liveStepOut) and no API release
+ * is needed. Everything that reads the breakdown does so by named bucket, so extra keys are inert.
+ */
+
+/** The state before any step of a turn. */
+export const NO_STEP = Object.freeze({ step: 0, stepIn: 0, stepOut: 0 });
+
+/**
+ * Fold one python "tokens" event into the current step's figures.
+ *
+ * A new `step` number starts from zero: its output is not known until the call returns, so the old
+ * step's ↓ must not linger beside the new step's ↑. Input can arrive twice for one step — the
+ * estimate at send time, then the server's exact count if higher — and the larger one wins.
+ */
+export function foldStepTokens(prev, event) {
+  let { step, stepIn, stepOut } = prev ?? NO_STEP;
+  if (!event || typeof event !== "object") return { step, stepIn, stepOut };
+  if (Number.isFinite(event.step) && event.step !== step) {
+    step = event.step;
+    stepIn = 0;
+    stepOut = 0;
+  }
+  if (Number.isFinite(event.stepInput) && event.stepInput > stepIn) stepIn = event.stepInput;
+  if (Number.isFinite(event.stepOutput) && event.stepOutput >= 0) stepOut = event.stepOutput;
+  return { step, stepIn, stepOut };
+}
+
+/** The breakdown the worker PATCHes, carrying the step's figures. */
+export function withStepTokens(breakdown, s) {
+  if (!breakdown || typeof breakdown !== "object" || !s || !s.step) return breakdown;
+  return { ...breakdown, liveStep: s.step, liveStepIn: s.stepIn, liveStepOut: s.stepOut };
+}
+
+/**
+ * What the terminal reads back from a polled breakdown: this step's figures, or null when the
+ * breakdown carries none (an older worker, or no step reported yet) — then the line shows nothing
+ * rather than a total dressed up as a step.
+ */
+export function readStepTokens(breakdown) {
+  if (!breakdown || typeof breakdown !== "object") return null;
+  const step = Number(breakdown.liveStep);
+  if (!Number.isFinite(step) || step <= 0) return null;
+  const n = (v) => (Number.isFinite(Number(v)) && Number(v) > 0 ? Number(v) : 0);
+  return { step, stepIn: n(breakdown.liveStepIn), stepOut: n(breakdown.liveStepOut) };
+}