muonroi-cli 1.4.0 → 1.4.1

package/src/orchestrator/provider-options-shape.ts

@@ -1,70 +0,0 @@
-/**
- * src/orchestrator/provider-options-shape.ts
- *
- * Helper for Phase O1 cost-leak forensics — records the SHAPE (not the
- * values) of providerOptions passed to streamText alongside each usage
- * event. Lets post-mortem answer "did this call carry store=true?" /
- * "was promptCacheKey present?" without leaking actual key material.
- *
- * Shape format: leaves are replaced with their typeof string. Example:
- *   {openai: {store: true, promptCacheKey: "abc123"}, anthropic: {thinking: {budgetTokens: 8192}}}
- * becomes:
- *   {openai: {store: "boolean", promptCacheKey: "string"}, anthropic: {thinking: {budgetTokens: "number"}}}
- *
- * Recursion is depth-capped to prevent runaway on circular refs or
- * pathological provider quirks.
- */
-
-const MAX_DEPTH = 4;
-const TRUNCATED = "<max-depth>";
-
-type ShapeLeaf = string;
-type ShapeNode = ShapeLeaf | { [key: string]: ShapeNode } | ShapeNode[];
-
-function walk(value: unknown, depth: number): ShapeNode {
-  if (depth >= MAX_DEPTH) return TRUNCATED;
-
-  if (value === null) return "null";
-  const t = typeof value;
-  if (t === "string" || t === "number" || t === "boolean" || t === "bigint" || t === "symbol" || t === "function") {
-    return t;
-  }
-  if (t === "undefined") return "undefined";
-
-  if (Array.isArray(value)) {
-    // Preserve array structure; recurse into each element.
-    return (value as unknown[]).map((v) => walk(v, depth + 1));
-  }
-
-  if (t === "object") {
-    const out: { [key: string]: ShapeNode } = {};
-    for (const key of Object.keys(value as object)) {
-      out[key] = walk((value as Record<string, unknown>)[key], depth + 1);
-    }
-    return out;
-  }
-
-  // Fallback for exotic types.
-  return t;
-}
-
-/**
- * Extract a JSON-serialisable shape of providerOptions, replacing
- * string/number/boolean leaves with their type names. Returns null for
- * null/undefined/empty inputs so the caller can store it as a NULL DB
- * column rather than `"{}"`.
- */
-export function extractProviderOptionsShape(opts: unknown): string | null {
-  if (opts === null || opts === undefined) return null;
-  if (typeof opts !== "object") return null;
-  if (Array.isArray(opts) && opts.length === 0) return null;
-  if (!Array.isArray(opts) && Object.keys(opts as object).length === 0) return null;
-
-  const shape = walk(opts, 0);
-  try {
-    return JSON.stringify(shape);
-  } catch {
-    // Defensive: should be unreachable since walk produces plain values only.
-    return null;
-  }
-}

package/src/orchestrator/read-path-budget.ts

@@ -1,205 +0,0 @@
-/**
- * src/orchestrator/read-path-budget.ts
- *
- * Phase C4 — input-keyed read budget. Complements the C3 cross-turn output-hash
- * dedup, which misses re-reads of files the agent itself just edited: file
- * content changes → output hash changes → cache miss → full re-bill.
- *
- * Caps `read_file` style tool calls at N per (toolName, normalizedPath) per
- * session. When the cap is exceeded, the wrapped execute() returns a stub
- * pointing the agent at its prior result instead of actually reading.
- *
- * Evidence: chat-export-bcf1f0951567 — client/vite.config.ts, index.html,
- * main.tsx each read 2× across edit turns; C3 missed because file bytes
- * changed between reads.
- *
- * Default cap N = 3 — generous enough that legitimate "edit → verify"
- * patterns still get a fresh read once, but tight enough to break runaway
- * re-read loops. Override via MUONROI_MAX_READS_PER_PATH; disable with 0.
- */
-import type { ToolSet } from "ai";
-
-// Matches built-in read tools + common MCP read tools (filesystem read_file,
-// read_text_file, etc). We don't include "ls" / "list_directory" because
-// those legitimately re-issue against a changing FS state.
-const READ_TOOL_PATTERN = /(^|_|__)read(_file|_text_file)?$/i;
-
-// Matches built-in write/edit tools + common MCP equivalents. These do NOT
-// get a budget cap of their own (the cumulative tool budget covers them);
-// instead a successful write/edit invalidates the read counter for the same
-// path so the agent can refresh its view of the post-write content. Without
-// this, an Edit on F.ts → agent re-reads F.ts → cap-blocked even though the
-// content changed under it (evidenced by session 1f29e238a816 where biome
-// reformatted a freshly-edited file and the next Read hit the budget cap).
-const WRITE_TOOL_PATTERN = /(^|_|__)(write_file|edit_file|create_file|notebook_edit|str_replace_editor)$/i;
-
-function isReadTool(name: string): boolean {
-  return READ_TOOL_PATTERN.test(name);
-}
-
-function isWriteTool(name: string): boolean {
-  return WRITE_TOOL_PATTERN.test(name);
-}
-
-/**
- * Extract the file path argument from a read-tool input shape. Handles the
- * common shapes: { path: "..." }, { file_path: "..." }, { filePath: "..." }.
- */
-function extractPath(input: unknown): string | null {
-  if (!input || typeof input !== "object") return null;
-  const obj = input as Record<string, unknown>;
-  const candidates = ["path", "file_path", "filePath", "filepath"];
-  for (const key of candidates) {
-    const v = obj[key];
-    if (typeof v === "string" && v.length > 0) return v;
-  }
-  return null;
-}
-
-/** Normalize a path for budget keying: lowercase + forward slashes + trim. */
-function normalizePath(p: string): string {
-  return p.trim().replace(/\\/g, "/").toLowerCase();
-}
-
-export interface ReadBudgetStats {
-  capExceededHits: number;
-  trackedPaths: number;
-  writeInvalidations: number;
-}
-
-export class ReadPathBudget {
-  private counts = new Map<string, number>();
-  private capExceededHits = 0;
-  private writeInvalidations = 0;
-  constructor(private readonly cap: number) {}
-
-  /** Returns null if under cap (caller passes through); stub string if over. */
-  public checkAndIncrement(toolName: string, path: string): string | null {
-    if (this.cap <= 0) return null;
-    const key = `${toolName}::${normalizePath(path)}`;
-    const prior = this.counts.get(key) ?? 0;
-    if (prior >= this.cap) {
-      this.capExceededHits += 1;
-      return `[read budget exceeded for ${path}: ${prior} prior reads this session; refer to your earlier result instead of re-reading. To override set MUONROI_MAX_READS_PER_PATH higher or 0 to disable.]`;
-    }
-    this.counts.set(key, prior + 1);
-    return null;
-  }
-
-  /**
-   * Reset every read counter pointing at `path` (across all toolName keys).
-   * Called after a successful write/edit so the agent can re-read the
-   * post-write content without immediately tripping the cap. Without this,
-   * external rewriters (lint-staged biome, formatters) that mutate the file
-   * between agent edits leave the read-counter "primed" and block recovery
-   * reads. Evidence: session 1f29e238a816, cost-leak-tui-helpers.ts edits
-   * → biome reformatted → next read hit cap → agent could not refresh.
-   */
-  public notifyWrite(path: string): void {
-    if (this.cap <= 0) return;
-    const normalized = normalizePath(path);
-    let removed = 0;
-    for (const key of Array.from(this.counts.keys())) {
-      // Key shape: `${toolName}::${normalizedPath}` — strip the prefix and
-      // compare the path portion. Read-tool name varies (read_file,
-      // mcp__filesystem__read_text_file, etc.) so we can't pre-compute the
-      // key.
-      const sepIdx = key.indexOf("::");
-      if (sepIdx === -1) continue;
-      const keyPath = key.slice(sepIdx + 2);
-      if (keyPath === normalized) {
-        this.counts.delete(key);
-        removed += 1;
-      }
-    }
-    if (removed > 0) this.writeInvalidations += removed;
-  }
-
-  public getStats(): ReadBudgetStats {
-    return {
-      capExceededHits: this.capExceededHits,
-      trackedPaths: this.counts.size,
-      writeInvalidations: this.writeInvalidations,
-    };
-  }
-
-  /** Test-only. */
-  public clear(): void {
-    this.counts.clear();
-    this.capExceededHits = 0;
-    this.writeInvalidations = 0;
-  }
-}
-
-export function getReadPathBudgetCap(): number {
-  const raw = process.env.MUONROI_MAX_READS_PER_PATH;
-  // Default 0 = disabled. Agent knows when it needs to re-read and should
-  // not be blocked mid-analysis by a per-path cap. Override via env to
-  // re-enable (e.g. MUONROI_MAX_READS_PER_PATH=3).
-  if (raw === undefined || raw === "") return 0;
-  const n = Number(raw);
-  if (!Number.isFinite(n) || n < 0) return 3;
-  return Math.floor(n);
-}
-
-/**
- * Wrap a ToolSet so:
- *   - read-tool execute() calls are short-circuited once a per-path cap is
- *     exceeded
- *   - write/edit-tool execute() calls invalidate the read counter for the
- *     same path AFTER a successful invocation, so the agent can refresh its
- *     view of post-write content without tripping the cap
- *
- * Tools that are neither read nor write pass through unchanged. Stub
- * matches the format the LLM already sees from cross-turn dedup so the
- * model interprets it consistently.
- */
-export function wrapToolSetWithReadBudget(tools: ToolSet, budget: ReadPathBudget | null): ToolSet {
-  if (!budget) return tools;
-  const wrapped: ToolSet = {};
-  for (const [name, tool] of Object.entries(tools)) {
-    const reading = isReadTool(name);
-    const writing = isWriteTool(name);
-    if (!reading && !writing) {
-      wrapped[name] = tool;
-      continue;
-    }
-    const t = tool as Record<string, unknown>;
-    const innerExecute = t.execute as ((input: unknown, ctx?: unknown) => unknown) | undefined;
-    if (!innerExecute) {
-      wrapped[name] = tool;
-      continue;
-    }
-    if (reading) {
-      wrapped[name] = {
-        ...(tool as object),
-        execute: async (input: unknown, ctx?: unknown) => {
-          const path = extractPath(input);
-          if (path) {
-            const stub = budget.checkAndIncrement(name, path);
-            if (stub !== null) return stub;
-          }
-          return innerExecute(input, ctx);
-        },
-      } as ToolSet[string];
-    } else {
-      wrapped[name] = {
-        ...(tool as object),
-        execute: async (input: unknown, ctx?: unknown) => {
-          const path = extractPath(input);
-          const result = await innerExecute(input, ctx);
-          // Only invalidate on apparent success — i.e. the wrapped tool did
-          // not throw. We can't easily inspect the result shape (tools return
-          // formatted strings here, not structured objects) so we trust that
-          // a non-throwing call wrote something. False positives are cheap
-          // (a free re-read), false negatives are not (the bug we're fixing).
-          if (path) budget.notifyWrite(path);
-          return result;
-        },
-      } as ToolSet[string];
-    }
-  }
-  return wrapped;
-}
-
-export const _internals = { isReadTool, isWriteTool, extractPath, normalizePath };

package/src/orchestrator/reasoning.test.ts

@@ -1,114 +0,0 @@
-import type { ModelMessage } from "ai";
-import { describe, expect, it } from "vitest";
-import { containsEncryptedReasoning, sanitizeModelMessages } from "./reasoning";
-
-describe("reasoning helpers", () => {
-  it("detects encrypted reasoning markers", () => {
-    expect(containsEncryptedReasoning("-----BEGIN PGP MESSAGE-----\nabc")).toBe(true);
-    expect(containsEncryptedReasoning("normal reasoning text")).toBe(false);
-  });
-
-  it("removes encrypted reasoning from assistant messages", () => {
-    const messages = [
-      {
-        role: "assistant",
-        content: [
-          { type: "reasoning", text: "-----BEGIN PGP MESSAGE-----\nabc" },
-          { type: "text", text: "Final answer" },
-        ],
-      },
-    ] as ModelMessage[];
-
-    expect(sanitizeModelMessages(messages)).toEqual([
-      {
-        role: "assistant",
-        content: [{ type: "text", text: "Final answer" }],
-      },
-    ]);
-  });
-
-  // Session 7dcf8fd7d6a4 regression: 57/100 assistant messages contained
-  // inter-tool narration like "Let me check..." → "Now let me look at...". The
-  // PIL L6 text-based ban is ignored by budget models, so strip structurally.
-  describe("inter-tool narration stripping", () => {
-    it("drops 'Let me X' text when followed by a tool-call in the same message", () => {
-      const messages = [
-        {
-          role: "assistant",
-          content: [
-            { type: "text", text: "Let me check the current GitHub Actions status." },
-            { type: "tool-call", toolCallId: "c1", toolName: "bash", input: { command: "gh run list" } },
-          ],
-        },
-      ] as ModelMessage[];
-
-      const result = sanitizeModelMessages(messages);
-      expect(result[0]?.content).toEqual([
-        { type: "tool-call", toolCallId: "c1", toolName: "bash", input: { command: "gh run list" } },
-      ]);
-    });
-
-    it("drops Vietnamese narration 'Tiếp theo tôi sẽ...' before tool-call", () => {
-      const messages = [
-        {
-          role: "assistant",
-          content: [
-            { type: "text", text: "Tiếp theo tôi sẽ kiểm tra log." },
-            { type: "tool-call", toolCallId: "c2", toolName: "read_file", input: { path: "x" } },
-          ],
-        },
-      ] as ModelMessage[];
-
-      const result = sanitizeModelMessages(messages);
-      expect((result[0]?.content as unknown[]).length).toBe(1);
-    });
-
-    it("KEEPS final-answer text when there is no tool-call in the same message", () => {
-      const messages = [
-        {
-          role: "assistant",
-          content: [{ type: "text", text: "Let me explain — actually this IS my final answer." }],
-        },
-      ] as ModelMessage[];
-
-      const result = sanitizeModelMessages(messages);
-      expect(result).toEqual(messages); // unchanged
-    });
-
-    it("KEEPS non-narration text even when followed by a tool-call", () => {
-      // E.g. agent quoted a finding before drilling deeper. We don't want to
-      // strip substantive commentary — only the narration boilerplate.
-      const messages = [
-        {
-          role: "assistant",
-          content: [
-            { type: "text", text: "Failure is in cost-leak-b3-tui.spec.ts line 47." },
-            { type: "tool-call", toolCallId: "c3", toolName: "read_file", input: { path: "spec" } },
-          ],
-        },
-      ] as ModelMessage[];
-
-      const result = sanitizeModelMessages(messages);
-      expect(result).toEqual(messages); // text was substantive, kept
-    });
-
-    it("strips multiple narration text parts but keeps tool-calls intact", () => {
-      const messages = [
-        {
-          role: "assistant",
-          content: [
-            { type: "text", text: "Let me check the status." },
-            { type: "tool-call", toolCallId: "c4", toolName: "bash", input: { command: "ls" } },
-            { type: "text", text: "Now let me read the file." },
-            { type: "tool-call", toolCallId: "c5", toolName: "read_file", input: { path: "x" } },
-          ],
-        },
-      ] as ModelMessage[];
-
-      const result = sanitizeModelMessages(messages);
-      const content = result[0]?.content as Array<{ type: string }>;
-      expect(content.every((p) => p.type === "tool-call")).toBe(true);
-      expect(content.length).toBe(2);
-    });
-  });
-});

package/src/orchestrator/reasoning.ts

@@ -1,116 +0,0 @@
-import type { ModelMessage } from "ai";
-
-const ENCRYPTED_REASONING_MARKERS = [
-  "-----BEGIN PGP MESSAGE-----",
-  "-----BEGIN PGP ARMORED FILE-----",
-  "-----BEGIN AGE ENCRYPTED FILE-----",
-  "encrypted_content",
-] as const;
-
-// Inter-tool narration patterns banned by PIL Layer 6 NO_PREAMBLE_RULE.
-// Budget models (DeepSeek-V4-Flash, Qwen, Llama) routinely ignore text-based
-// instructions and emit "Let me check..." / "Now let me look at..." between
-// every tool call — session 7dcf8fd7d6a4 had 57/100 assistant messages doing
-// this despite the prompt ban. Structural stripping is the only reliable fix.
-// Match starts at the beginning of a text part (after trim) so legitimate
-// final answers that happen to contain "Let me" mid-sentence stay intact.
-// Boundary uses an explicit char class instead of \b because Vietnamese
-// diacritics (ẽ, ế, ị, …) are not part of ECMAScript's default \w, so \b after
-// "sẽ" wouldn't match.
-const NARRATION_PREFIX_REGEX =
-  /^\s*(?:Let me|Let's|Now let me|Now I'll|Now I will|I'll|I will|First, let me|Next, I'll|Next, let me|Here's what I'll|Tiếp theo (?:tôi sẽ|là)|Bây giờ (?:tôi (?:sẽ|cần|phải)|là)|Để tôi|Tôi sẽ|That was|That's the|This is the|Looking at|Checking|Examining)(?=[\s.,;!?]|$)/i;
-
-type AssistantMessage = Extract<ModelMessage, { role: "assistant" }>;
-type AssistantContent = AssistantMessage["content"];
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-function getReasoningText(part: unknown): string | null {
-  if (!isRecord(part) || part.type !== "reasoning") return null;
-  if (typeof part.text === "string") return part.text;
-  if (typeof part.reasoning === "string") return part.reasoning;
-  return null;
-}
-
-export function containsEncryptedReasoning(text: string): boolean {
-  const lower = text.toLowerCase();
-  return ENCRYPTED_REASONING_MARKERS.some((marker) => lower.includes(marker.toLowerCase()));
-}
-
-/**
- * Strip inter-tool narration. When an assistant message has BOTH text and
- * tool-call parts, the text is by definition between-tool narration (the
- * "final answer" would not be followed by another tool call). Drop text parts
- * whose content matches a narration prefix.
- *
- * Pure final-answer text (text-only message, no tool-call after) is left alone
- * — that's the legitimate user-visible response.
- *
- * Tied to PIL L6 NO_PREAMBLE_RULE — see comment on NARRATION_PREFIX_REGEX.
- */
-function stripInterToolNarration(content: AssistantContent): AssistantContent {
-  if (!Array.isArray(content)) return content;
-  // Treat parts as loose records — the AI SDK assistant content union is
-  // discriminated and TS narrows away the "tool-call"/"text" tags after the
-  // isRecord guard. We only need to inspect type+text shape; structural cast
-  // keeps the logic readable without weakening the public AssistantContent type.
-  const parts = content as unknown as Array<Record<string, unknown>>;
-  const hasToolCall = parts.some((part) => isRecord(part) && part.type === "tool-call");
-  if (!hasToolCall) return content;
-
-  const stripped = parts.filter((part) => {
-    if (!isRecord(part) || part.type !== "text") return true;
-    const text = typeof part.text === "string" ? part.text : "";
-    return !NARRATION_PREFIX_REGEX.test(text);
-  });
-
-  return stripped.length === content.length ? content : (stripped as unknown as AssistantContent);
-}
-
-function sanitizeAssistantContent(content: AssistantContent): AssistantContent {
-  if (!Array.isArray(content)) return content;
-
-  const filtered = content.filter((part) => {
-    const reasoningText = getReasoningText(part);
-    return !reasoningText || !containsEncryptedReasoning(reasoningText);
-  });
-
-  const reasoningSanitized: AssistantContent =
-    filtered.length === content.length ? content : (filtered as typeof content);
-
-  return stripInterToolNarration(reasoningSanitized);
-}
-
-export function sanitizeModelMessages(messages: ModelMessage[]): ModelMessage[] {
-  let changed = false;
-  const sanitized: ModelMessage[] = [];
-
-  for (const message of messages) {
-    if (message.role !== "assistant") {
-      sanitized.push(message);
-      continue;
-    }
-
-    const content = sanitizeAssistantContent(message.content);
-    if (content !== message.content) {
-      changed = true;
-    }
-
-    if (Array.isArray(content) && content.length === 0) {
-      changed = true;
-      continue;
-    }
-
-    if (typeof content === "string" && !content.trim()) {
-      changed = true;
-      continue;
-    }
-
-    const nextMessage: ModelMessage = content === message.content ? message : { ...message, content };
-    sanitized.push(nextMessage);
-  }
-
-  return changed ? sanitized : messages;
-}

package/src/orchestrator/repair-tool-call.ts

@@ -1,54 +0,0 @@
-/**
- * src/orchestrator/repair-tool-call.ts
- *
- * AI SDK 6 hook adapter for the conservative tool-args repair. Plugs into
- * `streamText({ repairToolCall, ... })` — AI SDK invokes the hook on
- * InvalidToolInputError BEFORE emitting tool-error, so a successful repair
- * lets the tool execute normally instead of bubbling up as a failure that
- * triggers the tool-repetition detector.
- *
- * Returns:
- *   - corrected ToolCall when repair produced valid JSON for the schema
- *   - null when repair failed; AI SDK then re-throws the original error
- *     and tool-error fires (which our repetition detector still catches)
- *
- * This is provider-agnostic by design — the malformed-JSON pattern has been
- * observed on Qwen3-30B-Instruct via SiliconFlow but the SAME repair would
- * apply to any model whose tokenization breaks structured JSON. No
- * `if (providerId === ...)` branching: the repair function decides locally
- * whether each transform applies based on the input string alone.
- */
-
-import type { LanguageModelV3ToolCall } from "@ai-sdk/provider";
-import { repairToolCallArgs } from "./tool-args-repair.js";
-
-/**
- * AI SDK invokes this on InvalidToolInputError before tool-error fires.
- * Returns a corrected LanguageModelV3ToolCall (with input as the stringified
- * repaired JSON) or null to fall through to the existing error path.
- *
- * Only `toolCall` is consumed — other args (tools, inputSchema, system,
- * messages, error) are accepted to match AI SDK's signature but ignored.
- */
-export async function repairToolCallHook(args: {
-  toolCall: LanguageModelV3ToolCall;
-}): Promise<LanguageModelV3ToolCall | null> {
-  const original = args.toolCall;
-  const rawInput = original.input;
-  if (typeof rawInput !== "string" || rawInput.length === 0) return null;
-
-  const result = repairToolCallArgs(rawInput);
-  if (!result.ok) return null;
-
-  let repairedInput: string;
-  try {
-    repairedInput = JSON.stringify(result.value);
-  } catch {
-    return null;
-  }
-
-  return {
-    ...original,
-    input: repairedInput,
-  };
-}

package/src/orchestrator/repetition-detector.test.ts

@@ -1,127 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import {
-  _internals,
-  _resetForTests,
-  buildRepetitionReminder,
-  extractLeadingPhrase,
-  recordAssistantBurst,
-  shouldInjectRepetitionReminder,
-} from "./repetition-detector.js";
-
-describe("extractLeadingPhrase", () => {
-  it("returns lowercased first N words stripped of punctuation", () => {
-    expect(extractLeadingPhrase("YES still on scope. Commit pushed.")).toBe("yes still on scope");
-  });
-
-  it("returns null when fewer than N words", () => {
-    expect(extractLeadingPhrase("hi there")).toBeNull();
-    expect(extractLeadingPhrase("")).toBeNull();
-    expect(extractLeadingPhrase(null)).toBeNull();
-    expect(extractLeadingPhrase(undefined)).toBeNull();
-  });
-
-  it("strips code fences before counting words", () => {
-    const text = "```ts\nconst x = 1;\nconst y = 2;\nconst z = 3;\n```\nYES still on scope here we go";
-    expect(extractLeadingPhrase(text)).toBe("yes still on scope");
-  });
-
-  it("handles Vietnamese accents", () => {
-    expect(extractLeadingPhrase("Tiếp tục theo dõi CI rồi")).toBe("tiếp tục theo dõi");
-  });
-});
-
-describe("recordAssistantBurst + shouldInjectRepetitionReminder", () => {
-  beforeEach(() => _resetForTests());
-  afterEach(() => _resetForTests());
-
-  it("counts consecutive bursts that share the same opening phrase", () => {
-    expect(recordAssistantBurst("s1", "YES still on scope. Doing X.")).toBe(1);
-    expect(recordAssistantBurst("s1", "YES still on scope. Doing Y.")).toBe(2);
-    expect(recordAssistantBurst("s1", "YES still on scope. Doing Z.")).toBe(3);
-  });
-
-  it("resets the run when the opening phrase changes", () => {
-    recordAssistantBurst("s1", "YES still on scope. A");
-    recordAssistantBurst("s1", "YES still on scope. B");
-    expect(recordAssistantBurst("s1", "Switching approach now to a totally different plan")).toBe(1);
-  });
-
-  it("preserves the run when an interleaved burst has no phrase (tool-only step)", () => {
-    recordAssistantBurst("s1", "YES still on scope. First call");
-    recordAssistantBurst("s1", "YES still on scope. Second call");
-    // Non-text burst — counter should not reset.
-    expect(recordAssistantBurst("s1", "")).toBe(2);
-    expect(recordAssistantBurst("s1", "YES still on scope. Third call")).toBe(3);
-  });
-
-  it("isolates state per session", () => {
-    recordAssistantBurst("a", "YES still on scope. one");
-    recordAssistantBurst("a", "YES still on scope. two");
-    recordAssistantBurst("b", "Totally different opening phrase here");
-    expect(recordAssistantBurst("a", "YES still on scope. three")).toBe(3);
-    expect(recordAssistantBurst("b", "Totally different opening phrase here")).toBe(2);
-  });
-
-  it("returns 1 for null/empty sessionId", () => {
-    expect(recordAssistantBurst(null, "YES still on scope. x")).toBe(1);
-    expect(recordAssistantBurst("", "YES still on scope. x")).toBe(1);
-    expect(recordAssistantBurst(undefined, "YES still on scope. x")).toBe(1);
-  });
-
-  it("trigger fires once at runLength >= TRIGGER_RUN_LENGTH", () => {
-    recordAssistantBurst("s1", "YES still on scope. one");
-    recordAssistantBurst("s1", "YES still on scope. two");
-    expect(shouldInjectRepetitionReminder("s1")).toBe(false);
-    recordAssistantBurst("s1", "YES still on scope. three");
-    expect(shouldInjectRepetitionReminder("s1")).toBe(true);
-  });
-
-  it("trigger does not re-fire while the run continues", () => {
-    recordAssistantBurst("s1", "YES still on scope. one");
-    recordAssistantBurst("s1", "YES still on scope. two");
-    recordAssistantBurst("s1", "YES still on scope. three");
-    expect(shouldInjectRepetitionReminder("s1")).toBe(true);
-    recordAssistantBurst("s1", "YES still on scope. four");
-    expect(shouldInjectRepetitionReminder("s1")).toBe(false);
-    recordAssistantBurst("s1", "YES still on scope. five");
-    expect(shouldInjectRepetitionReminder("s1")).toBe(false);
-  });
-
-  it("trigger re-arms when a new run begins", () => {
-    recordAssistantBurst("s1", "YES still on scope. one");
-    recordAssistantBurst("s1", "YES still on scope. two");
-    recordAssistantBurst("s1", "YES still on scope. three");
-    shouldInjectRepetitionReminder("s1"); // mark fired
-
-    // New phrase — counter resets, fire flag clears.
-    recordAssistantBurst("s1", "Switching approach now to a totally different plan");
-    recordAssistantBurst("s1", "Switching approach now to step two");
-    recordAssistantBurst("s1", "Switching approach now to step three");
-    expect(shouldInjectRepetitionReminder("s1")).toBe(true);
-  });
-
-  it("trigger no-op for unknown / null session", () => {
-    expect(shouldInjectRepetitionReminder(null)).toBe(false);
-    expect(shouldInjectRepetitionReminder("never-recorded")).toBe(false);
-  });
-});
-
-describe("buildRepetitionReminder", () => {
-  beforeEach(() => _resetForTests());
-  afterEach(() => _resetForTests());
-
-  it("includes the perseveration phrase and runLength", () => {
-    recordAssistantBurst("s1", "YES still on scope. one");
-    recordAssistantBurst("s1", "YES still on scope. two");
-    recordAssistantBurst("s1", "YES still on scope. three");
-    const msg = buildRepetitionReminder("s1");
-    expect(msg).toContain("self-repetition detected");
-    expect(msg).toContain("yes still on scope");
-    expect(msg).toContain("3");
-  });
-
-  it("constants are stable for callers", () => {
-    expect(_internals.PHRASE_WORD_COUNT).toBe(4);
-    expect(_internals.TRIGGER_RUN_LENGTH).toBe(3);
-  });
-});