muonroi-cli 1.3.4 → 1.4.1

package/dist/src/orchestrator/read-path-budget.js

@@ -2,9 +2,20 @@
 // 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) {
     return READ_TOOL_PATTERN.test(name);
 }
+function isWriteTool(name) {
+    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: "..." }.
@@ -29,6 +40,7 @@ export class ReadPathBudget {
     cap;
     counts = new Map();
     capExceededHits = 0;
+    writeInvalidations = 0;
     constructor(cap) {
         this.cap = cap;
     }
@@ -45,27 +57,72 @@ export class ReadPathBudget {
         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.
+     */
+    notifyWrite(path) {
+        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;
+    }
     getStats() {
-        return { capExceededHits: this.capExceededHits, trackedPaths: this.counts.size };
+        return {
+            capExceededHits: this.capExceededHits,
+            trackedPaths: this.counts.size,
+            writeInvalidations: this.writeInvalidations,
+        };
     }
     /** Test-only. */
     clear() {
         this.counts.clear();
         this.capExceededHits = 0;
+        this.writeInvalidations = 0;
     }
 }
 export function getReadPathBudgetCap() {
     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 3;
+        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. Non-read tools pass through unchanged. Stub
+ * 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.
  */
@@ -74,7 +131,9 @@ export function wrapToolSetWithReadBudget(tools, budget) {
         return tools;
     const wrapped = {};
     for (const [name, tool] of Object.entries(tools)) {
-        if (!isReadTool(name)) {
+        const reading = isReadTool(name);
+        const writing = isWriteTool(name);
+        if (!reading && !writing) {
             wrapped[name] = tool;
             continue;
         }
@@ -84,20 +143,39 @@ export function wrapToolSetWithReadBudget(tools, budget) {
             wrapped[name] = tool;
             continue;
         }
-        wrapped[name] = {
-            ...tool,
-            execute: async (input, ctx) => {
-                const path = extractPath(input);
-                if (path) {
-                    const stub = budget.checkAndIncrement(name, path);
-                    if (stub !== null)
-                        return stub;
-                }
-                return innerExecute(input, ctx);
-            },
-        };
+        if (reading) {
+            wrapped[name] = {
+                ...tool,
+                execute: async (input, ctx) => {
+                    const path = extractPath(input);
+                    if (path) {
+                        const stub = budget.checkAndIncrement(name, path);
+                        if (stub !== null)
+                            return stub;
+                    }
+                    return innerExecute(input, ctx);
+                },
+            };
+        }
+        else {
+            wrapped[name] = {
+                ...tool,
+                execute: async (input, ctx) => {
+                    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;
+                },
+            };
+        }
     }
     return wrapped;
 }
-export const _internals = { isReadTool, extractPath, normalizePath };
+export const _internals = { isReadTool, isWriteTool, extractPath, normalizePath };
 //# sourceMappingURL=read-path-budget.js.map

package/dist/src/orchestrator/reasoning.js

@@ -4,6 +4,17 @@ const ENCRYPTED_REASONING_MARKERS = [
     "-----BEGIN AGE ENCRYPTED FILE-----",
     "encrypted_content",
 ];
+// 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;
 function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
@@ -20,6 +31,36 @@ export function containsEncryptedReasoning(text) {
     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) {
+    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;
+    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;
+}
 function sanitizeAssistantContent(content) {
     if (!Array.isArray(content))
         return content;
@@ -27,7 +68,8 @@ function sanitizeAssistantContent(content) {
         const reasoningText = getReasoningText(part);
         return !reasoningText || !containsEncryptedReasoning(reasoningText);
     });
-    return filtered.length === content.length ? content : filtered;
+    const reasoningSanitized = filtered.length === content.length ? content : filtered;
+    return stripInterToolNarration(reasoningSanitized);
 }
 export function sanitizeModelMessages(messages) {
     let changed = false;

package/dist/src/orchestrator/reasoning.test.js

@@ -22,5 +22,80 @@ describe("reasoning helpers", () => {
             },
         ]);
     });
+    // 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" } },
+                    ],
+                },
+            ];
+            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" } },
+                    ],
+                },
+            ];
+            const result = sanitizeModelMessages(messages);
+            expect((result[0]?.content).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." }],
+                },
+            ];
+            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" } },
+                    ],
+                },
+            ];
+            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" } },
+                    ],
+                },
+            ];
+            const result = sanitizeModelMessages(messages);
+            const content = result[0]?.content;
+            expect(content.every((p) => p.type === "tool-call")).toBe(true);
+            expect(content.length).toBe(2);
+        });
+    });
 });
 //# sourceMappingURL=reasoning.test.js.map

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

@@ -0,0 +1,32 @@
+/**
+ * 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";
+/**
+ * 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 declare function repairToolCallHook(args: {
+    toolCall: LanguageModelV3ToolCall;
+}): Promise<LanguageModelV3ToolCall | null>;

package/dist/src/orchestrator/repair-tool-call.js

@@ -0,0 +1,50 @@
+/**
+ * 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 { 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) {
+    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;
+    try {
+        repairedInput = JSON.stringify(result.value);
+    }
+    catch {
+        return null;
+    }
+    return {
+        ...original,
+        input: repairedInput,
+    };
+}
+//# sourceMappingURL=repair-tool-call.js.map

package/dist/src/orchestrator/repetition-detector.d.ts

@@ -0,0 +1,58 @@
+/**
+ * src/orchestrator/repetition-detector.ts
+ *
+ * Detects when the assistant text stream perseveres on the same opening
+ * phrase across consecutive streamText rounds — the "YES still on scope"
+ * anti-pattern observed in session 1f29e238a816 (15 consecutive bursts began
+ * with the same 5-word phrase while the agent loop-failed past the natural
+ * ceiling).
+ *
+ * The reminder system already softens past-ceiling pressure (see
+ * scope-reminder.ts), but a model that latches onto a scope-acknowledgement
+ * phrase will keep emitting it regardless of reminder volume. The detector
+ * closes that gap with a one-shot system message asking the agent to state
+ * the blocker explicitly instead of re-confirming scope.
+ *
+ * State lives on `globalThis.__muonroiRepetitionState: Map<sessionId, ...>`
+ * so it survives across prepareStep calls but resets between CLI processes —
+ * same pattern as scope-reminder soft-warn / ceiling-crossing one-shots.
+ *
+ * Pure functions; no side effects beyond globalThis state. The orchestrator
+ * pipes assistant text into `recordAssistantBurst` after each step finishes
+ * and consults `shouldInjectRepetitionReminder` from prepareStep.
+ */
+export interface RepetitionState {
+    /** Lowercased first-N words of the most-recent assistant burst, or null if not seen. */
+    lastPhrase: string | null;
+    /** How many consecutive bursts have started with `lastPhrase`. */
+    runLength: number;
+    /** True once we've injected a reminder this run — prevents re-injection on every step. */
+    reminderFiredForRun: boolean;
+}
+/**
+ * Extract the leading phrase used to detect repetition. Lowercased, trimmed,
+ * punctuation-stripped to N words. Returns null when the text is empty or
+ * has fewer than N usable words (don't trigger on stub one-word replies).
+ */
+export declare function extractLeadingPhrase(text: string | null | undefined): string | null;
+/**
+ * Record an assistant text burst for `sessionId` and return the updated run
+ * length (1 = first burst with this phrase, 2 = matched once, ...).
+ *
+ * Sessions with null/empty sessionId no-op (run length always 1).
+ */
+export declare function recordAssistantBurst(sessionId: string | null | undefined, text: string | null | undefined): number;
+/**
+ * True iff the session is in a repetition run of length >= TRIGGER_RUN_LENGTH
+ * AND no reminder has been injected for the current run yet. Calling this
+ * MARKS the run as fired — repeated calls inside the same run return false.
+ */
+export declare function shouldInjectRepetitionReminder(sessionId: string | null | undefined): boolean;
+/** Reminder text appended to tool_result channel when the trigger fires. */
+export declare function buildRepetitionReminder(sessionId: string): string;
+/** Test helper — clear all session state. */
+export declare function _resetForTests(): void;
+export declare const _internals: {
+    PHRASE_WORD_COUNT: number;
+    TRIGGER_RUN_LENGTH: number;
+};

package/dist/src/orchestrator/repetition-detector.js

@@ -0,0 +1,126 @@
+/**
+ * src/orchestrator/repetition-detector.ts
+ *
+ * Detects when the assistant text stream perseveres on the same opening
+ * phrase across consecutive streamText rounds — the "YES still on scope"
+ * anti-pattern observed in session 1f29e238a816 (15 consecutive bursts began
+ * with the same 5-word phrase while the agent loop-failed past the natural
+ * ceiling).
+ *
+ * The reminder system already softens past-ceiling pressure (see
+ * scope-reminder.ts), but a model that latches onto a scope-acknowledgement
+ * phrase will keep emitting it regardless of reminder volume. The detector
+ * closes that gap with a one-shot system message asking the agent to state
+ * the blocker explicitly instead of re-confirming scope.
+ *
+ * State lives on `globalThis.__muonroiRepetitionState: Map<sessionId, ...>`
+ * so it survives across prepareStep calls but resets between CLI processes —
+ * same pattern as scope-reminder soft-warn / ceiling-crossing one-shots.
+ *
+ * Pure functions; no side effects beyond globalThis state. The orchestrator
+ * pipes assistant text into `recordAssistantBurst` after each step finishes
+ * and consults `shouldInjectRepetitionReminder` from prepareStep.
+ */
+// 4 words captures the "YES still on scope" signature observed in session
+// 1f29e238. 5+ words would have to include the varying tail ("commit pushed",
+// "let me just check") and miss the perseveration pattern entirely.
+const PHRASE_WORD_COUNT = 4;
+const TRIGGER_RUN_LENGTH = 3;
+function getMap() {
+    const g = globalThis;
+    let map = g.__muonroiRepetitionState;
+    if (!(map instanceof Map)) {
+        map = new Map();
+        g.__muonroiRepetitionState = map;
+    }
+    return map;
+}
+/**
+ * Extract the leading phrase used to detect repetition. Lowercased, trimmed,
+ * punctuation-stripped to N words. Returns null when the text is empty or
+ * has fewer than N usable words (don't trigger on stub one-word replies).
+ */
+export function extractLeadingPhrase(text) {
+    if (!text)
+        return null;
+    // Strip code fences first — `\`\`\`...\`\`\`` blocks are not repetition signals.
+    const noFences = text.replace(/```[\s\S]*?```/g, " ");
+    const cleaned = noFences
+        .toLowerCase()
+        .replace(/[^a-z0-9\s'À-ɏḀ-ỿ]+/g, " ")
+        .trim();
+    if (!cleaned)
+        return null;
+    const words = cleaned.split(/\s+/);
+    if (words.length < PHRASE_WORD_COUNT)
+        return null;
+    return words.slice(0, PHRASE_WORD_COUNT).join(" ");
+}
+/**
+ * Record an assistant text burst for `sessionId` and return the updated run
+ * length (1 = first burst with this phrase, 2 = matched once, ...).
+ *
+ * Sessions with null/empty sessionId no-op (run length always 1).
+ */
+export function recordAssistantBurst(sessionId, text) {
+    if (!sessionId)
+        return 1;
+    const phrase = extractLeadingPhrase(text);
+    if (!phrase) {
+        // Non-text burst (e.g. pure tool call) — leave state untouched so a
+        // tool-call interlude between repeats does not reset the counter.
+        return getMap().get(sessionId)?.runLength ?? 1;
+    }
+    const map = getMap();
+    const prior = map.get(sessionId);
+    if (prior && prior.lastPhrase === phrase) {
+        const next = {
+            lastPhrase: phrase,
+            runLength: prior.runLength + 1,
+            reminderFiredForRun: prior.reminderFiredForRun,
+        };
+        map.set(sessionId, next);
+        return next.runLength;
+    }
+    // New phrase — reset the run.
+    map.set(sessionId, { lastPhrase: phrase, runLength: 1, reminderFiredForRun: false });
+    return 1;
+}
+/**
+ * True iff the session is in a repetition run of length >= TRIGGER_RUN_LENGTH
+ * AND no reminder has been injected for the current run yet. Calling this
+ * MARKS the run as fired — repeated calls inside the same run return false.
+ */
+export function shouldInjectRepetitionReminder(sessionId) {
+    if (!sessionId)
+        return false;
+    const map = getMap();
+    const state = map.get(sessionId);
+    if (!state)
+        return false;
+    if (state.runLength < TRIGGER_RUN_LENGTH)
+        return false;
+    if (state.reminderFiredForRun)
+        return false;
+    map.set(sessionId, { ...state, reminderFiredForRun: true });
+    return true;
+}
+/** Reminder text appended to tool_result channel when the trigger fires. */
+export function buildRepetitionReminder(sessionId) {
+    const state = getMap().get(sessionId);
+    const runLen = state?.runLength ?? TRIGGER_RUN_LENGTH;
+    const phrase = state?.lastPhrase ?? "the same opening phrase";
+    return (`[self-repetition detected] You have started ${runLen} consecutive responses with "${phrase}". ` +
+        `This pattern indicates perseveration — re-confirming scope instead of making progress. ` +
+        `In your next response, state EXPLICITLY what is blocking you (one short sentence), then either ` +
+        `(a) take a concrete next action with a different tool, or (b) emit your best final answer with current context.`);
+}
+/** Test helper — clear all session state. */
+export function _resetForTests() {
+    globalThis.__muonroiRepetitionState = undefined;
+}
+export const _internals = {
+    PHRASE_WORD_COUNT,
+    TRIGGER_RUN_LENGTH,
+};
+//# sourceMappingURL=repetition-detector.js.map

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

@@ -0,0 +1 @@
+export {};