muonroi-cli 1.4.0 → 1.4.1

package/src/ee/judge.ts

@@ -1,126 +0,0 @@
-/**
- * src/ee/judge.ts
- *
- * Deterministic auto-judge classifier (EE-09).
- * Classifies every tool call as FOLLOWED | IGNORED | IRRELEVANT using
- * deterministic rules — no LLM involved.
- *
- * fireFeedback() fires /api/feedback fire-and-forget per match, and
- * /api/principle/touch on FOLLOWED matches (EE-10 decay refresh).
- */
-
-import { getDefaultEEClient } from "./intercept.js";
-import type { Classification, InterceptResponse, PostToolPayload } from "./types.js";
-
-export interface JudgeContext {
-  warningResponse: InterceptResponse | null;
-  toolName: string;
-  outcome: PostToolPayload["outcome"];
-  cwdMatchedAtPretool: boolean;
-  diffPresent: boolean;
-  tenantId: string;
-}
-
-/**
- * Noise threshold: matches below this confidence are treated as noise
- * and should not strengthen the principle via FOLLOWED classification.
- */
-export const NOISE_CONFIDENCE_THRESHOLD = 0.3;
-
-/**
- * Deterministic classification rules (from RESEARCH Auto-Judge Deterministic Rules):
- *
- * 1. No matches or cwd mismatch → IRRELEVANT
- * 2. Outcome failed → IGNORED
- * 3. Any match has expectedBehavior='should-not-edit' AND diff present → IGNORED
- * 4. All matches below noise threshold → IRRELEVANT (prevents noise reinforcement)
- * 5. Otherwise → FOLLOWED
- */
-export function judge(ctx: JudgeContext): Classification {
-  if (!ctx.warningResponse?.matches?.length || !ctx.cwdMatchedAtPretool) {
-    return "IRRELEVANT";
-  }
-  if (!ctx.outcome.success) {
-    return "IGNORED";
-  }
-  if (ctx.warningResponse.matches.some((m) => m.expectedBehavior === "should-not-edit" && ctx.diffPresent)) {
-    return "IGNORED";
-  }
-  if (ctx.warningResponse.matches.every((m) => m.confidence < NOISE_CONFIDENCE_THRESHOLD)) {
-    return "IRRELEVANT";
-  }
-  return "FOLLOWED";
-}
-
-/**
- * Fire feedback for each match in the warning response.
- * - Always calls /api/feedback per match (fire-and-forget).
- * - On FOLLOWED, also calls /api/principle/touch per match (EE-10 decay refresh).
- *
- * B-4 invariant: returns void synchronously. All HTTP calls are fire-and-forget.
- */
-export function fireFeedback(ctx: JudgeContext): void {
-  const cls = judge(ctx);
-  const matches = ctx.warningResponse?.matches ?? [];
-  const client = getDefaultEEClient();
-  for (const m of matches) {
-    client.feedback({
-      principle_uuid: m.principle_uuid,
-      classification: cls,
-      tool_name: ctx.toolName,
-      duration_ms: ctx.outcome.durationMs ?? 0,
-      tenantId: ctx.tenantId,
-    });
-    if (cls === "FOLLOWED") {
-      client.touch(m.principle_uuid, ctx.tenantId);
-    }
-  }
-}
-
-export interface CouncilJudgeResult {
-  confidence: number;   // 0–1
-  verdict: "pass" | "fail" | "needs_review";
-  reason: string;
-}
-
-/**
- * Judge a council synthesis for quality using heuristic scoring.
- * No LLM involved — deterministic rules based on synthesis content.
- * confidence < 0.5 → verdict=needs_review.
- * Fire-and-forget pattern: callers use .then() not await.
- * Never throws — fail-open B-4 compliant.
- */
-export async function judgeCouncilOutcome(synthesis: string): Promise<CouncilJudgeResult> {
-  try {
-    // Heuristic scoring (deterministic � no LLM):
-    // +0.3 for synthesis length >= 200 chars (substantive)
-    // +0.2 for at least one citation pattern ([file:], [url], [REFUTED via])
-    // +0.2 for recommended action present (look for "Recommendation" or "recommend")
-    // +0.15 for convergence signal ("agreed", "consensus", "all participants")
-    // +0.15 for evidence density (>= 2 citation patterns)
-    // +0.15 for long synthesis >= 1000 chars (typical council output)
-    // +0.1 for very long synthesis >= 3000 chars
-    let score = 0.0;
-    const len = synthesis.length;
-    const lc = synthesis.toLowerCase();
-    const citationCount = (synthesis.match(/\[(?:file:|url|snapshot:|REFUTED via)/g) ?? []).length;
-
-    if (len >= 200) score += 0.3;
-    if (citationCount >= 1) score += 0.2;
-    if (lc.includes("recommend")) score += 0.2;
-    if (lc.includes("agreed") || lc.includes("consensus")) score += 0.15;
-    if (citationCount >= 2) score += 0.15;
-    if (len >= 1000) score += 0.15;
-    if (len >= 3000) score += 0.1;
-
-    const confidence = Math.min(1.0, Math.max(0.0, score));
-
-    return {
-      confidence,
-      verdict: confidence < 0.5 ? "needs_review" : "pass",
-      reason: `heuristic: len=${len} citations=${citationCount} score=${score.toFixed(2)}`,
-    };
-  } catch (err) {
-    return { confidence: 0, verdict: "needs_review", reason: `error: ${(err as Error).message}` };
-  }
-}

package/src/ee/mistake-detector.test.ts

@@ -1,252 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { _internals, MistakeDetector } from "./mistake-detector.js";
-
-describe("mistake-detector / tokenize + jaccard", () => {
-  it("tokenizes JSON tool input into normalized tokens", () => {
-    const tokens = _internals.tokenize({ file_path: "src/Foo.ts", lines: 42 });
-    expect(tokens.has("file_path")).toBe(true);
-    expect(tokens.has("src")).toBe(true);
-    expect(tokens.has("foo")).toBe(true);
-    expect(tokens.has("ts")).toBe(true);
-    expect(tokens.has("42")).toBe(true);
-  });
-
-  it("computes jaccard similarity correctly", () => {
-    const a = new Set(["a", "b", "c"]);
-    const b = new Set(["b", "c", "d"]);
-    expect(_internals.jaccardSimilarity(a, b)).toBeCloseTo(0.5, 3);
-  });
-
-  it("returns 1 when both sets are empty", () => {
-    expect(_internals.jaccardSimilarity(new Set(), new Set())).toBe(1);
-  });
-
-  it("returns 0 when one set is empty", () => {
-    expect(_internals.jaccardSimilarity(new Set(["a"]), new Set())).toBe(0);
-  });
-});
-
-describe("mistake-detector / path extraction", () => {
-  it("extracts file_path from Edit tool input", () => {
-    expect(_internals.extractFilePath("Edit", { file_path: "src/foo.ts" })).toBe("src/foo.ts");
-  });
-
-  it("extracts path from MCP edit_file tool input", () => {
-    expect(_internals.extractFilePath("mcp__filesystem__edit_file", { path: "src/foo.ts" })).toBe("src/foo.ts");
-  });
-
-  it("extracts path from lowercase write_file tool input", () => {
-    expect(_internals.extractFilePath("write_file", { path: "src/foo.ts", content: "x" })).toBe("src/foo.ts");
-  });
-
-  it("returns null for non-edit tools", () => {
-    expect(_internals.extractFilePath("Bash", { command: "ls" })).toBeNull();
-    expect(_internals.extractFilePath("Read", { file_path: "src/foo.ts" })).toBeNull();
-  });
-
-  it("normalizes Windows drive letters and backslashes", () => {
-    expect(_internals.extractFilePath("Edit", { file_path: "D:\\src\\Foo.ts" })).toBe("d:/src/Foo.ts");
-  });
-
-  it("returns null for missing/empty path", () => {
-    expect(_internals.extractFilePath("Edit", {})).toBeNull();
-    expect(_internals.extractFilePath("Edit", { file_path: "" })).toBeNull();
-  });
-});
-
-describe("mistake-detector / ring buffer", () => {
-  let det: MistakeDetector;
-  beforeEach(() => {
-    det = new MistakeDetector();
-  });
-
-  it("evicts oldest entry when ring exceeds 5", () => {
-    for (let i = 0; i < 7; i++) {
-      det.recordPreTool("Bash", { command: `echo ${i}` }, false);
-    }
-    const snap = det.snapshot();
-    expect(snap.ring.length).toBe(5);
-    const cmds = snap.ring.map((e) => (e.toolInput as { command: string }).command);
-    expect(cmds).toEqual(["echo 2", "echo 3", "echo 4", "echo 5", "echo 6"]);
-  });
-
-  it("recordPostTool marks the latest matching unfinished entry", () => {
-    det.recordPreTool("Bash", { command: "ls" }, false);
-    det.recordPreTool("Bash", { command: "pwd" }, false);
-    det.recordPostTool("Bash", true);
-    const snap = det.snapshot();
-    expect(snap.ring[0]!.success).toBeUndefined();
-    expect(snap.ring[1]!.success).toBe(true);
-  });
-});
-
-describe("mistake-detector / retry-pattern", () => {
-  let det: MistakeDetector;
-  beforeEach(() => {
-    det = new MistakeDetector();
-  });
-
-  it("detects fail→success on similar args within lookback window", () => {
-    det.recordPreTool("Edit", { file_path: "src/foo.ts", old_string: "a", new_string: "b" }, false);
-    det.recordPostTool("Edit", false);
-    det.recordPreTool("Edit", { file_path: "src/foo.ts", old_string: "a", new_string: "b" }, false);
-    det.recordPostTool("Edit", true);
-    const m = det.detectRetryPattern();
-    expect(m).not.toBeNull();
-    expect(m!.kind).toBe("retry-pattern");
-    expect(m!.toolName).toBe("Edit");
-    expect((m!.evidence.similarity as number) >= 0.7).toBe(true);
-  });
-
-  it("ignores when first attempt also succeeded (legitimate parallel calls)", () => {
-    det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-    det.recordPostTool("Edit", true);
-    det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-    det.recordPostTool("Edit", true);
-    expect(det.detectRetryPattern()).toBeNull();
-  });
-
-  it("ignores when current attempt failed", () => {
-    det.recordPreTool("Bash", { command: "npm test" }, false);
-    det.recordPostTool("Bash", false);
-    det.recordPreTool("Bash", { command: "npm test" }, false);
-    det.recordPostTool("Bash", false);
-    expect(det.detectRetryPattern()).toBeNull();
-  });
-
-  it("ignores when toolInputs are dissimilar", () => {
-    det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-    det.recordPostTool("Edit", false);
-    det.recordPreTool("Edit", { file_path: "src/totally/different/bar.ts" }, false);
-    det.recordPostTool("Edit", true);
-    expect(det.detectRetryPattern()).toBeNull();
-  });
-
-  it("only looks back 3 turns", () => {
-    det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-    det.recordPostTool("Edit", false);
-    for (let i = 0; i < 4; i++) {
-      det.recordPreTool("Bash", { command: `echo ${i}` }, false);
-      det.recordPostTool("Bash", true);
-    }
-    det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-    det.recordPostTool("Edit", true);
-    expect(det.detectRetryPattern()).toBeNull();
-  });
-});
-
-describe("mistake-detector / file-revert", () => {
-  let det: MistakeDetector;
-  beforeEach(() => {
-    det = new MistakeDetector();
-  });
-
-  it("fires when current edit targets a prior-batch file that had warnings", () => {
-    // Prior batch: agent edits foo.ts with a warning surfaced.
-    det.recordPreTool("Edit", { file_path: "src/foo.ts", old_string: "a", new_string: "b" }, true);
-    det.recordPostTool("Edit", true);
-    // Turn boundary.
-    det.resetBatch();
-    // New turn: re-edit on same file → revert detected.
-    const events = det.detectFileRevert("Edit", { file_path: "src/foo.ts", old_string: "b", new_string: "c" });
-    expect(events.length).toBe(1);
-    expect(events[0]!.kind).toBe("user-veto");
-    expect(events[0]!.evidence.signal).toBe("file-revert");
-    expect(events[0]!.evidence.filePath).toBe("src/foo.ts");
-  });
-
-  it("emits one event per matching prior-batch entry on the same file", () => {
-    det.recordPreTool("Edit", { file_path: "src/foo.ts" }, true);
-    det.recordPostTool("Edit", true);
-    det.recordPreTool("Edit", { file_path: "src/foo.ts" }, true);
-    det.recordPostTool("Edit", true);
-    det.resetBatch();
-    const events = det.detectFileRevert("Edit", { file_path: "src/foo.ts" });
-    expect(events.length).toBe(2);
-  });
-
-  it("skips when prior-batch entry on the same file had no warnings", () => {
-    det.recordPreTool("Edit", { file_path: "src/foo.ts" }, false);
-    det.recordPostTool("Edit", true);
-    det.resetBatch();
-    expect(det.detectFileRevert("Edit", { file_path: "src/foo.ts" }).length).toBe(0);
-  });
-
-  it("skips when current edit is on a different file", () => {
-    det.recordPreTool("Edit", { file_path: "src/foo.ts" }, true);
-    det.recordPostTool("Edit", true);
-    det.resetBatch();
-    expect(det.detectFileRevert("Edit", { file_path: "src/bar.ts" }).length).toBe(0);
-  });
-
-  it("matches across different edit tool variants on the same file", () => {
-    // Prior batch wrote with Write; current batch edits with mcp edit_file.
-    det.recordPreTool("Write", { file_path: "src/foo.ts", content: "x" }, true);
-    det.recordPostTool("Write", true);
-    det.resetBatch();
-    const events = det.detectFileRevert("mcp__filesystem__edit_file", { path: "src/foo.ts" });
-    expect(events.length).toBe(1);
-    expect(events[0]!.evidence.nextEditTool).toBe("mcp__filesystem__edit_file");
-  });
-
-  it("does not fire on the same-turn re-edit (only across turn boundary)", () => {
-    det.recordPreTool("Edit", { file_path: "src/foo.ts" }, true);
-    det.recordPostTool("Edit", true);
-    // No resetBatch() — still same turn.
-    expect(det.detectFileRevert("Edit", { file_path: "src/foo.ts" }).length).toBe(0);
-  });
-
-  it("does not fire on non-edit tools (e.g. Read of the same file)", () => {
-    det.recordPreTool("Edit", { file_path: "src/foo.ts" }, true);
-    det.recordPostTool("Edit", true);
-    det.resetBatch();
-    expect(det.detectFileRevert("Read", { file_path: "src/foo.ts" }).length).toBe(0);
-  });
-});
-
-describe("mistake-detector / abort", () => {
-  let det: MistakeDetector;
-  beforeEach(() => {
-    det = new MistakeDetector();
-  });
-
-  it("emits one event per current-batch tool that had warnings", () => {
-    det.recordPreTool("Edit", { file_path: "a.ts" }, true);
-    det.recordPostTool("Edit", true);
-    det.recordPreTool("Edit", { file_path: "b.ts" }, true);
-    det.recordPostTool("Edit", true);
-    const events = det.detectAbort("user-pressed-esc");
-    expect(events.length).toBe(2);
-    expect(events.every((e) => e.kind === "user-veto")).toBe(true);
-    expect(events[0]!.evidence.signal).toBe("abort");
-    expect(events[0]!.evidence.reason).toBe("user-pressed-esc");
-  });
-
-  it("skips tools without warnings (avoid noise on unrelated abort)", () => {
-    det.recordPreTool("Bash", { command: "git status" }, false);
-    det.recordPostTool("Bash", true);
-    expect(det.detectAbort().length).toBe(0);
-  });
-
-  it("only fires for current batch — resetBatch clears", () => {
-    det.recordPreTool("Edit", { file_path: "a.ts" }, true);
-    det.recordPostTool("Edit", true);
-    det.resetBatch();
-    expect(det.detectAbort().length).toBe(0);
-  });
-});
-
-describe("mistake-detector / resetBatch", () => {
-  it("captures prior batch and clears current", () => {
-    const det = new MistakeDetector();
-    det.recordPreTool("Edit", { file_path: "a.ts" }, true);
-    det.recordPostTool("Edit", true);
-    det.resetBatch();
-    const snap = det.snapshot();
-    expect(snap.batch.length).toBe(0);
-    expect(snap.priorBatch.length).toBe(1);
-    expect(snap.priorBatch[0]!.toolName).toBe("Edit");
-    // Ring still preserved.
-    expect(snap.ring.length).toBe(1);
-  });
-});

package/src/ee/mistake-detector.ts

@@ -1,297 +0,0 @@
-/**
- * src/ee/mistake-detector.ts
- *
- * P0 native observation — detect agent mistakes from observable BEHAVIOR
- * (NOT lexical patterns or agent self-report). Emits posttool payloads with
- * `outcome.mistakeKind` and structured `evidence` so the brain only learns
- * from unfakeable signals.
- *
- * Three detectors:
- *
- *   1. file-revert  — user-driven turn re-edits a file the agent just edited
- *                     in the prior batch (with warnings). Strong signal that
- *                     the agent's edit was rejected — language-agnostic.
- *
- *   2. abort        — user interrupted the agent mid-batch (AbortSignal)
- *                     while warnings were active. Strong signal that the
- *                     in-flight work was unwanted.
- *
- *   3. retry-pattern — same toolName + similar toolInput within last 3 turns,
- *                     where the first attempt failed and the second succeeded.
- *                     Signals "warning should have fired earlier".
- *
- * No regex over user prose. No language packs. All signals come from the
- * agent's tool stream and the runtime's own abort plumbing.
- */
-
-import type { MistakeKind } from "./types.js";
-
-const RING_SIZE = 5;
-const RETRY_LOOKBACK_TURNS = 3;
-const RETRY_SIMILARITY_THRESHOLD = 0.7;
-
-/** Tool names that mutate file contents. Includes built-ins + MCP variants + lowercase. */
-const EDIT_TOOL_NAMES = new Set([
-  "Edit",
-  "Write",
-  "MultiEdit",
-  "edit",
-  "write",
-  "edit_file",
-  "write_file",
-  "mcp__filesystem__write_file",
-  "mcp__filesystem__edit_file",
-  "NotebookEdit",
-]);
-
-export interface RingEntry {
-  toolName: string;
-  toolInput: unknown;
-  timestamp: number;
-  success?: boolean;
-  hadWarnings: boolean;
-  /** Cached JSON token set for cheap similarity comparison. */
-  tokens: Set<string>;
-  /** Resolved file path for edit-class tools (null otherwise). */
-  filePath: string | null;
-}
-
-export interface MistakeEvent {
-  kind: MistakeKind;
-  toolName: string;
-  toolInput: unknown;
-  evidence: Record<string, unknown>;
-}
-
-/**
- * Tool-call ring buffer + batch tracking. Per-process singleton owned by the
- * hook layer.
- */
-export class MistakeDetector {
-  private buffer: RingEntry[] = [];
-  /** Tools that fired in the most recent contiguous batch — reset on each user turn. */
-  private currentBatch: RingEntry[] = [];
-  /** Snapshot of the previous batch (captured by resetBatch). Used by detectFileRevert. */
-  private priorBatch: RingEntry[] = [];
-
-  /** Append a tool call (called from PreToolUse path with hadWarnings flag). */
-  recordPreTool(toolName: string, toolInput: unknown, hadWarnings: boolean): RingEntry {
-    const entry: RingEntry = {
-      toolName,
-      toolInput,
-      timestamp: Date.now(),
-      hadWarnings,
-      tokens: tokenize(toolInput),
-      filePath: extractFilePath(toolName, toolInput),
-    };
-    this.buffer.push(entry);
-    if (this.buffer.length > RING_SIZE) this.buffer.shift();
-    this.currentBatch.push(entry);
-    return entry;
-  }
-
-  /** Mark the most recent entry as completed (called from PostToolUse path). */
-  recordPostTool(toolName: string, success: boolean): RingEntry | null {
-    for (let i = this.buffer.length - 1; i >= 0; i--) {
-      const e = this.buffer[i]!;
-      if (e.toolName === toolName && e.success === undefined) {
-        e.success = success;
-        return e;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Inspect the latest entry for a retry-pattern.
-   * Returns a mistake event when a prior failed attempt of the same tool with
-   * similar input was followed by a success here.
-   */
-  detectRetryPattern(): MistakeEvent | null {
-    if (this.buffer.length < 2) return null;
-    const latest = this.buffer[this.buffer.length - 1]!;
-    if (latest.success !== true) return null;
-
-    const start = Math.max(0, this.buffer.length - 1 - RETRY_LOOKBACK_TURNS);
-    for (let i = this.buffer.length - 2; i >= start; i--) {
-      const prior = this.buffer[i]!;
-      if (prior.toolName !== latest.toolName) continue;
-      if (prior.success !== false) continue;
-      const sim = jaccardSimilarity(prior.tokens, latest.tokens);
-      if (sim >= RETRY_SIMILARITY_THRESHOLD) {
-        return {
-          kind: "retry-pattern",
-          toolName: latest.toolName,
-          toolInput: latest.toolInput,
-          evidence: {
-            similarity: Number(sim.toFixed(3)),
-            firstAttemptToolInput: prior.toolInput,
-            firstAttemptHadWarnings: prior.hadWarnings,
-            turnsSincePrior: this.buffer.length - 1 - i,
-          },
-        };
-      }
-    }
-    return null;
-  }
-
-  /**
-   * File-revert detection — behavior-based veto signal.
-   *
-   * If the incoming Edit/Write call targets a file that the agent already
-   * edited in the PRIOR batch (and that prior edit had warnings), treat it
-   * as the user re-touching the same file to undo or rework what we just
-   * did. Emits one veto event per matching prior-batch entry.
-   *
-   * Call this from the PreToolUse path AFTER recordPreTool, because we need
-   * the resolved filePath of the new entry.
-   *
-   * Gate: at least one prior-batch entry on the same file must have had
-   * warnings — generic re-edits during normal iteration shouldn't fire.
-   */
-  detectFileRevert(toolName: string, toolInput: unknown): MistakeEvent[] {
-    if (!isEditTool(toolName)) return [];
-    const path = extractFilePath(toolName, toolInput);
-    if (!path) return [];
-    if (this.priorBatch.length === 0) return [];
-
-    const matches = this.priorBatch.filter((e) => isEditTool(e.toolName) && e.filePath === path && e.hadWarnings);
-    if (matches.length === 0) return [];
-
-    return matches.map<MistakeEvent>((e) => ({
-      kind: "user-veto",
-      toolName: e.toolName,
-      toolInput: e.toolInput,
-      evidence: {
-        signal: "file-revert",
-        filePath: path,
-        priorEditTimestamp: e.timestamp,
-        priorEditSucceeded: e.success ?? null,
-        nextEditTool: toolName,
-      },
-    }));
-  }
-
-  /**
-   * Abort detection — behavior-based veto signal.
-   *
-   * Called when the runtime detects the user aborted the in-flight turn.
-   * Emits one veto event per current-batch entry that had warnings. Tools
-   * without warnings are skipped (an unrelated abort shouldn't poison the
-   * brain about them).
-   */
-  detectAbort(reason?: string): MistakeEvent[] {
-    if (this.currentBatch.length === 0) return [];
-    const flagged = this.currentBatch.filter((e) => e.hadWarnings);
-    if (flagged.length === 0) return [];
-    return flagged.map<MistakeEvent>((e) => ({
-      kind: "user-veto",
-      toolName: e.toolName,
-      toolInput: e.toolInput,
-      evidence: {
-        signal: "abort",
-        ...(reason ? { reason } : {}),
-        toolSucceeded: e.success ?? null,
-      },
-    }));
-  }
-
-  /**
-   * Reset the active batch — call at the start of every user turn.
-   * Captures the prior batch so file-revert detection has something to
-   * compare against on the first tool of the new turn.
-   */
-  resetBatch(): void {
-    this.priorBatch = this.currentBatch;
-    this.currentBatch = [];
-  }
-
-  /** For tests + introspection. */
-  snapshot(): { ring: RingEntry[]; batch: RingEntry[]; priorBatch: RingEntry[] } {
-    return {
-      ring: this.buffer.map((e) => ({ ...e, tokens: new Set(e.tokens) })),
-      batch: this.currentBatch.map((e) => ({ ...e, tokens: new Set(e.tokens) })),
-      priorBatch: this.priorBatch.map((e) => ({ ...e, tokens: new Set(e.tokens) })),
-    };
-  }
-
-  /** Clear all state. Test-only. */
-  reset(): void {
-    this.buffer = [];
-    this.currentBatch = [];
-    this.priorBatch = [];
-  }
-}
-
-// ─── Module-level singleton ───────────────────────────────────────────────────
-
-let _detector: MistakeDetector | null = null;
-
-export function getMistakeDetector(): MistakeDetector {
-  if (!_detector) _detector = new MistakeDetector();
-  return _detector;
-}
-
-/** Test-only helper. */
-export function resetMistakeDetector(): void {
-  _detector = null;
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function isEditTool(toolName: string): boolean {
-  return EDIT_TOOL_NAMES.has(toolName);
-}
-
-/**
- * Resolve the file path argument for an edit-class tool. Returns null when
- * the tool is not an edit tool or the input shape is unexpected.
- */
-function extractFilePath(toolName: string, toolInput: unknown): string | null {
-  if (!isEditTool(toolName)) return null;
-  if (!toolInput || typeof toolInput !== "object") return null;
-  const obj = toolInput as Record<string, unknown>;
-  const candidate = obj.file_path ?? obj.filePath ?? obj.path ?? obj.notebook_path;
-  if (typeof candidate !== "string" || candidate.length === 0) return null;
-  return normalizePath(candidate);
-}
-
-/**
- * Normalize a path for cross-tool equality comparison: trim, lowercase the
- * Windows drive letter, swap backslashes to forward slashes. We do NOT
- * resolve symlinks or canonicalize against cwd — false negatives on relative
- * vs. absolute paths are acceptable; false positives are not.
- */
-function normalizePath(p: string): string {
-  let out = p.trim().replace(/\\/g, "/");
-  if (/^[a-zA-Z]:\//.test(out)) {
-    out = out[0]!.toLowerCase() + out.slice(1);
-  }
-  return out;
-}
-
-function tokenize(input: unknown): Set<string> {
-  let json: string;
-  try {
-    json = typeof input === "string" ? input : JSON.stringify(input);
-  } catch {
-    json = String(input);
-  }
-  const tokens = json
-    .toLowerCase()
-    .split(/[^a-z0-9_-]+/)
-    .filter((t) => t.length >= 2);
-  return new Set(tokens);
-}
-
-function jaccardSimilarity(a: Set<string>, b: Set<string>): number {
-  if (a.size === 0 && b.size === 0) return 1;
-  if (a.size === 0 || b.size === 0) return 0;
-  let intersection = 0;
-  for (const t of a) if (b.has(t)) intersection++;
-  const union = a.size + b.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-
-/** Exposed for tests. */
-export const _internals = { tokenize, jaccardSimilarity, extractFilePath, isEditTool, normalizePath };