dsh-fast-mode 1.5.34 → 1.6.0

package/index.js

@@ -85,6 +85,7 @@ import { createRecorder } from './src/metrics.js'
 import { readOutputTokens } from './src/usage.js'
 import { configOverridesFor } from './src/state.js'
 import { buildShellParallelTool } from './src/parallel.js'
+import { beginStep as lazyBeginStep, createLazyWatch, DIRECTIVE_SUMMARY as LAZY_SUMMARY, NUDGE_SUMMARY as LAZY_NUDGE_SUMMARY, noteReasoning as lazyNoteReasoning, noteToolResult as lazyNoteToolResult, planEffort as lazyPlanEffort } from './src/lazy.js'
 
 /**
  * The settings-page schema. Re-exported from here because the Loader reads
@@ -98,7 +99,7 @@ const TAG = '[fast-mode]'
  * Shipped identity of this build. Traced into the debug log so a stale install is
  * visible at a glance, and pinned by a test against `package.json`.
  */
-export const VERSION = '1.5.34'
+export const VERSION = '1.6.0'
 const GLOBAL_AGENT = '__global__'
 
 /**
@@ -140,6 +141,26 @@ function latestUserText(messages) {
   return ''
 }
 
+/**
+ * How many messages in this turn came from the human. Plugin notices are also
+ * `role: 'user'`, so a bare role count would move every time this plugin spoke
+ * and every turn would look new.
+ *
+ * @param {unknown} messages
+ * @returns {number}
+ */
+function claimedUserCount(messages) {
+  if (!Array.isArray(messages)) return 0
+  let count = 0
+  for (const m of messages) {
+    if (!m || m.role !== 'user') continue
+    const source = m.source
+    if (source && typeof source === 'object' && source.form === 'notice') continue
+    count += 1
+  }
+  return count
+}
+
 function insertAfterClaimed(messages, claimed, notices) {
   const list = Array.isArray(messages) ? messages : []
   if (notices.length === 0) return list
@@ -189,6 +210,18 @@ function routeOf(resolved) {
   return typeof provider === 'string' && typeof model === 'string' ? `${provider}/${model}` : 'unknown'
 }
 
+/**
+ * The effort label a journal row carries: the resolved value when it is a
+ * string, otherwise `undefined`. Kept separate from the value itself so a route
+ * that hands back a non-string can never be stringified into a fake rung.
+ *
+ * @param {unknown} value
+ * @returns {string | undefined}
+ */
+function summaryEffort(value) {
+  return typeof value === 'string' ? value : undefined
+}
+
 /**
  * Log, once per load, whether this entry's namespace is actually served by the
  * `settings` service — the fact the chip's state depends on.
@@ -396,6 +429,11 @@ export function apply(ctx, rawConfig) {
   // The scheduler's memory, one entry per conversation: what has been tried, how
   // long calls have been taking, and how many steps went by without a new result.
   const auto = createAutoState()
+  const lazyWatch = createLazyWatch()
+  // Which human turn each session is in. `agent/pre-step` carries no turn number,
+  // so the count of claimed (non-plugin) user messages is the boundary: it moves
+  // exactly when the user speaks again.
+  const lazyTurnKey = new Map()
   /**
    * Live stall ceilings per conversation, as computed by the scheduler.
    * Bounded like `compacted`: a long-lived host process sees thousands of
@@ -481,13 +519,27 @@ export function apply(ctx, rawConfig) {
   // `attemptId` whose prefix is the session. They carry no turn or step, so the
   // recorder attributes them to the step that session has open.
   ctx.on('agent/assistant-stream', (payload) => {
-    if (!metrics.enabled) return
     const frame = payload && payload.frame
     if (!frame || frame.type !== 'chunk' || typeof frame.attemptId !== 'string') return
     const cut = frame.attemptId.lastIndexOf(':')
     if (cut <= 0) return
+    const sid = frame.attemptId.slice(0, cut)
     try {
-      metrics.record({ id: frame.attemptId.slice(0, cut) }, {
+      // Lazy mode reads the same stream, and must keep reading when the journal
+      // is off: the effort step-down is decided from how much the route actually
+      // streamed, not from a usage field this route reports as zero.
+      if (lazyWatch.runs.has(sid)) {
+        const chunk = frame.chunk
+        const kind = chunk && typeof chunk === 'object' ? chunk.type : undefined
+        if (kind === 'reasoning-delta') {
+          const text = typeof chunk.text === 'string'
+            ? chunk.text
+            : typeof chunk.delta === 'string' ? chunk.delta : ''
+          lazyNoteReasoning(lazyWatch, sid, text.length)
+        }
+      }
+      if (!metrics.enabled) return
+      metrics.record({ id: sid }, {
         type: 'assistant/chunk',
         time: frame.time,
         data: { chunk: frame.chunk },
@@ -568,6 +620,25 @@ export function apply(ctx, rawConfig) {
           }
         }
       }
+      if (cfg.lazy === true) {
+        // Lazy mode's two prompt-side mechanisms: the ladder text on the first
+        // step of a turn, and at most two nudges when a turn's streamed reasoning
+        // passes its threshold. The tail of a long turn is where over-thinking
+        // costs the most and where a reminder changes the next step rather than
+        // the one already paid for.
+        const key = `${sid}\u0000${claimedUserCount(payload?.messages)}`
+        const fresh = lazyTurnKey.get(sid) !== key
+        if (fresh) {
+          lazyTurnKey.set(sid, key)
+          trim(lazyTurnKey, 200)
+        }
+        const plan = lazyBeginStep(lazyWatch, sid, { firstStep: fresh })
+        if (plan && plan.directive) notices.push(createNoticeMessage(plan.directive, LAZY_SUMMARY))
+        if (plan && plan.nudge) notices.push(createNoticeMessage(plan.nudge, LAZY_NUDGE_SUMMARY))
+        if (plan && initial.debug) {
+          appendDebug(initial.debugFile, `lazy v${VERSION}: turn=${key.split('\u0000').pop()} directive=${plan.directive ? 'yes' : 'no'} nudge=${plan.nudge ? 'yes' : 'no'}`)
+        }
+      }
       if (cfg.workspaceMap === true) {
         // One inventory per session, before the model spends a step finding out
         // what is in the directory (35.7 % of the recorded calls were exactly
@@ -714,6 +785,9 @@ export function apply(ctx, rawConfig) {
         // The scheduler reads the same observation: a call that returns the same
         // bytes for the same arguments is the raw material of the long tail.
         noteTool(auto, agent, observation)
+        // An error result is the one signal that the model may need more room to
+        // think, so it cancels any pending effort step-down for a couple of steps.
+        lazyNoteToolResult(lazyWatch, agent, observation)
       }
     } catch {
       // Observation is best-effort. A failure here must not affect the tool
@@ -729,30 +803,44 @@ export function apply(ctx, rawConfig) {
     const sid = agentKey(payload?.agent)
     const agent = sid === GLOBAL_AGENT ? undefined : sid
     const cfg = configFor(agent)
-    const effort = resolved?.reasoningEffort
+    const baseEffort = resolved?.reasoningEffort
     const route = routeOf(resolved)
-    const label = effort === undefined ? undefined : String(effort)
-
-    // Fast mode does not touch the thinking budget, on purpose. The route and the
-    // effort are the user's contract with the model: a mode that quietly thinks
-    // less produces a different answer, not a faster one, and the measured public
-    // benchmarks showed the effort ladder bought no wall-clock on this route
-    // anyway (0 reasoning tokens in every arm). What is left is the part that
-    // makes the same thinking finish sooner — wider steps, bounded calls, and a
-    // breaker for the sessions that only look busy.
+
+    // The rule this plugin kept for five releases was "never touch the thinking
+    // budget", and it is still the rule unless the user turns on the one switch
+    // that says otherwise. See `src/lazy.js`: it lowers effort only after a step
+    // visibly over-thought, never below the user's own floor, twice a turn at
+    // most, and it restores the resolved value on the very next request — the
+    // 0.9.x damage was that a rewrite outlived the turn that justified it.
     if (!cfg.enabled) {
-      metrics.label(sid, { mode: 'off', gear: 'off', effort: label, route })
+      metrics.label(sid, { mode: 'off', gear: 'off', effort: summaryEffort(baseEffort), effortBase: null, route })
       return resolved
     }
 
     const schedule = cfg.gear === AUTO ? autoSchedule(auto, sid, { emit: false }) : undefined
     checkParallelCap(cfg, schedule?.parallel)
-    metrics.label(sid, { mode: 'on', gear: cfg.gear, effort: label, route })
+    const planned = cfg.lazy === true && cfg.lazyEffort === true
+      ? lazyPlanEffort(lazyWatch, sid, baseEffort)
+      : undefined
+    const applied = planned && planned.reduced ? planned.effort : baseEffort
+    // The journal keeps both halves in one call: `effort` is what the request
+    // carried, `effortBase` is what the user chose, so a comparison can tell a
+    // lazy step-down from a session that was simply started at a lower rung.
+    // `null`, not omitted, on a step that did not step down — otherwise the
+    // previous reduction would leak into every following row.
+    metrics.label(sid, {
+      mode: 'on',
+      gear: cfg.gear,
+      effort: summaryEffort(applied),
+      effortBase: planned && planned.reduced ? summaryEffort(baseEffort) : null,
+      route,
+    })
 
     if (cfg.debug) {
       appendDebug(
         cfg.debugFile,
-        `turn=${payload?.turn} step=${payload?.step} gear=${cfg.gear} effort=${String(label)} (unchanged)`
+        `turn=${payload?.turn} step=${payload?.step} gear=${cfg.gear} effort=${String(summaryEffort(baseEffort))}`
+          + (planned && planned.reduced ? `->${String(applied)} (lazy step-down)` : ' (unchanged)')
           + ` route=${route}`
           + (schedule
             ? ` parallel=${schedule.parallel} budget=${schedule.stallBudgetMs}ms`
@@ -762,17 +850,18 @@ export function apply(ctx, rawConfig) {
       )
     }
 
-    return resolved
+    return planned && planned.reduced ? { ...resolved, reasoningEffort: applied } : resolved
   })
 
   ctx.logger?.info?.(
-    '%s v%s loaded: enabled=%s gear=%s parallel=%d adaptive=%s reasoningEffort=untouched metrics=%s',
+    '%s v%s loaded: enabled=%s gear=%s parallel=%d adaptive=%s reasoningEffort=%s metrics=%s',
     TAG,
     VERSION,
     initial.enabled,
     initial.gear,
     initial.parallel,
     initial.adaptive === true,
+    initial.lazy === true ? (initial.lazyEffort === false ? 'lazy-text-only' : 'lazy') : 'untouched',
     metrics.enabled ? metrics.file : 'off',
   )
   if (initial.legacyGear) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-fast-mode",
-  "version": "1.5.34",
+  "version": "1.6.0",
   "description": "DeepSeek Harness fast mode: same thinking effort, fewer round trips. An adaptive parallel tool fan-out, output discipline that never trims the answer, and a cancellable stall guard. Never changes reasoning effort, the model, or the request body. Provider-agnostic, one dependency (@deepseek-ai/schemastery).",
   "repository": {
     "type": "git",
@@ -46,6 +46,7 @@
     "bench/ablate.py",
     "bench/turns.py",
     "bench/replay.mjs",
+    "bench/soak.mjs",
     "docs/",
     "LICENSE"
   ],

package/src/config.js

@@ -10,7 +10,7 @@
  *   why the on/off switch and the gear selector exist there without a line of
  *   client code.
  *
- * The seven form fields (`enabled`, `gear`, `parallel`, `sessions`,
+ * The form fields (`enabled`, `gear`, `parallel`, `sessions`,
  * `outputDiscipline`, `stepBudget`, `workspaceMap`) are `.volatile()`: that is
  * what makes them appear in the generated form *and* what lets an edit reach a
  * running fiber instead of forcing a remount. A non-volatile declaration is
@@ -18,7 +18,7 @@
  * keeps only volatile nodes, and `update()` refuses the path with "is not
  * volatile".
  *
- * The panel's three rows are volatile for exactly that reason: the client half
+ * The panel's rows are volatile for exactly that reason: the client half
  * has one channel to read state from, `describe()`, so a non-volatile field is a
  * row it can write into `sessions` but never paint — it would keep showing the
  * built-in default (`late` / 0 / off) while a hand-written `cordis.patch.yml`
@@ -39,9 +39,10 @@
  * the form.
  *
  * `enabled` defaults to **false** on purpose: opt-in is what makes "off means
- * completely off" verifiable. Nothing here can change the model's thinking
- * effort — the old `floor` / `ladder` / `aliases` knobs are gone, along with the
- * code that read them.
+ * completely off" verifiable. The old `floor` / `ladder` / `aliases` knobs are
+ * gone, along with the code that read them; the one field that can still move
+ * effort is `lazy`, and it is off by default because it can change the answer,
+ * not only the timing.
  *
  * @module dsh-fast-mode/config
  */
@@ -160,6 +161,21 @@ export const Config = z.object({
       '开局批量 / Opening batch（面板名「一次读多个文件」）: 每轮第一步提醒一次「把已知要做的独立调用放进同一块、shell 命令用 && 串起来」。短任务的钱几乎全花在每步固定成本（首字延迟 ~0.5 s/次）上，少一次往返就省一次；只发一次，不改后续调度。面板可逐会话开；和 `workspaceMap` 一起开时实测 0.742×（11 对），单独开测不到显著，所以默认仍是 false。',
     ),
 
+  lazy: z
+    .boolean()
+    .default(false)
+    .volatile()
+    .description(
+      '想太久就少想一点 / Think less when it stalls（面板「想太久就少想一点」）: 每轮第一步给一次「先找最省的一级、不扩范围、不砍信任边界校验/数据丢失处理/安全/可访问性」的提示；当上一步流出的思考字符 ≥ 1600、或本轮累计超过 4000/8000 时，把下一个请求的思考强度降一档（最低 low、从不升档、每轮最多两次、工具报错后两步内不降）。每个请求都从用户当下的选择重新读基准，所以下一次请求就恢复。默认关闭：它是唯一会改变答案而不只是时延的开关。',
+    ),
+
+  lazyEffort: z
+    .boolean()
+    .default(true)
+    .description(
+      'lazy 的思考强度半边 / Lazy effort step-down: 设为 false 时 lazy 只发提示文字，一个请求字段都不写。对照臂，用来分辨收益来自提示词还是 provider 真的更低档；默认 true。',
+    ),
+
   preferPatch: z
     .boolean()
     .default(false)

package/src/effort.js

@@ -276,6 +276,15 @@ export function resolveConfig(raw, overrides) {
     finishLineSteps: gear.directive
       ? Math.max(0, Math.floor(number(config.finishLineSteps, 0)))
       : 0,
+    /**
+     * Lazy mode: the one switch that may cut deliberation instead of only round
+     * trips. Off by default, because it changes what the model thinks about and
+     * every other switch keeps the "same depth, sooner" promise. `lazyEffort:
+     * false` keeps the ladder text and the nudge but never rewrites effort, so
+     * the two halves can be measured apart.
+     */
+    lazy: gear.directive && config.lazy === true,
+    lazyEffort: gear.directive && config.lazy === true && config.lazyEffort !== false,
     /**
      * The stall guard, the one *hard* bound this plugin owns: it cancels a single
      * tool call at its deadline. On by default; `false` or a negative

package/src/lazy.js

@@ -0,0 +1,220 @@
+/**
+ * Lazy mode: the one switch in this plugin that is allowed to touch how much the
+ * model deliberates.
+ *
+ * Everything else here buys speed while holding effort still — the promise is
+ * "same depth, sooner". This module is the deliberate exception, and it is the
+ * only place in the package that rewrites `reasoningEffort`. It exists because
+ * a long turn loses time in a way parallelism cannot fix: the model keeps
+ * expanding a problem it has already understood. The idea is borrowed from
+ * `ponytail` — a lazy senior developer solves the whole problem with the least
+ * new code, and is lazy about the solution but never about the reading.
+ *
+ * Three mechanisms, cheapest first:
+ *
+ * 1. **The ladder, in the prompt.** One short text asks for the first rung that
+ *    works and a one-line "what I skipped". Cost is input tokens once per turn;
+ *    it changes nothing about the harness.
+ * 2. **The nudge.** When a turn's streamed reasoning passes a threshold without
+ *    a new tool result, one notice says so. It is observation, not policy: it
+ *    repeats what the transcript already proves.
+ * 3. **The effort step-down.** Only when a step visibly over-thought (the
+ *    streamed reasoner block is large) does the next request ask for one rung
+ *    less. It never goes below `FLOOR` (the user's own floor, `low`), never
+ *    fires twice in a row after an error, and is capped per turn.
+ *
+ * What is never cut, in this module or its text: validation at a trust boundary,
+ * error handling that protects data, security, accessibility, and the
+ * deliverable itself. `DIRECTIVE` says so explicitly, because a model told
+ * "write less" drops the wrong things first.
+ *
+ * ## Why the step-down keeps its own ledger
+ *
+ * The 0.9.x release lowered effort from step two of *every* turn. Measured
+ * later, that bought no wall clock on this route and did real damage: the
+ * rewrite reached the provider as a request header, so the composer showed an
+ * effort the user never chose, and it stayed there across restarts. So this
+ * module lowers effort only after evidence, restores the resolved value on the
+ * next request, and is off unless `lazy: true`.
+ */
+
+/** The prompt section. Short on purpose: it is paid on every request of a turn. */
+export const DIRECTIVE = `Work like a lazy senior developer: the best step is the one not taken.
+
+- Read before deciding. Trace the real flow of the code the change touches, then decide. Being lazy about the solution never means being lazy about the reading.
+- Once a step fully does the job, stop planning it. No option, abstraction, or "for later" code nobody asked for.
+- Take the first rung that works: what this repo already has, then the platform or a tool you already hold, then one line, then the minimum that works.
+- Never cut these to save code or time: validation where input crosses a trust boundary, error handling that protects data, security, accessibility, and the deliverable the user asked for.
+- End the turn with one line: what you skipped, and the risk that carries.`
+
+const DIRECTIVE_SUMMARY = 'lazy mode: first rung that works, no scope beyond the task'
+
+/** Reasoning rungs a route may name, weakest first. */
+export const EFFORT_RUNGS = Object.freeze(['minimal', 'low', 'medium', 'high', 'xhigh', 'max'])
+
+/**
+ * The lowest rung this module will ask for. Effort is the user's contract; a
+ * watchdog may spend a little of the headroom a high setting leaves, and stops
+ * where the default would have been.
+ */
+const FLOOR = 'low'
+
+/**
+ * Streamed reasoning characters in one step that count as over-thinking. On the
+ * measured route a normal step streams a few hundred characters and a step stuck
+ * on scope streams thousands, so this is deliberately not a tight bound.
+ */
+const HOT_CHARS = 1600
+
+/** Reasoning characters a turn may spend before the first nudge. */
+const NUDGE_CHARS = 4000
+
+/** How many notices one turn may receive. Two: one early, one late. */
+const MAX_NUDGES = 2
+
+/** How many effort reductions one turn may use. */
+const MAX_REDUCTIONS = 2
+
+/** Steps a reduction is off limits for after an error result (the step it fired on plus two). */
+const ERROR_COOLDOWN = 2
+
+/**
+ * The next rung down, or `undefined` when the value is not a rung this module
+ * understands (a route may use its own vocabulary — never guess at it) or is
+ * already at `FLOOR`.
+ *
+ * @param {string} value
+ * @returns {string | undefined}
+ */
+export function cheaperEffort(value) {
+  const at = EFFORT_RUNGS.indexOf(value)
+  if (at <= 0) return undefined
+  const floor = EFFORT_RUNGS.indexOf(FLOOR)
+  if (at <= floor) return undefined
+  return EFFORT_RUNGS[at - 1]
+}
+
+/** Per-session bookkeeping; one turn at a time is all a session runs. */
+const newTurn = () => ({
+  step: 0,
+  hot: false,
+  stepChars: 0,
+  turnChars: 0,
+  nudges: 0,
+  reductions: 0,
+  coolUntil: 0,
+  nudgedAt: 0,
+  reducedStep: -1,
+})
+
+/**
+ * Create the per-session ledger. Pure and dependency-free so the policy can be
+ * tested without a harness.
+ */
+export function createLazyWatch() {
+  return { runs: new Map() }
+}
+
+/** @param {{runs: Map<string, any>}} watch @param {string} sid */
+const runOf = (watch, sid) => {
+  let run = watch.runs.get(sid)
+  if (run === undefined) {
+    run = newTurn()
+    watch.runs.set(sid, run)
+    if (watch.runs.size > 64) watch.runs.delete(watch.runs.keys().next().value)
+  }
+  return run
+}
+
+/**
+ * Count streamed reasoning characters. Called from the stream tap, i.e. before
+ * the step ends, which is what makes the effort decision possible at all: the
+ * decision has to be made for the *next* request.
+ *
+ * @param {{runs: Map<string, any>}} watch @param {string} sid @param {number} chars
+ */
+export function noteReasoning(watch, sid, chars) {
+  if (!Number.isFinite(chars) || chars <= 0) return
+  const run = runOf(watch, sid)
+  run.stepChars += chars
+  run.turnChars += chars
+}
+
+/**
+ * Open a step: close the previous one's verdict, and say whether this step is
+ * the one that carries the ladder text.
+ *
+ * @param {{runs: Map<string, any>}} watch @param {string} sid
+ * @param {{turn?: number, step?: number, firstStep?: boolean}} where
+ * @returns {{directive?: string, nudge?: string} | undefined}
+ */
+export function beginStep(watch, sid, where) {
+  const run = runOf(watch, sid)
+  const step = Number.isFinite(where?.step) ? Math.floor(where.step) : run.step + 1
+  const newTurnStart = where?.firstStep === true || step <= 1
+  if (newTurnStart) {
+    const fresh = newTurn()
+    fresh.step = step
+    watch.runs.set(sid, fresh)
+    return { directive: DIRECTIVE }
+  }
+  // The previous step's streamed volume is the evidence the next request acts on.
+  run.hot = run.stepChars >= HOT_CHARS
+  run.stepChars = 0
+  run.step = step
+  const plan = {}
+  if (run.nudges < MAX_NUDGES && run.turnChars >= NUDGE_CHARS * (run.nudges + 1) && run.turnChars > run.nudgedAt) {
+    run.nudges += 1
+    run.nudgedAt = run.turnChars
+    run.hot = true
+    plan.nudge = `You have streamed about ${run.turnChars} characters of reasoning this turn. Use what you already have: decide, take the next rung, and say in one line what you skipped. Do not open a new line of investigation unless the last result contradicted an assumption.`
+  }
+  return Object.keys(plan).length === 0 ? undefined : plan
+}
+
+/**
+ * A tool result came back. An error is the one signal that the model may need
+ * *more* thinking, so it cancels any pending step-down for a couple of steps.
+ *
+ * @param {{runs: Map<string, any>}} watch @param {string} sid @param {{isError?: boolean}} observation
+ */
+export function noteToolResult(watch, sid, observation) {
+  if (observation?.isError !== true) return
+  const run = runOf(watch, sid)
+  run.hot = false
+  run.coolUntil = run.step + ERROR_COOLDOWN + 1
+}
+
+/**
+ * The effort this request should carry.
+ *
+ * Returns `base` untouched unless the ledger holds evidence: a hot previous
+ * step, no pending cooldown, budget left, and a base that is a rung above
+ * `FLOOR`. The caller must treat `effort === base` as "nothing happened".
+ *
+ * @param {{runs: Map<string, any>}} watch @param {string} sid
+ * @param {string | undefined} base - the effort the harness resolved.
+ * @returns {{effort: string | undefined, reduced: boolean}}
+ */
+export function planEffort(watch, sid, base) {
+  if (typeof base !== 'string') return { effort: base, reduced: false }
+  const run = runOf(watch, sid)
+  if (run.reducedStep === run.step) {
+    // One step, one reduction: a retry inside the same step must not walk the
+    // effort ladder down twice before anything has been measured again.
+    return { effort: base, reduced: false }
+  }
+  if (!run.hot || run.step < run.coolUntil || run.reductions >= MAX_REDUCTIONS) {
+    return { effort: base, reduced: false }
+  }
+  const cheaper = cheaperEffort(base)
+  if (cheaper === undefined) return { effort: base, reduced: false }
+  run.reductions += 1
+  run.reducedStep = run.step
+  return { effort: cheaper, reduced: true }
+}
+
+/** The notice body for the nudge, built where it is sent (see `index.js`). */
+export const NUDGE_SUMMARY = 'lazy mode: decide with what you have'
+
+export { DIRECTIVE_SUMMARY }

package/src/metrics.js

@@ -113,6 +113,21 @@ const chunkKind = (chunk) => {
   return typeof chunk.type === 'string' ? chunk.type : 'unknown'
 }
 
+/**
+ * The text a delta chunk carries. Adapters spell it `text` or `delta`; anything
+ * else is counted as zero characters rather than guessed at, so the column can
+ * be read as a lower bound and never as an estimate.
+ *
+ * @param {any} chunk
+ */
+const deltaText = (chunk) => {
+  if (!chunk || typeof chunk !== 'object') return ''
+  if (typeof chunk.text === 'string') return chunk.text
+  if (typeof chunk.delta === 'string') return chunk.delta
+  const nested = chunk.delta
+  return nested && typeof nested === 'object' && typeof nested.text === 'string' ? nested.text : ''
+}
+
 const payloadOf = (event) => {
   const data = event && typeof event === 'object' ? event.data : undefined
   return data && typeof data === 'object' ? data : (event ?? {})
@@ -144,7 +159,7 @@ export function createRecorder(options = {}) {
   const on = file.length > 0
   /** @type {Map<string, any>} */
   const steps = new Map()
-  /** @type {Map<string, {mode: string, gear: string, effort?: string, route?: string}>} */
+  /** @type {Map<string, {mode: string, gear: string, effort?: string, effortBase?: string, route?: string}>} */
   const labels = new Map()
   let prepared = false
 
@@ -205,6 +220,8 @@ export function createRecorder(options = {}) {
       calls: 0,
       errors: 0,
       seen: 0,
+      reasoningChars: 0,
+      textChars: 0,
     }
     steps.set(key, entry)
     trim(steps, STEPS_MAX)
@@ -222,8 +239,14 @@ export function createRecorder(options = {}) {
      * Tell the next step rows which stance produced them. Called from the
      * request hook, which is the only place that knows the resolved gear.
      *
+     * A call may carry only some fields: the omitted ones keep the session's
+     * previous value, so a later call cannot blank the gear it does not know
+     * about. `effortBase: null` is the one explicit clear, used when a step did
+     * *not* step down — without it the previous reduction would be attributed to
+     * every following row.
+     *
      * @param {string|undefined} sid
-     * @param {{mode: string, gear: string, effort?: string, route?: string}} label
+     * @param {{mode?: string, gear?: string, effort?: string, effortBase?: string|null, route?: string}} label
      */
     label(sid, label) {
       if (typeof sid !== 'string' || sid.length === 0) return
@@ -232,14 +255,19 @@ export function createRecorder(options = {}) {
       // not exist is pure retention. (1.5.33 and earlier kept them anyway.)
       if (!on) return
       const previous = labels.get(sid)
-      if (previous && previous.mode === label.mode && previous.gear === label.gear
-        && previous.effort === label.effort && previous.route === label.route) return
-      labels.set(sid, {
-        mode: label.mode,
-        gear: label.gear,
-        effort: label.effort,
-        route: label.route,
-      })
+      const next = {
+        mode: label.mode !== undefined ? label.mode : previous && previous.mode,
+        gear: label.gear !== undefined ? label.gear : previous && previous.gear,
+        effort: label.effort !== undefined ? label.effort : previous && previous.effort,
+        effortBase: label.effortBase === null
+          ? undefined
+          : label.effortBase !== undefined ? label.effortBase : previous && previous.effortBase,
+        route: label.route !== undefined ? label.route : previous && previous.route,
+      }
+      if (previous && previous.mode === next.mode && previous.gear === next.gear
+        && previous.effort === next.effort && previous.effortBase === next.effortBase
+        && previous.route === next.route) return
+      labels.set(sid, next)
       trim(labels, LABELS_MAX)
     },
 
@@ -302,6 +330,13 @@ export function createRecorder(options = {}) {
           }
           return
         }
+        // Streaming volume is the only live view of how much the model is
+        // deliberating: this route reports zero reasoning *tokens* in `usage`
+        // even when it streams a long reasoner block, so the character count is
+        // the measurement that can actually be compared across arms.
+        const carried = deltaText(data.chunk)
+        if (chunkType === 'reasoning-delta') entry.reasoningChars += carried.length
+        else if (chunkType === 'text-delta') entry.textChars += carried.length
         if (entry.chunkFirst === undefined) {
           entry.chunkFirst = time
           entry.chunkKind = chunkType
@@ -354,6 +389,7 @@ export function createRecorder(options = {}) {
         mode: label ? label.mode : 'unknown',
         gear: label ? label.gear : 'unknown',
         effort: label ? label.effort : undefined,
+        effortBase: label ? label.effortBase : undefined,
         route: label ? label.route : undefined,
         // `ttftMs` is queue + prefill: `step/start` to the first streamed chunk.
         // `decodeMs` is the generation window that follows it. `llmMs` stays the
@@ -370,6 +406,8 @@ export function createRecorder(options = {}) {
         input: entry.input,
         output: entry.output,
         reasoning: entry.reasoning,
+        reasoningChars: entry.reasoningChars,
+        textChars: entry.textChars,
         cacheRead: entry.cacheRead,
         cacheWrite: entry.cacheWrite,
         assistantMessages: entry.seen,