flowviant 0.89.0 → 0.90.0

package/bin/lib/claude.mjs

@@ -168,6 +168,43 @@ export const humanizeToolUse = humanizeClaudeTool;
 // Collapse whitespace + clip so a narration/thinking snippet is one tidy feed line.
 const oneLine = (s, n = 160) => String(s).replace(/\s+/g, ' ').trim().slice(0, n);
 
+/**
+ * WHAT THIS TURN COST, IN THE CLI'S OWN NUMBERS (2026-09-19).
+ *
+ * The `result` event carries a `usage` object — `input_tokens`,
+ * `output_tokens`, `cache_creation_input_tokens`, `cache_read_input_tokens` —
+ * and this reads exactly those four and nothing else. A RELAY: nothing here
+ * derives, estimates or prices anything.
+ *
+ * DELIBERATELY NOT `total_cost_usd`, which rides the same event. It is a
+ * notional list price that a subscription operator did not pay, so relaying it
+ * as "cost" would be the product asserting a figure nobody was charged — the
+ * refusal the board's fix pass already made once against the mock's "1.4
+ * spent". Tokens are measured; dollars are not.
+ *
+ * COERCED AND FLOORED, never trusted: a non-number, a NaN, an Infinity or a
+ * negative reads as 0, because these are summed into a counter that only ever
+ * goes up and one bad field must not poison the other three.
+ *
+ * Returns null when there is no usage object at all — the three-state rule
+ * every readout here keeps: a turn that reported nothing charges nothing, and
+ * that is not the same as a turn that reported zeros.
+ */
+export function usageFromResult(ev) {
+  const u = ev?.usage;
+  if (!u || typeof u !== 'object') return null;
+  const n = (v) => {
+    const x = Number(v);
+    return Number.isFinite(x) && x > 0 ? Math.floor(x) : 0;
+  };
+  return {
+    input: n(u.input_tokens),
+    output: n(u.output_tokens),
+    cacheCreate: n(u.cache_creation_input_tokens),
+    cacheRead: n(u.cache_read_input_tokens),
+  };
+}
+
 // Parse ONE line of `--output-format stream-json` NDJSON into feed activities.
 // Surfaces the WHOLE turn — thinking, narration, AND every tool — so neither the
 // daemon console nor the app cover goes dark while Claude reasons (Opus thinks in
@@ -180,7 +217,15 @@ const oneLine = (s, n = 160) => String(s).replace(/\s+/g, ' ').trim().slice(0, n
 // every intermediate text block still NARRATES, but only the final `result`
 // event contributes text — otherwise the same sentences arrive twice, once as
 // they stream and once in the result, and the tab posts the duplicate.
-function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText, answerFromResult, onInit }) {
+//
+// EXPORTED FOR ITS TEST ONLY (2026-09-19), and the reason is worth stating: the
+// `onUsage` threading through this function, `runTurn`'s options and `onLine`
+// was four edits and NOT ONE of them was reachable from either suite — delete
+// any one and both stay green, while the only symptom in production is a
+// container that reports no spend, which is indistinguishable from an older
+// daemon by design. A callback that is silent when it breaks has to be called
+// directly by something.
+export function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText, answerFromResult, onInit, onUsage }) {
   let ev;
   try {
     ev = JSON.parse(line);
@@ -262,6 +307,18 @@ function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText
       });
     }
   } else if (ev.type === 'result') {
+    /**
+     * WHAT THE TURN SPENT, BEFORE ANYTHING ELSE IN THIS BRANCH.
+     *
+     * FIRED ON A FAILED RESULT TOO, and that ordering is the point: a turn that
+     * hit a limit, ran out of permission or aborted still sent the requests it
+     * sent, and a spend readout that quietly skipped every unhappy turn would
+     * under-report exactly the runs somebody is looking at the number to
+     * understand. `usageFromResult` returns null when the event carries no
+     * usage at all, and a caller that passes no `onUsage` sees no change.
+     */
+    const usage = usageFromResult(ev);
+    if (usage) onUsage?.(usage);
     // The final assistant text (carries WIKI_DONE / REGROUND_DONE).
     if (typeof ev.result === 'string') appendText(ev.result + '\n');
     else if (ev.is_error || ev.subtype) {
@@ -294,7 +351,7 @@ function handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText
 // returned string for sentinel detection, and each activity is handed to
 // `onActivity` so the caller can forward progress. Build-agent turns leave it
 // off and keep the raw text passthrough + line sentinels.
-export function runTurn({ prompt, resume, system, cwd, mcpConfig, mcpArgs, mcpEnv, runtime = 'claude', label, onSpawn, streamJson, answerFromResult, onActivity, onToolEvent, onInit, onThreadId, wikiPerm, readOnly, planPerm, vaultDir, resultSchemaArgs, model, effort, adoptResumeId, resumeThreadId, resumeConversationId }) {
+export function runTurn({ prompt, resume, system, cwd, mcpConfig, mcpArgs, mcpEnv, runtime = 'claude', label, onSpawn, streamJson, answerFromResult, onActivity, onToolEvent, onInit, onUsage, onThreadId, wikiPerm, readOnly, planPerm, vaultDir, resultSchemaArgs, model, effort, adoptResumeId, resumeThreadId, resumeConversationId }) {
   return new Promise((resolve) => {
     const rt = runtimeById(runtime);
     if (!rt.args) {
@@ -425,7 +482,7 @@ export function runTurn({ prompt, resume, system, cwd, mcpConfig, mcpArgs, mcpEn
       /** One line of the child's stdout, in whichever dialect it speaks. */
       const onLine = (line) => {
         if (!rt.parse)
-          return handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText, answerFromResult, onInit });
+          return handleStreamLine(line, { cwd, emit, onActivity, onToolEvent, appendText, answerFromResult, onInit, onUsage });
         const ev = rt.parse(line, cwd);
         if (!ev) return;
         // The conversation id, when the runtime announces one (codex's

package/bin/lib/work.mjs

@@ -4885,6 +4885,21 @@ export function createWorkManager({
 
       let out = '';
       let child = null;
+      /**
+       * WHAT THIS TURN SPENT, AS THE CLI COUNTED IT (2026-09-19).
+       *
+       * Held across the whole turn so every settle below can carry it — a turn
+       * that hit a limit, produced no parseable outcome or delivered properly
+       * all spent real tokens, and a readout that only charged the happy path
+       * would under-report the runs somebody opens the number to understand.
+       *
+       * The three settles it is spread into are the ones that follow a CLI
+       * actually running. The pre-spawn refusals above (a bad place, a missing
+       * card, the begun-guard) and the teardown sweep below deliberately do NOT
+       * take it: nothing ran there, and `usage` stays null anyway, which is
+       * what makes `...(usage ? … : {})` the whole guard.
+       */
+      let usage = null;
       try {
         out = await runTurn({
           prompt:
@@ -4944,6 +4959,13 @@ export function createWorkManager({
           onToolEvent: (name, input) => {
             trace.tool(toolEventOf(name, input, wt, envScrub));
           },
+          // The CLI's own per-turn token counts, off the `result` event. One
+          // result per turn, so this is a set and not an accumulate — the
+          // adding-up happens SERVER-side, behind the settle's idempotent win,
+          // because a retried settle must not charge the same turn twice.
+          onUsage: (u) => {
+            usage = u;
+          },
           onSpawn: (ch) => {
             child = ch;
             // The AGENT it serves — what the machine snapshot charges this
@@ -5015,7 +5037,14 @@ export function createWorkManager({
         // limit means all of them have. The turn itself is reported as
         // `nothing` — it did not deliver and it did not ask.
         await postAgentParked(limit);
-        await postAgentTurn({ turnId, outcome: 'nothing', answer: limit, branch, worktree: wt });
+        await postAgentTurn({
+          turnId,
+          outcome: 'nothing',
+          answer: limit,
+          ...(usage ? { usage } : {}),
+          branch,
+          worktree: wt,
+        });
         return;
       }
 
@@ -5029,6 +5058,7 @@ export function createWorkManager({
             ? envScrub(out).slice(-1500)
             : 'the turn produced no output on the machine — its CLI may be signed out',
           ...(commits.length ? { commits } : {}),
+          ...(usage ? { usage } : {}),
           branch,
           worktree: wt,
         });
@@ -5040,6 +5070,7 @@ export function createWorkManager({
         answer: envScrub(res.answer ?? '').slice(0, 8000),
         ...(commits.length ? { commits } : {}),
         ...(res.raised?.length ? { raised: res.raised } : {}),
+        ...(usage ? { usage } : {}),
         branch,
         worktree: wt,
       });
@@ -5450,6 +5481,17 @@ export function createWorkManager({
    * and is retried ONCE, because unlike a trace batch this body cost a whole
    * model call and losing it to a blip means the operator paid for a label
    * nobody ever sees.
+   *
+   * THE RETRY IS NOT A GUARANTEE THAT THE FIRST ATTEMPT FAILED, and since the
+   * body started carrying `usage` (0.90.0) that matters. The `catch` below
+   * takes the 30-second `AbortSignal` with everything else, so a server that
+   * was merely SLOW — and committed — receives this identical body twice. The
+   * store was always idempotent; the token counts riding it were not, and a
+   * timed-out-but-committed post added them twice. The SERVER closes that: its
+   * write refuses a body whose text already sits on the row, so a re-send
+   * stores the same reading and charges nothing for it. Nothing here needs to
+   * change, and nothing here may start assuming a thrown fetch means the
+   * server never saw this.
    */
   const postPre = async (body) => {
     try {
@@ -5552,6 +5594,21 @@ export function createWorkManager({
     let timer = null;
     /** The cap fired: the CLI was still running when this machine stopped it. */
     let wedged = false;
+    /**
+     * WHAT THE READING SPENT — the agent-turn lane's own relay, on the one
+     * other lane that charges an AGENT (2026-09-19).
+     *
+     * It rides the agent and never a card link: a pre-review belongs to no card
+     * (the same reason `workChildren` gets a null task id below), so the four
+     * counters it adds to are the container's alone. That is also why an
+     * agent's links can never sum to its total, and the schema says so.
+     *
+     * A WEDGED OR UNPARSEABLE READING POSTS NOTHING AT ALL, so it charges
+     * nothing either — which under-reports a turn that really did spend. That
+     * is the honest direction: there is no row to put it on, and inventing a
+     * settle to carry a number would be a post whose only content is a bill.
+     */
+    let usage = null;
     /**
      * THE CONVERSATION THIS READING SPEAKS UNDER — held for exactly one reason:
      * to DELETE the transcript it leaves behind (review, 2026-09-17).
@@ -5612,6 +5669,11 @@ export function createWorkManager({
           if (typeof i.sessionId === 'string' && i.sessionId.trim())
             preSession = i.sessionId.trim();
         },
+        // The CLI's own count for this reading. Set, never accumulated: one
+        // turn is one `result` event, and the adding-up is the server's.
+        onUsage: (u) => {
+          usage = u;
+        },
         onSpawn: (ch) => {
           child = ch;
           // No task id: a pre-review belongs to no card, and the machine
@@ -5710,6 +5772,7 @@ export function createWorkManager({
     const body = {
       agentId,
       ...(headSha ? { headSha } : {}),
+      ...(usage ? { usage } : {}),
       cards: result.cards.map((cd) => ({
         taskId: cd.taskId,
         verdict: cd.verdict,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.89.0",
+  "version": "0.90.0",
   "description": "Run your own coding CLIs as build agents for Flowviant \u2014 Claude Code, Codex or Antigravity, on your own credentials. Holds your sessions, keeps a worktree per tab, and ships branches on your word.",
   "type": "module",
   "bin": {