muonroi-cli 1.4.0 → 1.4.1

package/src/orchestrator/scope-reminder.ts

@@ -1,230 +0,0 @@
-/**
- * src/orchestrator/scope-reminder.ts
- *
- * Phase 04 / Plan 4A — REQ-005 scope reminder.
- *
- * Re-anchors fast-tier cheap models (DeepSeek V4 Flash etc.) to their
- * original intent at structural cadence so multi-round tool loops do not
- * drift off-task. The reminder is injected into the tool_result/system
- * message channel — NOT into the system prompt — because the system prompt
- * is repeatedly compacted by B3/B4 once cumulative input grows.
- *
- * Locked behaviour (04-CONTEXT.md "Scope reminder 4A"):
- *   - Cadence K: 3 small / 5 medium / 8 large; hard floor K >= 3
- *   - Format (<= 200 chars):
- *       [scope-check step N/CEILING — task=TASKTYPE size=SIZE]
- *       original: "PROMPT_SNIPPET (first 100 chars)"
- *       still on scope? if no → emit final answer; if yes → continue.
- *   - Soft-warn fires ONCE per session at step === floor(ceiling * 0.7)
- *
- * Wired by both orchestrator loops:
- *   - src/orchestrator/message-processor.ts (top-level streamText loop)
- *   - src/orchestrator/stream-runner.ts (sub-agent streamText loop)
- *
- * All cadence math is pure. Soft-warn one-shot state lives on
- * `globalThis.__muonroiSoftWarnFired: Map<sessionId, Set<step>>` to match
- * the cross-cutting state pattern used by cross-turn-dedup (G3).
- */
-
-export type ComplexitySize = "small" | "medium" | "large";
-
-/** Hard floor for K. Never let cadence drop below this. */
-export const SCOPE_REMINDER_FLOOR_K = 3;
-
-/** Locked cadence table per 04-CONTEXT.md. */
-const CADENCE_TABLE: Record<ComplexitySize, number> = {
-  small: 3,
-  medium: 5,
-  large: 8,
-};
-
-/** Hard cap on the produced reminder string. 4V harness asserts this. */
-export const SCOPE_REMINDER_MAX_CHARS = 200;
-
-/** First-N chars of original prompt embedded in the reminder. */
-export const SCOPE_REMINDER_PROMPT_SNIPPET_CHARS = 100;
-
-/**
- * Resolve cadence K for a complexity-size. Floor at SCOPE_REMINDER_FLOOR_K
- * defends against garbage size strings reaching this path at runtime
- * (e.g. from an older trace replay where the bucket label changed).
- */
-export function cadenceForSize(size: ComplexitySize | string | null | undefined): number {
-  const k = CADENCE_TABLE[size as ComplexitySize];
-  if (typeof k === "number" && k >= SCOPE_REMINDER_FLOOR_K) return k;
-  return SCOPE_REMINDER_FLOOR_K;
-}
-
-/**
- * True iff `step` is a non-zero multiple of K. step 0 is the pre-loop
- * boundary — never inject a reminder before the agent has done any work.
- */
-export function shouldInjectReminder(step: number, k: number): boolean {
-  if (!Number.isFinite(step) || step <= 0) return false;
-  if (!Number.isFinite(k) || k < 1) return false;
-  return step % k === 0;
-}
-
-/**
- * One-shot soft-warn guard. Returns true exactly once per session when
- * `step === floor(ceiling * 0.7)`. Subsequent calls for the same session
- * (any step) return false.
- *
- * State: `globalThis.__muonroiSoftWarnFired: Map<sessionId, true>`
- * — mirror of the cross-turn-dedup G3 pattern. The map persists for the
- * lifetime of the CLI process; cleared at process exit.
- */
-export function shouldInjectSoftWarn(step: number, ceiling: number, sessionId: string): boolean {
-  if (!Number.isFinite(step) || step <= 0) return false;
-  if (!Number.isFinite(ceiling) || ceiling <= 0) return false;
-  const threshold = Math.floor(ceiling * 0.7);
-  if (step !== threshold) return false;
-  const g = globalThis as Record<string, unknown>;
-  let fired = g.__muonroiSoftWarnFired as Map<string, true> | undefined;
-  if (!(fired instanceof Map)) {
-    fired = new Map<string, true>();
-    g.__muonroiSoftWarnFired = fired;
-  }
-  if (fired.has(sessionId)) return false;
-  fired.set(sessionId, true);
-  return true;
-}
-
-/**
- * One-shot ceiling-crossing guard. Returns true exactly once per session at
- * the first step strictly past `naturalCeiling`. After that, subsequent calls
- * for the same session return false — the orchestrator should rely on the
- * regular cadence reminder (every K steps) to anchor a model that keeps
- * working past the budget. Without this guard, sessions that went deep past
- * ceiling (e.g. step 77 / ceiling 6 in session 1f29e238a816) received the
- * "past natural budget" strong reminder on EVERY step, generating 70+
- * redundant reminders that bloat tool_result channel and force the model
- * into a "YES still on scope" loop on every tool call.
- */
-export function shouldInjectCeilingCrossing(step: number, naturalCeiling: number, sessionId: string): boolean {
-  if (!Number.isFinite(step) || step <= 0) return false;
-  if (!Number.isFinite(naturalCeiling) || naturalCeiling <= 0) return false;
-  if (step <= naturalCeiling) return false;
-  const g = globalThis as Record<string, unknown>;
-  let fired = g.__muonroiCeilingCrossingFired as Map<string, true> | undefined;
-  if (!(fired instanceof Map)) {
-    fired = new Map<string, true>();
-    g.__muonroiCeilingCrossingFired = fired;
-  }
-  if (fired.has(sessionId)) return false;
-  fired.set(sessionId, true);
-  return true;
-}
-
-export interface BuildScopeReminderOpts {
-  step: number;
-  ceiling: number;
-  taskType: string;
-  size: string;
-  originalPrompt: string;
-}
-
-/**
- * Produce the locked reminder string, guaranteed <= SCOPE_REMINDER_MAX_CHARS.
- * Format reproduced verbatim from 04-CONTEXT.md so 4V harness assertions
- * (`[scope-check step 3/`, `still on scope?`) match.
- */
-export function buildScopeReminder(opts: BuildScopeReminderOpts): string {
-  const { step, ceiling, taskType, size, originalPrompt } = opts;
-  const snippetRaw = (originalPrompt ?? "").slice(0, SCOPE_REMINDER_PROMPT_SNIPPET_CHARS);
-  // Escape embedded double quotes so the JSON-looking snippet stays parseable
-  // when an LLM tries to extract it. Backslash itself is NOT escaped because
-  // the snippet is plain prose — repeated escaping would inflate length.
-  const snippet = snippetRaw.replace(/"/g, '\\"');
-  const header = `[scope-check step ${step}/${ceiling} — task=${taskType} size=${size}]`;
-  const middle = `original: "${snippet}"`;
-  // Tail kept short so the 100-char snippet + header always fit under the
-  // 200-char hard cap (4V harness assertion). Spec phrasing "if no → emit
-  // final answer; if yes → continue" inflates this past 60 chars, which
-  // combined with a 50-char header + 100-char snippet overruns 200. The
-  // 4V assertion only cares about "[scope-check step N/" + verbatim
-  // snippet, so the trimmed tail is the minimal-impact concession.
-  const tail = "still on scope? if no, finalize.";
-  const joined = `${header}\n${middle}\n${tail}`;
-  if (joined.length <= SCOPE_REMINDER_MAX_CHARS) return joined;
-  // Defensive hard truncation. Header / tail are bounded by their own
-  // string literals + small ints; only the snippet can blow the budget
-  // when taskType/size labels are pathologically long. Re-derive a smaller
-  // snippet that fits.
-  const fixedOverhead = `[scope-check step ${step}/${ceiling} — task=${taskType} size=${size}]\noriginal: ""\n${tail}`
-    .length;
-  const room = Math.max(0, SCOPE_REMINDER_MAX_CHARS - fixedOverhead);
-  const trimmed = snippet.slice(0, room);
-  const candidate = `${header}\noriginal: "${trimmed}"\n${tail}`;
-  if (candidate.length <= SCOPE_REMINDER_MAX_CHARS) return candidate;
-  // Absolute last resort — hard slice. Better to lose readability than to
-  // exceed the contractual cap that 4V asserts on.
-  return candidate.slice(0, SCOPE_REMINDER_MAX_CHARS);
-}
-
-/**
- * Append `reminder` to a `messages` array via the tool_result channel.
- *
- * Strategy:
- *   - If the last message has role "tool" with at least one tool-result
- *     part, append a synthetic tool-result part carrying the reminder text.
- *     Pairing with an existing assistant tool-call is preserved by reusing
- *     the last result's `toolCallId` + `toolName` so the AI SDK does not
- *     drop the message for being orphaned.
- *   - Otherwise push a fresh `{role:"system", content: reminder}` at end.
- *
- * Returns a NEW array. Input is not mutated. When `reminder` is empty the
- * input is returned by identity (no allocations).
- */
-export function attachReminderToMessages<T>(messages: ReadonlyArray<T>, reminder: string): T[] {
-  if (!reminder) return messages as T[];
-  if (!Array.isArray(messages) || messages.length === 0) {
-    return [{ role: "system", content: reminder } as unknown as T];
-  }
-  const last = messages[messages.length - 1] as unknown as
-    | {
-        role?: string;
-        content?: unknown;
-      }
-    | undefined;
-  if (last && last.role === "tool" && Array.isArray(last.content)) {
-    const parts = last.content as ReadonlyArray<Record<string, unknown>>;
-    // Append reminder text INTO the last tool-result part's output value.
-    // We must NOT create a new tool-result part with a duplicate toolCallId —
-    // AI SDK v6 serializes multi-part `tool` messages into one OpenAI tool
-    // message per part, and duplicate tool_call_id causes DeepSeek/OpenAI to
-    // reject the request with "messages with role 'tool' must be a response
-    // to a preceding message with 'tool_calls'". Mutating the existing part
-    // keeps the 1:1 tool_call ↔ tool_result pairing intact.
-    for (let i = parts.length - 1; i >= 0; i--) {
-      const p = parts[i]!;
-      if (p.type !== "tool-result") continue;
-      const out_parts = parts.slice();
-      const oldOut = p.output as { type?: string; value?: unknown } | undefined;
-      const oldValue = typeof oldOut?.value === "string" ? oldOut.value : "";
-      out_parts[i] = {
-        ...p,
-        output: { type: "text", value: `${oldValue}\n\n${reminder}` },
-      };
-      const rewritten = { ...last, content: out_parts } as unknown as T;
-      const out = messages.slice() as T[];
-      out[out.length - 1] = rewritten;
-      return out;
-    }
-  }
-  // Fallback path — push a fresh system-role message.
-  return [...(messages as ReadonlyArray<T>), { role: "system", content: reminder } as unknown as T];
-}
-
-/**
- * Companion to buildScopeReminder for anti-mù.
- * Returns a short note (under SCOPE_REMINDER_MAX_CHARS budget when combined) that
- * tells the agent to self-check against persisted EE checkpoints.
- * Used by prepareStep / sub-agent paths after compaction.
- */
-export function buildCheckpointReminder(iteration: number, hasEECheckpoint: boolean): string {
-  // Enhanced per anti-mù (ideas 3+4): lighter KEEP_TOOL_IDS + on-demand artifact fetch.
-  const base = `[checkpoint status iter=${iteration}${hasEECheckpoint ? " (EE persisted)" : ""}] Task finished? Emit PRESERVE or KEEP_TOOL_IDS: id1,id2. High-value elided? Use ee_query tool with "tool-artifact id=XXX".`;
-  if (base.length <= 220) return base;
-  return base.slice(0, 220);
-}

package/src/orchestrator/stall-rescue.test.ts

@@ -1,100 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  attemptStallRescue,
-  buildStallSynthesisMessages,
-  pushStallToolResult,
-  STALL_RESCUE_MAX_CHARS_PER_RESULT,
-  STALL_RESCUE_MAX_RESULTS,
-  type StallToolResult,
-} from "./stall-rescue.js";
-
-describe("pushStallToolResult", () => {
-  it("caps the buffer count, keeping the most recent results", () => {
-    const buf: StallToolResult[] = [];
-    for (let i = 0; i < STALL_RESCUE_MAX_RESULTS + 5; i++) pushStallToolResult(buf, "bash", `out-${i}`);
-    expect(buf.length).toBe(STALL_RESCUE_MAX_RESULTS);
-    // oldest dropped, newest kept
-    expect(buf[buf.length - 1]?.text).toBe(`out-${STALL_RESCUE_MAX_RESULTS + 4}`);
-    expect(buf.some((r) => r.text === "out-0")).toBe(false);
-  });
-
-  it("truncates per-entry text and defaults a missing tool name", () => {
-    const buf: StallToolResult[] = [];
-    pushStallToolResult(buf, "", "x".repeat(STALL_RESCUE_MAX_CHARS_PER_RESULT + 500));
-    expect(buf[0]?.tool).toBe("tool");
-    expect(buf[0]?.text.length).toBe(STALL_RESCUE_MAX_CHARS_PER_RESULT);
-  });
-});
-
-describe("buildStallSynthesisMessages", () => {
-  it("appends one synthetic user turn with the request + tool digest", () => {
-    const base = [{ role: "user", content: "hi" }];
-    const out = buildStallSynthesisMessages(base, "find a bug", [
-      { tool: "grep", text: "match in a.ts" },
-      { tool: "read_file", text: "contents" },
-    ]);
-    expect(out.length).toBe(base.length + 1);
-    const last = out[out.length - 1] as { role: string; content: string };
-    expect(last.role).toBe("user");
-    expect(last.content).toContain("find a bug");
-    expect(last.content).toContain("grep");
-    expect(last.content).toContain("match in a.ts");
-    expect(last.content).toMatch(/Do NOT call any more tools/i);
-    // does not mutate the base array
-    expect(base.length).toBe(1);
-  });
-});
-
-describe("attemptStallRescue", () => {
-  it("returns null when there are no tool results (nothing to synthesize)", async () => {
-    let called = false;
-    const out = await attemptStallRescue({
-      baseMessages: [],
-      userText: "q",
-      toolResults: [],
-      finalize: async () => {
-        called = true;
-        return { text: "should not run" };
-      },
-    });
-    expect(out).toBeNull();
-    expect(called).toBe(false);
-  });
-
-  it("returns the synthesized text when finalize yields content", async () => {
-    const out = await attemptStallRescue({
-      baseMessages: [{ role: "user", content: "x" }],
-      userText: "find a bug",
-      toolResults: [{ tool: "grep", text: "found it in a.ts:42" }],
-      finalize: async ({ messages }) => {
-        // proves the digest reached the finalize call
-        const last = messages[messages.length - 1] as { content: string };
-        expect(last.content).toContain("a.ts:42");
-        return { text: "The bug is at a.ts:42 — null deref." };
-      },
-    });
-    expect(out).toBe("The bug is at a.ts:42 — null deref.");
-  });
-
-  it("returns null when finalize yields empty/whitespace text", async () => {
-    const out = await attemptStallRescue({
-      baseMessages: [],
-      userText: "q",
-      toolResults: [{ tool: "bash", text: "out" }],
-      finalize: async () => ({ text: "   " }),
-    });
-    expect(out).toBeNull();
-  });
-
-  it("never throws — returns null when finalize rejects (provider still dead)", async () => {
-    const out = await attemptStallRescue({
-      baseMessages: [],
-      userText: "q",
-      toolResults: [{ tool: "bash", text: "out" }],
-      finalize: async () => {
-        throw new Error("stall again");
-      },
-    });
-    expect(out).toBeNull();
-  });
-});

package/src/orchestrator/stall-rescue.ts

@@ -1,95 +0,0 @@
-/**
- * src/orchestrator/stall-rescue.ts
- *
- * Best-effort answer rescue when a streaming model call stalls mid-turn.
- *
- * Root cause it addresses (live obs 2026-06-04, deepseek-v4-flash session
- * 734e65cffdf6): on a long open-ended task the model looped, the loop-guard
- * fired, then the main stream stalled. The stall branch in message-processor
- * yields a bare "Model not responding" and `return`s — so a turn that already
- * ran dozens of tool calls (read_file, grep, bash …) leaves the user with NO
- * synthesis of any of that work. The normal F6 forced-finalize path that would
- * coax a text answer out of a tool-only last step is never reached because the
- * abort short-circuits before it.
- *
- * The rescue: on stall, if the turn gathered any tool outputs, make ONE
- * forced-finalize call (toolChoice:"none", its own stall timeout) over the
- * conversation plus a compact digest of those outputs, asking the model to give
- * its best final answer from what it already has. If that returns text, the turn
- * is rescued; otherwise we fall back to the bare stall message.
- *
- * This module is pure/instrumentation-free so it unit-tests without the AI SDK:
- * the caller injects `finalize`, and the live stall (nondeterministic) is not
- * needed to verify the rescue logic.
- */
-
-/** One tool output captured during the turn, already truncated by the caller. */
-export interface StallToolResult {
-  tool: string;
-  text: string;
-}
-
-/** Max tool outputs folded into the synthesis digest (most recent win). */
-export const STALL_RESCUE_MAX_RESULTS = 8;
-/** Max chars kept per tool output in the digest. */
-export const STALL_RESCUE_MAX_CHARS_PER_RESULT = 1500;
-
-/**
- * Capture a tool result into a capped ring buffer (mutates `buffer`). Keeps the
- * buffer bounded in BOTH count and per-entry size so a long turn can't blow
- * memory or the eventual synthesis prompt.
- */
-export function pushStallToolResult(buffer: StallToolResult[], tool: string, rawText: string): void {
-  const text = (rawText ?? "").slice(0, STALL_RESCUE_MAX_CHARS_PER_RESULT);
-  buffer.push({ tool: tool || "tool", text });
-  while (buffer.length > STALL_RESCUE_MAX_RESULTS) buffer.shift();
-}
-
-/**
- * Build the synthesis messages: the existing conversation plus one synthetic
- * user turn carrying the original request and a digest of the tool outputs
- * gathered before the stall. Pure — returns a fresh array, never mutates input.
- */
-export function buildStallSynthesisMessages(
-  baseMessages: unknown[],
-  userText: string,
-  toolResults: StallToolResult[],
-): unknown[] {
-  const digest = toolResults.map((r, i) => `[${i + 1}] ${r.tool}:\n${r.text}`).join("\n\n");
-  const content =
-    "The connection to the model stalled before it could finish its answer. " +
-    "You already ran the tools below this turn — use ONLY their outputs to give " +
-    "your best final answer now. Do NOT call any more tools.\n\n" +
-    `Original request:\n${userText}\n\n` +
-    `Tool outputs gathered before the stall:\n${digest}`;
-  return [...baseMessages, { role: "user", content }];
-}
-
-export interface StallRescueParams {
-  baseMessages: unknown[];
-  userText: string;
-  toolResults: StallToolResult[];
-  system?: string;
-  /**
-   * Injected finalize call (production: a thin wrapper over `forcedFinalize`).
-   * Must resolve to the synthesized text (may be empty) or reject on failure.
-   */
-  finalize: (args: { system?: string; messages: unknown[] }) => Promise<{ text: string }>;
-}
-
-/**
- * Attempt to rescue a final answer after a stall. Returns the synthesized text,
- * or null when there is nothing to synthesize from / the finalize call fails or
- * yields no text. Never throws — the caller falls back to the stall message.
- */
-export async function attemptStallRescue(params: StallRescueParams): Promise<string | null> {
-  if (!params.toolResults || params.toolResults.length === 0) return null;
-  const messages = buildStallSynthesisMessages(params.baseMessages, params.userText, params.toolResults);
-  try {
-    const result = await params.finalize({ system: params.system, messages });
-    const text = (result?.text ?? "").trim();
-    return text.length > 0 ? text : null;
-  } catch {
-    return null;
-  }
-}

package/src/orchestrator/stall-watchdog.test.ts

@@ -1,83 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createStallWatchdog, STALL_ABORT_REASON } from "./stall-watchdog.js";
-
-describe("createStallWatchdog", () => {
-  beforeEach(() => vi.useFakeTimers());
-  afterEach(() => vi.useRealTimers());
-
-  it("aborts with a TimeoutError when no chunk arrives within timeoutMs", () => {
-    const wd = createStallWatchdog(1000);
-    expect(wd.signal.aborted).toBe(false);
-    expect(wd.fired()).toBe(false);
-
-    vi.advanceTimersByTime(999);
-    expect(wd.signal.aborted).toBe(false);
-
-    vi.advanceTimersByTime(2);
-    expect(wd.signal.aborted).toBe(true);
-    expect(wd.fired()).toBe(true);
-    expect((wd.signal.reason as Error)?.name).toBe("TimeoutError");
-    expect((wd.signal.reason as Error)?.message).toBe(STALL_ABORT_REASON);
-  });
-
-  it("pet() re-arms the timer so an actively-streaming call is NOT aborted", () => {
-    const wd = createStallWatchdog(1000);
-    // Chunk every 600ms keeps it alive well past the raw timeout.
-    for (let i = 0; i < 5; i++) {
-      vi.advanceTimersByTime(600);
-      wd.pet();
-    }
-    expect(wd.signal.aborted).toBe(false);
-    expect(wd.fired()).toBe(false);
-    // ...but a gap longer than timeout after the last chunk still fires.
-    vi.advanceTimersByTime(1001);
-    expect(wd.fired()).toBe(true);
-  });
-
-  it("dispose() stops the timer (no abort after disposal)", () => {
-    const wd = createStallWatchdog(1000);
-    wd.dispose();
-    vi.advanceTimersByTime(5000);
-    expect(wd.signal.aborted).toBe(false);
-    expect(wd.fired()).toBe(false);
-  });
-
-  it("timeoutMs <= 0 disables the watchdog entirely", () => {
-    for (const ms of [0, -1, Number.NaN]) {
-      const wd = createStallWatchdog(ms);
-      vi.advanceTimersByTime(1_000_000);
-      expect(wd.signal.aborted).toBe(false);
-      expect(wd.fired()).toBe(false);
-    }
-  });
-
-  it("invokes onFire exactly once when it fires", () => {
-    const onFire = vi.fn();
-    const wd = createStallWatchdog(1000, onFire);
-    vi.advanceTimersByTime(1001);
-    expect(wd.fired()).toBe(true);
-    expect(onFire).toHaveBeenCalledTimes(1);
-  });
-
-  it("does NOT invoke onFire when disposed before timeout, or when disabled", () => {
-    const onFireA = vi.fn();
-    const a = createStallWatchdog(1000, onFireA);
-    a.dispose();
-    vi.advanceTimersByTime(5000);
-    expect(onFireA).not.toHaveBeenCalled();
-
-    const onFireB = vi.fn();
-    createStallWatchdog(0, onFireB);
-    vi.advanceTimersByTime(5000);
-    expect(onFireB).not.toHaveBeenCalled();
-  });
-
-  it("pet() after firing is a no-op (does not un-fire)", () => {
-    const wd = createStallWatchdog(1000);
-    vi.advanceTimersByTime(1001);
-    expect(wd.fired()).toBe(true);
-    wd.pet();
-    expect(wd.fired()).toBe(true);
-    expect(wd.signal.aborted).toBe(true);
-  });
-});

package/src/orchestrator/stall-watchdog.ts

@@ -1,87 +0,0 @@
-/**
- * src/orchestrator/stall-watchdog.ts
- *
- * Time-to-next-chunk watchdog for streaming model calls.
- *
- * Root cause it addresses (observed live, 2026-05-31): a provider connection
- * can accept the request but never send a response chunk (e.g. an overloaded /
- * stalled backend). `streamText` has no built-in time-to-first-byte timeout, so
- * the `for await (...result.fullStream)` loop blocks forever — the agent looks
- * frozen with ZERO user feedback (no error, no toast). Cheap/free providers hit
- * this often (balance, rate, flaky routing).
- *
- * The watchdog exposes an AbortSignal that the caller combines into the
- * streamText abortSignal. If no chunk arrives within `timeoutMs`, it aborts the
- * stream with a TimeoutError. `pet()` is called on every received chunk to
- * re-arm the timer, so the guard covers BOTH the first chunk and any mid-stream
- * stall — without killing a stream that is actively producing output.
- *
- * `timeoutMs <= 0` disables the watchdog (signal never fires).
- */
-
-export interface StallWatchdog {
-  /** Combine this into the streamText abortSignal. */
-  readonly signal: AbortSignal;
-  /** Call on every received stream chunk to reset the stall timer. */
-  pet(): void;
-  /** Stop the timer (call when the stream completes or errors). Idempotent. */
-  dispose(): void;
-  /** True iff the watchdog aborted the stream because of a stall. */
-  fired(): boolean;
-}
-
-export const STALL_ABORT_REASON = "provider-stall";
-
-/** User-facing message surfaced when the stall watchdog fires. */
-export const STALL_ERROR_MESSAGE =
-  "Model not responding — no output received within the stall timeout. " +
-  "The provider may be out of balance, rate-limited, or unreachable. " +
-  "Tune MUONROI_PROVIDER_STALL_TIMEOUT_MS (0 disables) or switch model/provider.";
-
-export function createStallWatchdog(timeoutMs: number, onFire?: () => void): StallWatchdog {
-  const controller = new AbortController();
-  let firedFlag = false;
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  const enabled = Number.isFinite(timeoutMs) && timeoutMs > 0;
-
-  const arm = () => {
-    if (!enabled) return;
-    timer = setTimeout(() => {
-      firedFlag = true;
-      // DOMException(TimeoutError) mirrors AbortSignal.timeout() semantics so
-      // downstream isAbortError-style checks treat it as an abort.
-      controller.abort(new DOMException(STALL_ABORT_REASON, "TimeoutError"));
-      try {
-        onFire?.();
-      } catch {
-        /* callback must not break the watchdog */
-      }
-    }, timeoutMs);
-    // Don't keep the event loop alive solely for the watchdog (Node).
-    (timer as { unref?: () => void }).unref?.();
-  };
-
-  const clear = () => {
-    if (timer) {
-      clearTimeout(timer);
-      timer = null;
-    }
-  };
-
-  arm();
-
-  return {
-    signal: controller.signal,
-    pet() {
-      if (!enabled || firedFlag) return;
-      clear();
-      arm();
-    },
-    dispose() {
-      clear();
-    },
-    fired() {
-      return firedFlag;
-    },
-  };
-}