@hicaru/pi-rlm 0.3.20 → 0.3.22

package/src/index.ts

@@ -29,11 +29,18 @@ import type { AddContextHandlerBundle } from "./bridge/add-context.ts";
 import { buildNativeSystemPrompt } from "./prompts/native.ts";
 import { SkillStore, notesFromRunState, xiQuery } from "./config/skillstate.ts";
 import { buildRootDigestCompaction } from "./core/root-digest.ts";
-import { RootStateTracker } from "./core/root-state.ts";
+import { ROOT_IDLE_DEGRADE_TURNS, RootStateTracker } from "./core/root-state.ts";
 import { elideStalePayloads, spliceSigmaSnapshot } from "./core/root-context.ts";
+import { SessionArchive } from "./core/session-archive.ts";
 import { agentMessageText, firstLine, textContentOf } from "./text/agent-text.ts";
 import { findStatePatches } from "./text/parsing.ts";
 import { capToolResultText } from "./mode/native-guards.ts";
+import {
+  STAGE_CUSTOM_TYPE,
+  renderStageCard,
+  stageCardMarkdown,
+  type StageCardDetails,
+} from "./ui/stage-cards.ts";
 import {
   isSubagentChildBypass,
   commitSubagentForceActivation,
@@ -108,17 +115,36 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     hideWhenEmpty: true,
   });
   let treePanelInstalled = false;
+  /**
+   * Native-mode abort: repl cells' child engines, detached spawn() tasks and add_context
+   * loads read this signal lazily (createReplTool getSignal), so /rlm-stop aborts AND
+   * rotates the controller mid-session — work started after a stop sees a fresh signal.
+   */
+  let nativeAbort = new AbortController();
+  const stopNativeWork = (): boolean => {
+    const hadWork = runRegistry.hasActive() || background.pending > 0;
+    nativeAbort.abort();
+    nativeAbort = new AbortController();
+    return hadWork;
+  };
   /** SKILL.state (Workstream B): session store — hydrated at session_start, flushed at shutdown. */
   let skillStore: SkillStore | undefined;
   /** Root Σ (WS-3/4): the native session's digest-level Σ_t — runtime-derived (tool outcomes,
    *  engine mirrors, prompts); lazily born on the first prompt, harvested + dropped at shutdown. */
   let rootTracker: RootStateTracker | undefined;
+  /** Recall W1: elided turns archive here and materialize into the sandbox
+   *  (ctx/session-log/*) so search()/grep_context() recall them. Per-session, closure-only. */
+  const sessionArchive = new SessionArchive(config.rootArchiveMaxChars);
+  /** Archive gate: enabled (chars > 0) AND the context transform actually running. */
+  const archiveActive = (): boolean =>
+    controller.config.rootArchiveMaxChars > 0 && rootContextActive();
   // Root Σ WS-5.1 telemetry — journal counters (trace lines + status widget when tracing).
   let xiCompositions = 0;
   let rootDigests = 0;
   let elidedMessages = 0;
   let sigmaSplices = 0;
   let idleDegrades = 0;
+  let archivedTurns = 0;
   /** R6: Σ counter snapshot for the status line — a fresh readonly object per render. */
   const sigmaTelemetry = (): RootSigmaTelemetry => ({
     xiCompositions,
@@ -127,6 +153,21 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     sigmaSplices,
     idleDegrades,
   });
+  /** [rlm.stage]: post one stage-transition card into the transcript (persisted, ctrl+o-expandable). */
+  const postStageCard = (details: StageCardDetails): void => {
+    try {
+      pi.sendMessage({ customType: STAGE_CUSTOM_TYPE, content: stageCardMarkdown(details), display: true, details });
+    } catch (err) {
+      // Stage cards are decoration — never fail the hook that produced the transition.
+      if (traceEnabled) trace("stage-card.fail", { error: errorMessage(err) });
+    }
+  };
+  /**
+   * Compaction-hook re-entrancy guard: session_before_compact builds the digest card but does
+   * NOT post it from inside the hook (a message appended mid-compaction would fold into the
+   * very span being digested) — the pending card flushes at the next turn_start instead.
+   */
+  let pendingDigestCard: StageCardDetails | undefined;
   // A detached child works in its OWN sandbox, so this one sees no frames and its request
   // watchdog would fire mid-await and SIGKILL a healthy worker, taking the REPL namespace
   // with it. Keep it alive while detached work is genuinely in flight.
@@ -173,7 +214,9 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     const cfg = controller.config;
     // R0: enableSkillState is enforced (validateEnforcedOn) — no config check remains.
     if (skillStore === undefined) return undefined;
-    const block = skillStore.blockFor(query, cfg.skillStateMaxTokens);
+    // Recall W3: the Ξ block honors the configured score floor (was MIN_VALUE — any
+    // positively-scored stale note rode every prompt).
+    const block = skillStore.blockFor(query, cfg.skillStateMaxTokens, cfg.skillStateXiMinScore);
     return block === "" ? undefined : block;
   };
 
@@ -189,6 +232,8 @@ export default function rlmExtension(pi: ExtensionAPI): void {
   pi.registerMessageRenderer("rlm-intro", (message, _options, theme) =>
     new Markdown(textContentOf(message.content), 1, 0, markdownTheme(theme)),
   );
+  // [rlm.stage] cards — orchestrator stage transitions, collapsed until the user's ctrl+o.
+  pi.registerMessageRenderer(STAGE_CUSTOM_TYPE, renderStageCard);
 
   // ── CLI flag: `pi --rlm` / `pi --rlm=false` overrides the persisted mode for this run ──
   pi.registerFlag("rlm", {
@@ -197,7 +242,7 @@ export default function rlmExtension(pi: ExtensionAPI): void {
   });
 
   // ── Commands ──
-  registerRlmCommand(pi, controller);
+  registerRlmCommand(pi, controller, stopNativeWork);
   registerRlmConfigCommand(pi, controller);
   registerRlmLlmCommand(pi, controller);
   registerRlmRlmCommand(pi, controller);
@@ -322,6 +367,7 @@ export default function rlmExtension(pi: ExtensionAPI): void {
           background,
           runRegistry,
           skillStore,
+          getSignal: () => nativeAbort.signal,
           onRunState: (state) => { rootTracker?.absorbEngineState(state); },
           getSkillBlock: composeSkillBlock,
           registerDiscardHook: (reset) => { onSandboxDiscardExtra = reset; },
@@ -362,6 +408,14 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     setRlmModeStatus(ctx, controller, ctx.getContextUsage(), sigmaTelemetry());
   });
 
+  // Deferred [rlm.stage] digest card — built inside session_before_compact, posted here.
+  pi.on("turn_start", async () => {
+    const card = pendingDigestCard;
+    if (card === undefined) return;
+    pendingDigestCard = undefined;
+    postStageCard(card);
+  });
+
   /** True when the native-mode trade holds: enabled AND repl is in the active tool set. */
   const nativeTradeHolds = (): boolean =>
     shouldEnforceNativeReaderBlock({
@@ -423,8 +477,13 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     const tracker = rootTracker;
     if (tracker === undefined || !controller.config.enableRootStateFences) return;
     if (event.message.role !== "assistant") return;
+    // Recall W2: a turn that ran TOOLS did work — it is never fence-idle (file-editing
+    // sessions were degrading before their first fence landed). Productive turns neither
+    // grow nor reset the idle streak; prose-only turns keep the R4 ladder.
+    const productiveTurn = Array.isArray(event.message.content) &&
+      (event.message.content as Array<{ type?: string }>).some((b) => b?.type === "toolCall");
     const wasActive = tracker.isActive;
-    const outcome = tracker.applyFences(findStatePatches(agentMessageText(event.message)));
+    const outcome = tracker.applyFences(findStatePatches(agentMessageText(event.message)), { productiveTurn });
     // R3 soak observability: per-turn fence outcomes — the soak-B bars (≥50% of turns commit
     // ≥1 accepted delta, rejection storms <10%) are computed from these journal lines.
     if (traceEnabled) {
@@ -439,6 +498,12 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     }
     if (wasActive && !tracker.isActive) {
       idleDegrades += 1;
+      postStageCard({
+        kind: "degrade",
+        reason: tracker.degradeReason ?? "unknown",
+        idleTurns: tracker.idleTurns,
+        idleMax: ROOT_IDLE_DEGRADE_TURNS,
+      });
       if (traceEnabled) {
         const reason = tracker.degradeReason ?? "unknown";
         trace(reason.startsWith("idle") ? "root-state.idle-degrade" : "root-state.degrade", {
@@ -446,6 +511,9 @@ export default function rlmExtension(pi: ExtensionAPI): void {
           reason,
         });
       }
+    } else if (!wasActive && tracker.isActive) {
+      // R7-fix recovery observability, user-visible: a degraded tracker accepted a clean batch.
+      postStageCard({ kind: "recover", fencesAccepted: outcome.accepted, fencesTotal: outcome.fences });
     }
   });
 
@@ -462,6 +530,14 @@ export default function rlmExtension(pi: ExtensionAPI): void {
       });
       if (result !== undefined) {
         rootDigests += 1;
+        pendingDigestCard = {
+          kind: "digest",
+          index: rootDigests,
+          turnsFolded: event.preparation.messagesToSummarize.length,
+          tokensBefore: result.compaction.tokensBefore,
+          tokensBeforeRecomputed: result.tokensBeforeRecomputed,
+          summary: result.compaction.summary,
+        };
         if (traceEnabled) {
           // V1 soak probe: host-consumed tokensBefore vs our recomputation over the same span.
           trace("root-digest.built", {
@@ -486,7 +562,7 @@ export default function rlmExtension(pi: ExtensionAPI): void {
   // ── Context injection: listing of whatever is currently loaded ──
   // Re-inject only when the payload identity changes (seed / add_context), not every turn —
   // the listing can be up to 200 file lines and the plugin exists to shrink the root window.
-  pi.on("context", async (event) => {
+  pi.on("context", async (event, ctx) => {
     const filtered = event.messages.filter(
       (message) =>
         !(message.role === "custom" && message.customType === "rlm-intro")
@@ -499,10 +575,23 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     // then splice exactly one fresh Σ snapshot. Fail-soft: a throw here must never break a turn.
     if (rootContextActive()) {
       try {
-        const elided = elideStalePayloads(filtered, {
-          keepTurns: controller.config.rootContextKeepTurns,
-          elideChars: controller.config.rootContextElideChars,
-        });
+        // Recall W1: every destroyed message's full text rides the sink into the session
+        // archive BEFORE the stub replaces it — elision stays dereferenceable.
+        const sink = archiveActive()
+          ? (entry: { role: "assistant" | "toolResult"; toolName: string | undefined; text: string }) => {
+              const seq = sessionArchive.record(entry);
+              if (seq !== undefined) archivedTurns += 1;
+            }
+          : undefined;
+        const elided = elideStalePayloads(
+          filtered,
+          {
+            keepTurns: controller.config.rootContextKeepTurns,
+            elideChars: controller.config.rootContextElideChars,
+            archiveActive: sink !== undefined,
+          },
+          sink,
+        );
         elidedMessages += elided;
         const tracker = rootTracker;
         // R4 REV (amnesia fix): degrade suspends fence WRITES (applyFences gate) — never Σ
@@ -523,8 +612,31 @@ export default function rlmExtension(pi: ExtensionAPI): void {
           });
           sigmaSplices += 1;
         }
+        // Recall W1 flush: materialize new archive segments into the sandbox — ONLY when a
+        // worker already exists (never spawn Python from a context event) and fail-soft.
+        const pendingSegment = archiveActive() && sandboxManager.isAlive
+          ? sessionArchive.renderPending()
+          : undefined;
+        if (pendingSegment !== undefined) {
+          const cwd = resolve(ctx?.cwd ?? process.cwd());
+          const written = await sandboxManager.upsertArchiveSegment(pendingSegment.path, pendingSegment.text, cwd);
+          if (traceEnabled) {
+            trace("root-archive.flush", {
+              path: pendingSegment.path,
+              chars: pendingSegment.text.length,
+              written,
+              stats: sessionArchive.stats,
+            });
+          }
+        }
         if (traceEnabled && (elided > 0 || sigmaSplices > 0)) {
-          trace("root-context.transform", { elided, total: elidedMessages, splices: sigmaSplices });
+          trace("root-context.transform", {
+            elided,
+            total: elidedMessages,
+            splices: sigmaSplices,
+            archived: archivedTurns,
+            archiveChars: sessionArchive.stats.chars,
+          });
         }
       } catch (err) {
         if (traceEnabled) trace("root-context.fail", { error: errorMessage(err) });
@@ -571,6 +683,13 @@ export default function rlmExtension(pi: ExtensionAPI): void {
         event.isError,
         event.isError ? firstLine(textContentOf(event.content)) : "",
       );
+      // Recall W2 deterministic harvest (commit-at-first-sight, paper §7): successful reads
+      // are Σ facts the moment they happen — previously the only runtime feeds were tool
+      // ERRORS and edits, so the early turns (the ones elided first) never reached Σ.
+      if (!event.isError && event.toolName === "read") {
+        const path = extractEditPaths(event.input)[0];
+        if (path !== undefined) tracker.noteFact(`read ${path}`);
+      }
     }
 
     // ── Keep RLM context fresh after native file mutations ──
@@ -617,14 +736,25 @@ export default function rlmExtension(pi: ExtensionAPI): void {
     const tracker = rootTracker;
     if (skillStore !== undefined && tracker !== undefined && tracker.dirty) {
       try {
-        skillStore.merge(notesFromRunState(tracker.snapshot()));
-        if (traceEnabled) trace("root-harvest.merged", { notes: tracker.snapshot().verifiedFacts.length });
+        const merged = notesFromRunState(tracker.snapshot());
+        skillStore.merge(merged);
+        if (merged.length > 0) {
+          // One-line stage card: what this session taught the store (tag histogram via stats()).
+          postStageCard({
+            kind: "distill",
+            merged,
+            total: skillStore.noteCount,
+            byTag: skillStore.stats().byTag,
+          });
+        }
+        if (traceEnabled) trace("root-harvest.merged", { notes: merged.length });
       } catch (err) {
         if (traceEnabled) trace("root-harvest.fail", { error: errorMessage(err) });
       }
     }
     await skillStore?.flush(); // SKILL.state (Workstream B): persist distilled notes
     controller.abort();
+    nativeAbort.abort(); // detach engines/spawns still holding the session signal
     clearInterval(watchdogHeartbeat);
     background.dispose();
     await sandboxManager.dispose();

package/src/mode/rlm-mode.ts

@@ -120,10 +120,10 @@ export class RlmController {
   }
 
   /** Ξ (Workstream C): BM25 slice of the session SkillState for a root prompt; undefined when
-   *  the store is absent/disabled or nothing is relevant. */
+   *  the store is absent/disabled or nothing is relevant. Recall W3: honors the Ξ score floor. */
   private skillBlockFor(query: string): string | undefined {
     if (this.skillStore === undefined || !this.config.enableSkillState) return undefined;
-    const block = this.skillStore.blockFor(query, this.config.skillStateMaxTokens);
+    const block = this.skillStore.blockFor(query, this.config.skillStateMaxTokens, this.config.skillStateXiMinScore);
     return block === "" ? undefined : block;
   }
 

package/src/prompts/glossary.ts

@@ -7,6 +7,8 @@
  * about functions that do not exist, or not told about ones that do.
  */
 
+import { ARCHIVE_NAMESPACE } from "../core/session-archive.ts";
+
 export type ContextKind = "files" | "text";
 
 /** "str" (raw string context, e.g. rlm_query children) → text; everything else → files. */
@@ -28,9 +30,11 @@ export function promptCapTokensK(maxPromptChars: number): number {
  * the outcome (§5, Fig. 4a). These cost no tokens and no sub-calls.
  */
 const RETRIEVAL_GLOSSARY_LINES: readonly string[] = Object.freeze([
-  "- `search(query: str, k=10, path_glob=None)`: BM25 ranking over `context`. Returns",
-  "  [{path, line, score, snippet, text}] — POINTERS, not bodies (`text` aliases `snippet`).",
-  "  **Start here.** Free: no sub-LLM call. Use before guessing filenames.",
+  "- `search(query: str, k=10, path_glob=None)`: BM25 ranking over `context` (stemmed, with",
+  "  query expansion — try plain words, not just exact identifiers). Returns",
+  "  [{path, line, end, score, snippet, text}] — POINTERS, not bodies (`text` aliases",
+  "  `snippet`; line..end is the match span; `index_truncated: true` means the context tail",
+  "  is NOT indexed — narrow with path_glob). **Start here.** Free: no sub-LLM call.",
   "- `grep_context(pattern, k=50, path_glob=None, before=0, after=0) -> dict`: regex over",
   "  `context`. Returns {hits: [{path, line, text, snippet}], counts, total, truncated} —",
   "  `counts` is complete even when `hits` is capped, so a wide pattern reports its shape",
@@ -56,6 +60,15 @@ const SKILL_SEARCH_GLOSSARY_LINES: readonly string[] = Object.freeze([
   "  smells like something already learned — do not re-discover it.",
 ]);
 
+/** W3 recall discoverability: the condensed NATIVE twins. glossary doctrine — divergence
+ *  between the headless and native surfaces is a bug; `skill_search` had no native twin, so
+ *  native models could not discover cross-session recall at all (and the archive line
+ *  teaches the ctx/session-log recall that honest elision stubs point at). */
+export const SKILL_SEARCH_LINE_NATIVE =
+  "- `skill_search(query, k=8) -> [{id, text, tags, score}]` — BM25 over distilled project facts from PRIOR sessions. Free; use before re-discovering a learned config/gotcha/symbol.";
+export const ARCHIVE_RECALL_LINE_NATIVE =
+  `- Elided chat turns are archived in the sandbox: \`search("<keywords>", path_glob="${ARCHIVE_NAMESPACE}*")\` / \`grep_context()\` recall text that scrolled out of your context — free, no sub-LLM call.`;
+
 /** Single source of wording for the injected SkillState block (headless + native, Workstream C).
  *  Takes the dynamic body as an argument — the glossary itself stays static-only. */
 /** One wording source for the skill_search recall hint (Ξ block + root Σ snapshot). */
@@ -64,10 +77,21 @@ export const SKILL_RECALL_LINE =
 
 /** R5 (G4, /tmp/ROOT_FULL_SKILLSTATE_PLAN.md): the one-line replacement for assistant prose
  *  older than the keep window — durable facts live in Σ; the repl sandbox (answers/vars) is
- *  the model-reachable recovery channel — the session log is host-side only, never re-openable
- *  by the model, so stubs must not promise it. */
+ *  the model-reachable recovery channel for repl-owned payloads. Stubs must promise only a
+ *  channel that actually holds the bytes (recall W1): repl-owned payloads → the repl line,
+ *  native payloads → the archive line (searchable `ctx/session-log/`), else the plain line. */
 export const ROOT_TURN_ELIDED_LINE =
   "… turn elided — durable facts live in Σ; your repl sandbox persists: print(answers) / SHOW_VARS() to re-derive";
+export const ROOT_TURN_ELIDED_ARCHIVE_LINE =
+  `… turn elided — durable facts live in Σ; the full text is archived in the sandbox: ` +
+  `search('<keywords>', path_glob='${ARCHIVE_NAMESPACE}*') or grep_context() recalls it`;
+export const ROOT_TURN_ELIDED_PLAIN_LINE =
+  "… turn elided — durable facts live in Σ";
+/** Preview mark twin: payloads kept as head+tail previews point at the same archive. */
+export const ROOT_ELIDE_PREVIEW_MARK =
+  `chars elided — full text archived under ${ARCHIVE_NAMESPACE} (search/grep_context it)`;
+export const ROOT_ELIDE_PREVIEW_MARK_REPL =
+  "chars elided — repl sandbox persists: print(answers[k]) or re-run repl to re-derive";
 
 export function skillStateLines(noteCount: number, body: string): string {
   return [
@@ -343,6 +367,9 @@ export function replGlossary(
   lines.push(
     "- `llm_query(prompt: str) -> Task`: spawn one sub-LLM (await_task for str). The prompt must",
     "  **contain the text** to analyze — this call has no filesystem and no `context`.",
+    "  Leaf convention: a sub-LLM answers exactly `NOT_FOUND` when its slice lacks the answer —",
+    "  treat that as \"not in this slice\": slice differently, search elsewhere, or narrow the ask.",
+    "  Never re-send an identical prompt hoping for a different verdict.",
     "- `llm_batch(prompts: list[str]) -> Task`: many parallel one-shots (same rule: embed text).",
     "  await_task → ordered list[str]. NEVER pass bare file paths as if the worker can open them.",
     ...CHUNKED_GLOSSARY_LINES,
@@ -395,6 +422,8 @@ export function replGlossary(
     '- `answer`: a dict initialized to {"content": "", "ready": False}. To submit your final answer,',
     '  set `answer["content"]` to the answer text and `answer["ready"] = True`.',
     '  **You MUST flip `answer["ready"] = True` — runs that never finalize are discarded.**',
+    '  Never write FINAL(...) / FINAL_VAR(...) prose and never emit a ```state fence in the',
+    '  reply that finalizes — `answer` is the only finalize channel; Σ bookkeeping waits.',
   );
   return lines.join("\n");
 }

package/src/prompts/native.ts

@@ -6,11 +6,13 @@
  */
 
 import {
+  ARCHIVE_RECALL_LINE_NATIVE,
   CHUNKED_GLOSSARY_LINE_NATIVE,
   ENV_TIPS_CONDENSED,
   LARGE_FILE_RULE_NATIVE,
   DEFAULT_PROMPT_CAP,
   promptCapTokensK,
+  SKILL_SEARCH_LINE_NATIVE,
 } from "./glossary.ts";
 import { STATE_FENCE_INSTRUCTION } from "../core/run-state.ts";
 
@@ -25,6 +27,7 @@ function nativeReplGlossary(): string {
     "- `search(query, k=10, path_glob=None) -> [{path, line, score, snippet, text}]` — BM25 pointers, not bodies",
     "- `grep_context(pattern, k=50, …) -> {hits, counts, total, truncated}` — regex / lexical needles",
     "- `outline(path) -> str` — definition skeleton (~200 chars)",
+    ARCHIVE_RECALL_LINE_NATIVE,
     "",
     "### Always-spawn fan-out (return Task + run ↯bg — NEVER the answer)",
     "| Call | await_task → | When | NOT for |",
@@ -47,6 +50,7 @@ function nativeReplGlossary(): string {
     "- `answers` / `plan` — persistent dicts for **collected** results. Task handles are REPL vars (`t`), not `answers` keys.",
     "- `add_context(source) -> dict` — append external dir/file/doc/git under `ctx/<id>/…` (metadata only).",
     "- `list_claims()` — the live `[ledger]` table of agent work.",
+    SKILL_SEARCH_LINE_NATIVE,
     "- `SHOW_VARS()` — list REPL vars (Tasks as `<Task …>`). `list_tasks()` finds Task handles. `answer[\"ready\"]=True` only for headless finalize (native: write a normal message).",
     "",
     ENV_TIPS_CONDENSED,
@@ -189,8 +193,10 @@ export function buildNativeSystemPrompt(opts?: { readonly stateFences?: boolean
   ].join("\n");
 }
 
-/** Soft cap on the static native prompt. Raised for v5-style contract/routing/examples. */
-export const NATIVE_PROMPT_BUDGET = 9_500;
+/** Soft cap on the static native prompt. Raised for v5-style contract/routing/examples;
+ *  recall W3 raised it again (+200) for the archive-recall + skill_search twin lines —
+ *  the model cannot recall elided turns or prior-session facts it is never told about. */
+export const NATIVE_PROMPT_BUDGET = 9_700;
 
 /** Exported for tests — prompt length without context metadata (which is injected separately). */
 export const NATIVE_PROMPT_STATIC = buildNativeSystemPrompt();

package/src/prompts/user.ts

@@ -26,6 +26,7 @@ export function buildTurnPrompt(
 export const FINALIZE_PROMPT =
   "You are out of turns. Finalize NOW: set `answer[\"content\"]` and `answer[\"ready\"] = True` " +
     "(fenced ```repl```) with your best final answer from everything you have gathered. " +
+    "Finalize ONLY through `answer` — no FINAL(...) prose and no ```state fence in this reply. " +
     "Only if the REPL is unavailable, answer as plain text.";
 
 /** One-shot retrieval-discipline nudge (the engine owns the when — see core/engine.ts). The
@@ -44,9 +45,9 @@ export const REASONING_BUDGET_HINT =
   "the completion budget with the answer, so long thought may be cut off mid-reasoning. " +
   "Keep thought concise, or raise rootSampling.maxTokens.";
 
-/** One-shot verification-discipline nudge (default OFF — enableVerificationNudge): fired when
- *  the root finalizes suspiciously early with a bare number / short label. The model gets ONE
- *  coached redo instead of having the answer accepted. */
+/** One-shot verification-discipline nudge (default ON — enableVerificationNudge): fired when
+ *  the root finalizes suspiciously early with a bare answer, or without having inspected its
+ *  context at all. The model gets ONE coached redo instead of having the answer accepted. */
 export const VERIFICATION_NUDGE =
   "[coach] That answer was submitted suspiciously early and looks under-verified. Before " +
   "finalizing: recompute the key quantity inside a ```repl block (show the actual computation, " +