dsh-fast-mode 1.6.2 → 1.7.2

package/index.js

@@ -82,10 +82,22 @@ import { classifyEntry } from './src/shape.js'
 import { detectPeerPlugins, opsToolsLive } from './src/peers.js'
 import { createStallGuard, stallBudgetFor } from './src/stallguard.js'
 import { createRecorder } from './src/metrics.js'
-import { readOutputTokens } from './src/usage.js'
+import { readOutputTokens, readReasoningChars } 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'
+import {
+  ACT_SUMMARY,
+  LONG_REASONING_SUMMARY,
+  PROBE_SUMMARY,
+  REPEAT_SUMMARY,
+  beginTurn as beginDeliberationTurn,
+  createProgressWatch,
+  deliberationNotice,
+  noteCall as noteDeliberationCall,
+  noteReasoning as noteTurnReasoning,
+  planReasoningNudge,
+  planRepeatNudge,
+} from './src/deliberation.js'
 
 /**
  * The settings-page schema. Re-exported from here because the Loader reads
@@ -99,7 +111,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.6.2'
+export const VERSION = '1.7.2'
 const GLOBAL_AGENT = '__global__'
 
 /**
@@ -366,6 +378,10 @@ export function apply(ctx, rawConfig) {
       try {
         const out = readOutputTokens(event.data ?? event)
         if (out > 0) noteOutputTokens(auto, agentKey(session), out)
+        // Same event, second reading: how much reasoning this turn has written
+        // so far. Observed from the transcript; never written into a request.
+        const chars = readReasoningChars(event.data ?? event)
+        if (chars > 0) noteTurnReasoning(progressWatch, agentKey(session), chars)
       } catch {
         // A counter that can fail a turn is worse than no counter.
       }
@@ -429,11 +445,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()
+  const progressWatch = createProgressWatch()
   // 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()
+  const deliberationTurnKey = new Map()
   /**
    * Live stall ceilings per conversation, as computed by the scheduler.
    * Bounded like `compacted`: a long-lived host process sees thousands of
@@ -525,19 +541,6 @@ export function apply(ctx, rawConfig) {
     if (cut <= 0) return
     const sid = frame.attemptId.slice(0, cut)
     try {
-      // 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',
@@ -620,23 +623,37 @@ 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.
+      if (cfg.probeFirst === true || cfg.actBeforePlan === true || cfg.repeatNudge === true) {
+        // Three prompt-side mechanisms, all opt-in and all visible in the
+        // transcript: one notice at turn entry (probe-first / act-first), and an
+        // evidence nudge when a turn repeats a call or stops learning anything.
+        // Nothing here touches a request field: see `src/deliberation.js`.
         const key = `${sid}\u0000${claimedUserCount(payload?.messages)}`
-        const fresh = lazyTurnKey.get(sid) !== key
+        const fresh = deliberationTurnKey.get(sid) !== key
         if (fresh) {
-          lazyTurnKey.set(sid, key)
-          trim(lazyTurnKey, 200)
+          deliberationTurnKey.set(sid, key)
+          trim(deliberationTurnKey, 200)
+        }
+        const turn = beginDeliberationTurn(progressWatch, sid, key)
+        let directive
+        if (fresh && (cfg.probeFirst === true || cfg.actBeforePlan === true)) {
+          directive = deliberationNotice({ probe: cfg.probeFirst === true, act: cfg.actBeforePlan === true })
+          if (directive) {
+            notices.push(createNoticeMessage(directive, cfg.probeFirst === true ? PROBE_SUMMARY : ACT_SUMMARY))
+          }
         }
-        const plan = lazyBeginStep(lazyWatch, sid, { firstStep: fresh, variant: cfg.lazyVariant })
-        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'}`)
+        let nudge
+        if (cfg.repeatNudge === true) nudge = planRepeatNudge(progressWatch, sid, payload?.step)
+        if (nudge) notices.push(createNoticeMessage(nudge, REPEAT_SUMMARY))
+        let lengthNudge
+        if (cfg.actBeforePlan === true) lengthNudge = planReasoningNudge(progressWatch, sid, payload?.step)
+        if (lengthNudge) notices.push(createNoticeMessage(lengthNudge, LONG_REASONING_SUMMARY))
+        if (initial.debug) {
+          appendDebug(initial.debugFile, `deliberation v${VERSION}: turn=${key.split('\u0000').pop()}`
+            + ` probe=${cfg.probeFirst === true ? 'on' : 'off'} act=${cfg.actBeforePlan === true ? 'on' : 'off'}`
+            + ` directive=${directive ? 'yes' : 'no'} nudge=${nudge ? 'yes' : 'no'}`
+            + ` reasoning=${turn.reasonChars} lengthNudge=${lengthNudge ? 'yes' : 'no'}`
+            + ` calls=${turn.calls.length} stale=${turn.stale}`)
         }
       }
       if (cfg.workspaceMap === true) {
@@ -785,9 +802,14 @@ 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)
+        // The evidence nudge reads the same observation: same call again, or a
+        // run of results that carried nothing new, is what "over-thinking" is
+        // defined as here — not the length of the reasoning stream.
+        noteDeliberationCall(progressWatch, agent, {
+          signature: `${observation.name}\u0000${observation.argsKey}`,
+          digest: observation.digest,
+          isError: observation.isError,
+        })
       }
     } catch {
       // Observation is best-effort. A failure here must not affect the tool
@@ -806,12 +828,12 @@ export function apply(ctx, rawConfig) {
     const baseEffort = resolved?.reasoningEffort
     const route = routeOf(resolved)
 
-    // 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.
+    // Released in 1.7.0: this hook no longer rewrites any request field. The
+    // 1.6.x effort step-down was measurable neither in wall clock (LZ1: 1.106x
+    // against the same text without it, CI crossing 1) nor in usage (the route
+    // reports `reasoning` as 0), and it was the one mechanism that could make the
+    // request differ from what the composer showed. Every mechanism kept in 1.7.0
+    // is prompt-side.
     if (!cfg.enabled) {
       metrics.label(sid, { mode: 'off', gear: 'off', effort: summaryEffort(baseEffort), effortBase: null, route })
       return resolved
@@ -819,20 +841,14 @@ export function apply(ctx, rawConfig) {
 
     const schedule = cfg.gear === AUTO ? autoSchedule(auto, sid, { emit: false }) : undefined
     checkParallelCap(cfg, schedule?.parallel)
-    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.
+    // `effort` is recorded, `effortBase` stays null: nothing in this release
+    // changes it, and a reader comparing the two must be able to tell that the
+    // step-down is gone rather than merely not firing.
     metrics.label(sid, {
       mode: 'on',
       gear: cfg.gear,
-      effort: summaryEffort(applied),
-      effortBase: planned && planned.reduced ? summaryEffort(baseEffort) : null,
+      effort: summaryEffort(baseEffort),
+      effortBase: null,
       route,
     })
 
@@ -840,7 +856,7 @@ export function apply(ctx, rawConfig) {
       appendDebug(
         cfg.debugFile,
         `turn=${payload?.turn} step=${payload?.step} gear=${cfg.gear} effort=${String(summaryEffort(baseEffort))}`
-          + (planned && planned.reduced ? `->${String(applied)} (lazy step-down)` : ' (unchanged)')
+          + ' (unchanged)'
           + ` route=${route}`
           + (schedule
             ? ` parallel=${schedule.parallel} budget=${schedule.stallBudgetMs}ms`
@@ -850,18 +866,20 @@ export function apply(ctx, rawConfig) {
       )
     }
 
-    return planned && planned.reduced ? { ...resolved, reasoningEffort: applied } : resolved
+    return resolved
   })
 
   ctx.logger?.info?.(
-    '%s v%s loaded: enabled=%s gear=%s parallel=%d adaptive=%s reasoningEffort=%s metrics=%s',
+    '%s v%s loaded: enabled=%s gear=%s parallel=%d adaptive=%s switches(probe/act/repeat)=%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',
+    [initial.probeFirst, initial.actBeforePlan, initial.repeatNudge]
+      .map((on) => (on === true ? 'on' : 'off'))
+      .join('/'),
     metrics.enabled ? metrics.file : 'off',
   )
   if (initial.legacyGear) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-fast-mode",
-  "version": "1.6.2",
-  "description": "DeepSeek Harness fast mode: fewer round trips at the same thinking effort. Adaptive parallel tool fan-out, output discipline that never trims the answer, a cancellable stall guard, and one off-by-default switch (lazy) that steps a stalled turn one rung down. By default it never changes reasoning effort, the model, or the request body. Provider-agnostic, one dependency (@deepseek-ai/schemastery).",
+  "version": "1.7.2",
+  "description": "DeepSeek Harness fast mode: fewer round trips at the same thinking effort. Adaptive parallel tool fan-out, output discipline that never trims the answer, a cancellable stall guard, and three off-by-default switches that trim wasted deliberation (read the fact you are unsure of, act after one line of plan, stop when the evidence stops arriving). It never changes reasoning effort, the model, or the request body. Provider-agnostic, one dependency (@deepseek-ai/schemastery).",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/regrevia/dsh-fast-mode.git"

package/src/config.js

@@ -40,9 +40,10 @@
  *
  * `enabled` defaults to **false** on purpose: opt-in is what makes "off means
  * 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.
+ * gone, along with the code that read them, and so is the 1.6.x effort
+ * step-down: no field in this schema changes a request field any more. The three
+ * deliberation switches (`probeFirst`, `actBeforePlan`, `repeatNudge`) only add
+ * prompt text, and all three are off by default.
  *
  * @module dsh-fast-mode/config
  */
@@ -97,7 +98,7 @@ export const Config = z.object({
     .default('late')
     .volatile()
     .description(
-      '输出纪律 / Output discipline（面板「少写过程」，也是没有自己条目的会话的默认值）: 让模型少写过程、只在结论处落笔。`late`（默认）不往系统提示里放文风规则，第 4 步之后由调度器提醒一次——短任务零成本，长任务实测 6 对：墙钟中位 2.68×、步数 10.5→7.5、输出 token −52%、正确性 12/12 不变。`true` 全程生效；`false` 关闭。',
+      '输出纪律 / Output discipline（面板「精简输出」，也是没有自己条目的会话的默认值）: 让模型少写过程、只在结论处落笔。`late`（默认）不往系统提示里放文风规则，第 4 步之后由调度器提醒一次——短任务零成本，长任务实测 6 对：墙钟中位 2.68×、步数 10.5→7.5、输出 token −52%、正确性 12/12 不变。`true` 全程生效；`false` 关闭。',
     ),
 
   shellParallel: z
@@ -115,7 +116,7 @@ export const Config = z.object({
     .default(0)
     .volatile()
     .description(
-      '单轮步数预算 / Steps per turn（面板「最多几步」，0 显示为「不限」）: 用户自设的硬上限，到达后调度器提醒一次按现状汇报；0 = 不限（默认）。步数只说明成本，不说明任务是否完成——默认不再按步数催停，避免把仍在推进的长任务截断。需要成本上限时自己设。',
+      '单轮步数预算 / Steps per turn（面板「步数上限」，0 显示为「不限」）: 用户自设的硬上限，到达后调度器提醒一次按现状汇报；0 = 不限（默认）。步数只说明成本，不说明任务是否完成——默认不再按步数催停，避免把仍在推进的长任务截断。需要成本上限时自己设。',
     ),
 
   finishLineSteps: z
@@ -158,29 +159,31 @@ export const Config = z.object({
     .boolean()
     .default(false)
     .description(
-      '开局批量 / Opening batch（面板名「一次读多个文件」）: 每轮第一步提醒一次「把已知要做的独立调用放进同一块、shell 命令用 && 串起来」。短任务的钱几乎全花在每步固定成本（首字延迟 ~0.5 s/次）上，少一次往返就省一次；只发一次，不改后续调度。面板可逐会话开；和 `workspaceMap` 一起开时实测 0.742×（11 对），单独开测不到显著，所以默认仍是 false。',
+      '开局批量 / Opening batch（面板名「批量读文件」）: 每轮第一步提醒一次「把已知要做的独立调用放进同一块、shell 命令用 && 串起来」。短任务的钱几乎全花在每步固定成本（首字延迟 ~0.5 s/次）上，少一次往返就省一次；只发一次，不改后续调度。面板可逐会话开；和 `workspaceMap` 一起开时实测 0.742×（11 对），单独开测不到显著，所以默认仍是 false。',
     ),
 
-  lazy: z
+  probeFirst: z
     .boolean()
     .default(false)
     .volatile()
     .description(
-      '过度思考时降档 / Cap over-thinking（面板「过度思考时降档」）: 每轮第一步给一次「先找最省的一级、不扩范围、不砍信任边界校验/数据丢失处理/安全/可访问性」的提示；当上一步流出的思考字符 ≥ 1600、或本轮累计超过 4000/8000 时，把下一个请求的思考强度降一档（最低 low、从不升档、每轮最多两次、工具报错后两步内不降）。每个请求都从用户当下的选择重新读基准，所以下一次请求就恢复。默认关闭：它是唯一会改变答案而不只是时延的开关。',
+      '不确定先查证 / Verify before guessing（面板「不确定先查证」）: 每轮第一步的提示里加一句「拿不准的仓库事实就读一次：一次调用，选最便宜的那个（grep 先于 read，读范围先于整文件）；结果出乎意料时先重读，再解释为什么」。只加提示文字，不改任何请求字段、不改调度、不改完成判定。依据是本插件唯一测出大收益的机制就是提示文字（LZ1 0.389×），而参数降档测不出效果；这条专门对着「用推理代替读取」这种过思考。默认关闭。',
     ),
 
-  lazyVariant: z
-    .union(['v1', 'v2', 'v3'].map(name => z.const(name)))
-    .default('v1')
+  actBeforePlan: z
+    .boolean()
+    .default(false)
+    .volatile()
     .description(
-      '实验开关，不进面板：lazy 的梯子文本用哪一版。v1 是 1.6.x 已发布的文本，v2 在它后面加「不重述任务、行动已经清楚就直接做」，v3 是同样规则的精简重写。只用于同一块里对照三版文本，默认 v1；选它不会改变回答以外的任何东西，普通用户不需要动。',
+      '先执行后解释 / Act before explaining（面板「先执行后解释」）: 每轮第一步加一句「不复述任务、不重讲计划；第一个工具调用之前最多一行计划，动作已经清楚就直接做」。省的是每一步的输出字符（实测输出中位一万字符以上），对推理量不一定有效，所以它和另外两条是不同机制、分开开关。默认关闭。',
     ),
 
-  lazyEffort: z
+  repeatNudge: z
     .boolean()
-    .default(true)
+    .default(false)
+    .volatile()
     .description(
-      'lazy 的思考强度半边 / Lazy effort step-down: 设为 false 时 lazy 只发提示文字，一个请求字段都不写。对照臂，用来分辨收益来自提示词还是 provider 真的更低档；默认 true。',
+      '重复时换方法 / Evidence nudge（面板「重复时换方法」）: 轮内检测两种「没有新信息还在想」的证据——同一个调用（工具名+参数）本轮已经出现 ≥2 次，或连续 ≥3 次工具结果的内容完全相同；命中时在下一步之前发一句带计数的提醒，每轮最多两次、同一证据不重复。它只读本轮已经发生的调用，不发请求、不写请求字段。按推理字符数触发只是「过度思考」的代理指标，短任务上会误触发，这条改用它本身的定义。默认关闭。',
     ),
 
   preferPatch: z
@@ -232,7 +235,7 @@ export const Config = z.object({
     .default(false)
     .volatile()
     .description(
-      '工作区清单 / Workspace inventory（面板「先列文件清单」）: 会话开始时不调用任何工具，harness 自己走一遍 cwd（深度 2、最多 60 条、跳过 node_modules 等）把路径、大小和现有测试入口作为一条提示交给模型。实测 `def15` 会话里 35.7% 的工具调用是 ls/find/cat 这类探路，其中 40% 出现在前两次调用里——这一步就是把那次往返拿掉。只发一次，不隐藏任何文件，读文件仍由模型自己决定。',
+      '工作区清单 / Workspace inventory（面板「开局附文件清单」）: 会话开始时不调用任何工具，harness 自己走一遍 cwd（深度 2、最多 60 条、跳过 node_modules 等）把路径、大小和现有测试入口作为一条提示交给模型。实测 `def15` 会话里 35.7% 的工具调用是 ls/find/cat 这类探路，其中 40% 出现在前两次调用里——这一步就是把那次往返拿掉。只发一次，不隐藏任何文件，读文件仍由模型自己决定。',
     ),
 
   mapEntries: z

package/src/deliberation.js

@@ -0,0 +1,217 @@
+/**
+ * Deliberation controls: the three opt-in mechanisms that replaced the retired
+ * effort step-down in 1.7.0.
+ *
+ * Why the old half went away: rewriting `reasoningEffort` for one request turned
+ * out to be unmeasurable on the route this plugin runs on (the provider reports
+ * `reasoning` usage as 0 on every row, so there is no evidence the parameter is
+ * honoured) and it was the one mechanism that changed answers rather than only
+ * latency. See BENCHMARK.md, LZ1: text-only 0.389x vs text+step-down 0.430x.
+ *
+ * What is left is three switches, all visible in the transcript instead:
+ *   1. `probeFirst`   — one line at turn entry: look up the fact you are unsure
+ *                       of instead of reasoning about it.
+ *   2. `actBeforePlan`— one line at turn entry: at most one line of plan before
+ *                       the first call, and act when the next action is clear.
+ *   3. `repeatNudge`  — an evidence nudge mid-turn: the same call already ran, or
+ *                       the last few results carried nothing new. This targets
+ *                       the definition of over-thinking ("no new information, and
+ *                       still thinking") instead of its proxy ("long reasoning").
+ *
+ * `actBeforePlan` also carries a length nudge. Repetition turned out to be blind
+ * on tasks that read one new file per step, so the second signal is the one the
+ * transcript already records: how many characters of reasoning this turn has
+ * written. It is counted from `assistant/message` events and never written back,
+ * so like everything else here it can only add text to the prompt.
+ *
+ * All three are prompt-side only. No config field is written, no request field
+ * changes, so nothing here can make the request differ from what the composer
+ * shows.
+ */
+
+/** Never-cut guard: the point of thinking less is not to skip the expensive checks. */
+export const GUARD =
+  'None of this cuts validation at trust boundaries, data-loss handling, security, or accessibility.'
+
+export const PROBE_TEXT =
+  'When you are unsure of a fact about the codebase — a file\'s contents, a signature, a test\'s expectation — read it once instead of reasoning about it. One call, the cheapest that answers the question: `grep` before `read`, a range before the whole file. Guessing costs a step and is usually wrong; looking costs the same step and settles it. Read again when a result surprises you, before theorising about why it surprised you.'
+
+export const ACT_TEXT =
+  'Do not restate the task and do not re-explain the plan: the reader already has it. Before your first tool call, one line of plan is enough; when the next action is already clear, take it now and explain afterwards only if the result is not self-evident.'
+
+export const PROBE_SUMMARY = 'probe-first: read the fact, do not reason about it'
+export const ACT_SUMMARY = 'act-first: one line of plan, then work'
+export const REPEAT_SUMMARY = 'repeat nudge: same call again, or no new information'
+export const LONG_REASONING_SUMMARY = 'over-thinking: think with what you have'
+
+/** Cumulative reasoning characters in one turn that earn the first length nudge. */
+export const REASONING_CHARS = 4000
+/** At most this many length nudges per turn. */
+export const MAX_REASONING_NUDGES = 2
+
+/** At most this many evidence nudges per turn. */
+export const MAX_REPEAT_NUDGES = 2
+/** The same call (name + arguments) seen this many times in one turn is a loop. */
+export const REPEAT_CALLS = 2
+/** Consecutive unchanged results beyond the first: three identical results in a row. */
+export const STALE_RESULTS = 2
+/** Bounded history per conversation; the watch is a WeakMap-free Map trimmed by age. */
+const HISTORY_MAX = 8
+const RUN_MAX = 64
+
+/**
+ * The turn-entry notice. Both text switches share one message and one guard line
+ * so that turning both on does not cost two notices.
+ * @param {{probe?: boolean, act?: boolean}} switches
+ * @returns {string|undefined}
+ */
+export function deliberationNotice(switches) {
+  const parts = []
+  if (switches?.probe === true) parts.push(PROBE_TEXT)
+  if (switches?.act === true) parts.push(ACT_TEXT)
+  if (parts.length === 0) return undefined
+  return `${parts.join('\n\n')}\n\n${GUARD}`
+}
+
+/** @returns {{runs: Map<string, object>}} */
+export function createProgressWatch() {
+  return { runs: new Map() }
+}
+
+function runOf(watch, sid) {
+  let run = watch.runs.get(sid)
+  if (!run) {
+    run = { key: '', calls: [], stale: 0, nudges: 0, nudgedFor: '', reasonChars: 0, reasonNudges: 0 }
+    watch.runs.set(sid, run)
+    if (watch.runs.size > RUN_MAX) {
+      const oldest = watch.runs.keys().next().value
+      if (oldest !== undefined && oldest !== sid) watch.runs.delete(oldest)
+    }
+  }
+  return run
+}
+
+/**
+ * Start (or continue) a conversation's turn. A new user message resets the
+ * evidence: the previous turn's loop is not this turn's.
+ * @param {{runs: Map<string, object>}} watch
+ * @param {string} sid
+ * @param {string} key turn identity
+ */
+export function beginTurn(watch, sid, key) {
+  const run = runOf(watch, sid)
+  if (run.key !== key) {
+    run.key = key
+    run.calls = []
+    run.stale = 0
+    run.nudges = 0
+    run.nudgedFor = ''
+    run.reasonChars = 0
+    run.reasonNudges = 0
+  }
+  return run
+}
+
+/**
+ * Record one finished tool call. `signature` must be stable across repeats of the
+ * same call (tool name + arguments), `digest` the hash of the result content.
+ * Error results are counted as "something happened", never as a loop signal: an
+ * error is information, and it is the one case where more thought is warranted.
+ * @param {{runs: Map<string, object>}} watch
+ * @param {string} sid
+ * @param {{signature?: string, digest?: string, isError?: boolean}} call
+ */
+export function noteCall(watch, sid, call) {
+  const run = runOf(watch, sid)
+  const signature = typeof call?.signature === 'string' ? call.signature : ''
+  const digest = typeof call?.digest === 'string' ? call.digest : ''
+  const last = run.calls[run.calls.length - 1]
+  if (call?.isError !== true && last !== undefined && digest !== '' && digest === last.digest) {
+    run.stale += 1
+  } else {
+    run.stale = 0
+  }
+  // An error is information: it resets the "nothing new" run, and it never counts
+  // as a repeated call, because the next step after a failure is exactly where
+  // more thought is warranted rather than less.
+  const isError = call?.isError === true
+  run.calls.push({ signature: isError ? '' : signature, digest, isError })
+  if (run.calls.length > HISTORY_MAX) run.calls.shift()
+}
+
+/**
+ * The evidence nudge for the next step, or undefined when the turn shows no loop.
+ * Every nudge names the count it saw, because "you are looping" without a number
+ * reads as an opinion and this one has to read as a finding.
+ * @param {{runs: Map<string, object>}} watch
+ * @param {string} sid
+ * @param {number} step
+ * @returns {string|undefined}
+ */
+export function planRepeatNudge(watch, sid, step) {
+  const run = runOf(watch, sid)
+  if (run.nudges >= MAX_REPEAT_NUDGES) return undefined
+
+  let condition = ''
+  let text = ''
+
+  const last = run.calls[run.calls.length - 1]
+  if (last !== undefined && last.signature !== '') {
+    const same = run.calls.filter((call) => call.signature === last.signature).length
+    if (same >= REPEAT_CALLS) {
+      // The digest is part of the condition: the same call returning new content
+      // is new evidence, and earns its own sentence once.
+      condition = `repeat:${last.signature}:${last.digest}`
+      text = `The call you are about to reason about has already run ${same} times in this turn and returned what you have. If the answer did not change, a different call is what changes it — not more thinking about this one.`
+    }
+  }
+
+  if (text === '' && run.stale >= STALE_RESULTS) {
+    condition = `stale:${last?.digest ?? ''}`
+    text = `The last ${run.stale + 1} calls returned the same content. Nothing new is arriving from that direction: decide with what you have, or ask a different question.`
+  }
+
+  if (text === '' || condition === run.nudgedFor) return undefined
+  run.nudges += 1
+  run.nudgedFor = condition
+  run.debugWhy = `${condition} step=${step}`
+  return text
+}
+
+/**
+ * Add one assistant message's reasoning size to this turn's running total.
+ *
+ * Per turn, not per session: the length of *this* attempt is what the next step
+ * needs to know, and the next user message starts the measurement over.
+ *
+ * @param {{runs: Map<string, object>}} 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.reasonChars += chars
+}
+
+/**
+ * The length nudge for the next step, or undefined when this turn has not yet
+ * thought longer than a decision needs. Fires at most `MAX_REASONING_NUDGES`
+ * times per turn and names the size it saw, so the message reads as a finding
+ * rather than an opinion.
+ *
+ * @param {{runs: Map<string, object>}} watch
+ * @param {string} sid
+ * @param {number} step
+ * @returns {string|undefined}
+ */
+export function planReasoningNudge(watch, sid, step) {
+  const run = runOf(watch, sid)
+  if (run.reasonNudges >= MAX_REASONING_NUDGES) return undefined
+  const threshold = REASONING_CHARS * (run.reasonNudges + 1)
+  if (run.reasonChars < threshold) return undefined
+  run.reasonNudges += 1
+  run.debugWhy = `reasoning:${run.reasonChars} step=${step}`
+  const seen = Math.round(run.reasonChars / 100) * 100
+  return `You have written about ${seen} characters of reasoning in this turn. Past that length, more thinking about facts you already have rarely changes the next action: take the action the evidence supports, or read the one fact that is still missing.`
+}

package/src/effort.js

@@ -277,15 +277,14 @@ export function resolveConfig(raw, overrides) {
       ? 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.
+     * The three deliberation switches of 1.7.0, all prompt-side and all opt-in.
+     * They replaced the 1.6.x effort step-down, which could change an answer
+     * without being measurable on this route. `probeFirst` and `actBeforePlan`
+     * cost one notice at turn entry; `repeatNudge` reads the turn's own calls.
      */
-    lazy: gear.directive && config.lazy === true,
-    lazyEffort: gear.directive && config.lazy === true && config.lazyEffort !== false,
-    lazyVariant: String(config.lazyVariant || 'v1'),
+    probeFirst: gear.directive && config.probeFirst === true,
+    actBeforePlan: gear.directive && config.actBeforePlan === true,
+    repeatNudge: gear.directive && config.repeatNudge === true,
     /**
      * 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/state.js

@@ -14,7 +14,7 @@
  *   has an entry of its own. Only an edit in `cordis.patch.yml` changes them;
  *   the chip and the panel never write them.
  * - The `sessions` field carries every per-session choice: `{ sessionId: {
- *   enabled, gear, discipline, stepBudget, map, batch, lazy, ts } }` as a compact JSON
+ *   enabled, gear, discipline, stepBudget, map, batch, probeFirst, actBeforePlan, repeatNudge, ts } }` as a compact JSON
  *   string. It is volatile, so a write lands in the running plugin without a
  *   remount.
  *
@@ -107,7 +107,9 @@ function sanitise(input) {
     if (Number.isFinite(entry.stepBudget) && entry.stepBudget >= 0) clean.stepBudget = Math.floor(Number(entry.stepBudget))
     if (typeof entry.map === 'boolean') clean.map = entry.map
     if (typeof entry.batch === 'boolean') clean.batch = entry.batch
-    if (typeof entry.lazy === 'boolean') clean.lazy = entry.lazy
+    if (typeof entry.probeFirst === 'boolean') clean.probeFirst = entry.probeFirst
+    if (typeof entry.actBeforePlan === 'boolean') clean.actBeforePlan = entry.actBeforePlan
+    if (typeof entry.repeatNudge === 'boolean') clean.repeatNudge = entry.repeatNudge
     if (Number.isFinite(entry.ts)) clean.ts = Number(entry.ts)
     if (
       clean.enabled === undefined
@@ -116,7 +118,9 @@ function sanitise(input) {
       && clean.stepBudget === undefined
       && clean.map === undefined
       && clean.batch === undefined
-      && clean.lazy === undefined
+      && clean.probeFirst === undefined
+      && clean.actBeforePlan === undefined
+      && clean.repeatNudge === undefined
     ) continue
     out[sessionId] = clean
   }
@@ -142,7 +146,9 @@ export function choiceFor(raw, sessionId) {
   if (entry.stepBudget !== undefined) choice.stepBudget = entry.stepBudget
   if (entry.map !== undefined) choice.map = entry.map
   if (entry.batch !== undefined) choice.batch = entry.batch
-  if (entry.lazy !== undefined) choice.lazy = entry.lazy
+  if (entry.probeFirst !== undefined) choice.probeFirst = entry.probeFirst
+  if (entry.actBeforePlan !== undefined) choice.actBeforePlan = entry.actBeforePlan
+  if (entry.repeatNudge !== undefined) choice.repeatNudge = entry.repeatNudge
   return choice
 }
 
@@ -168,7 +174,9 @@ export function configOverridesFor(raw, sessionId) {
   if (choice.stepBudget !== undefined) overrides.stepBudget = choice.stepBudget
   if (choice.map !== undefined) overrides.workspaceMap = choice.map
   if (choice.batch !== undefined) overrides.openBatch = choice.batch
-  if (choice.lazy !== undefined) overrides.lazy = choice.lazy
+  if (choice.probeFirst !== undefined) overrides.probeFirst = choice.probeFirst
+  if (choice.actBeforePlan !== undefined) overrides.actBeforePlan = choice.actBeforePlan
+  if (choice.repeatNudge !== undefined) overrides.repeatNudge = choice.repeatNudge
   return Object.keys(overrides).length === 0 ? undefined : overrides
 }
 
@@ -220,12 +228,14 @@ export function writeChoice(raw, sessionId, choice, now) {
   if (Number.isFinite(choice.stepBudget) && choice.stepBudget >= 0) next.stepBudget = Math.floor(Number(choice.stepBudget))
   if (typeof choice.map === 'boolean') next.map = choice.map
   if (typeof choice.batch === 'boolean') next.batch = choice.batch
-  if (typeof choice.lazy === 'boolean') next.lazy = choice.lazy
+  if (typeof choice.probeFirst === 'boolean') next.probeFirst = choice.probeFirst
+  if (typeof choice.actBeforePlan === 'boolean') next.actBeforePlan = choice.actBeforePlan
+  if (typeof choice.repeatNudge === 'boolean') next.repeatNudge = choice.repeatNudge
   map[sessionId] = next
   return { sessions: encodeChoices(map), map }
 }
 
-/** @typedef {{enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean, batch?: boolean, lazy?: boolean, ts?: number}} SessionEntry */
+/** @typedef {{enabled?: boolean, gear?: string, discipline?: boolean|'late', stepBudget?: number, map?: boolean, batch?: boolean, probeFirst?: boolean, actBeforePlan?: boolean, repeatNudge?: boolean, ts?: number}} SessionEntry */
 
 /**
  * Serialise the map, dropping the oldest entries beyond {@link SESSIONS_LIMIT}.