dsh-fast-mode 1.6.1 → 1.7.1

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,14 +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,
+    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}.

package/src/usage.js

@@ -122,3 +122,26 @@ export function findUsage(source) {
 export function readOutputTokens(source) {
   return readUsage(findUsage(source)).output
 }
+
+/**
+ * Reasoning characters in one assistant message, summed over its blocks.
+ *
+ * This is the *observed* size of the model's thinking, read from the transcript;
+ * it is never written back into a request. Routes that do not persist reasoning
+ * blocks return 0, and a switch that reads this stays silent there — the correct
+ * failure mode for something that is off by default.
+ *
+ * @param {any} source an assistant message, or an event carrying one under `message`
+ * @returns {number}
+ */
+export function readReasoningChars(source) {
+  const message = source && typeof source === 'object' ? (source.message ?? source) : undefined
+  const content = message && Array.isArray(message.content) ? message.content : []
+  let total = 0
+  for (const block of content) {
+    if (block && typeof block === 'object' && block.type === 'reasoning' && typeof block.text === 'string') {
+      total += block.text.length
+    }
+  }
+  return total
+}

package/src/lazy.js

@@ -1,220 +0,0 @@
-/**
- * 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 }