muonroi-cli 1.4.0 → 1.4.1

package/src/orchestrator/repetition-detector.ts

@@ -1,140 +0,0 @@
-/**
- * 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;
-
-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;
-}
-
-interface RepetitionGlobals {
-  __muonroiRepetitionState?: Map<string, RepetitionState>;
-}
-
-function getMap(): Map<string, RepetitionState> {
-  const g = globalThis as RepetitionGlobals;
-  let map = g.__muonroiRepetitionState;
-  if (!(map instanceof Map)) {
-    map = new Map<string, RepetitionState>();
-    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: string | null | undefined): string | null {
-  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: string | null | undefined, text: string | null | undefined): number {
-  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: RepetitionState = {
-      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: string | null | undefined): boolean {
-  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: string): string {
-  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(): void {
-  (globalThis as RepetitionGlobals).__muonroiRepetitionState = undefined;
-}
-
-export const _internals = {
-  PHRASE_WORD_COUNT,
-  TRIGGER_RUN_LENGTH,
-};

package/src/orchestrator/retry-classifier.ts

@@ -1,140 +0,0 @@
-import { APICallError } from "@ai-sdk/provider";
-import { STALL_ABORT_REASON } from "./stall-watchdog.js";
-
-export interface TransientCheck {
-  transient: boolean;
-  reason: string;
-}
-
-/**
- * Classifies a stream error as transient (safe to retry) or non-transient.
- *
- * Transient:
- *  - Network-level errors: ECONNREFUSED, ETIMEDOUT, ECONNRESET, EAI_AGAIN,
- *    "fetch failed", "Unable to connect", "socket hang up", "network"
- *  - HTTP 408 (request timeout), 425 (too early), 429 (rate limit), 5xx
- *  - TypeError with "fetch failed" message (browser/bun/node fetch layer)
- *  - AbortSignal.timeout firing (err.name === "TimeoutError")
- *
- * Non-transient:
- *  - AbortError (user cancellation) — caller must handle abort separately
- *  - HTTP 400, 401, 403, 422, and any other 4xx not listed above
- *  - Malformed tool/function name errors
- */
-export function classifyStreamError(err: unknown, depth = 0): TransientCheck {
-  if (depth > 2) {
-    return { transient: false, reason: "max-depth reached" };
-  }
-
-  if (!(err instanceof Error) && typeof err !== "object") {
-    return { transient: false, reason: "non-error value" };
-  }
-
-  const e = err as {
-    name?: string;
-    message?: string;
-    statusCode?: number;
-    status?: number;
-    cause?: unknown;
-    retryAfter?: number | string;
-  };
-
-  // AbortError: user cancellation — never retry, caller must handle
-  if (e.name === "AbortError") {
-    return { transient: false, reason: "user-abort" };
-  }
-
-  // Provider-stall watchdog abort (DOMException(STALL_ABORT_REASON,
-  // "TimeoutError")): the stream produced no chunk within the stall timeout.
-  // Must NOT be retried — a stalled provider just stalls again, burning another
-  // full timeout of silence. Check BEFORE the generic TimeoutError branch.
-  if (e.name === "TimeoutError" && e.message === STALL_ABORT_REASON) {
-    return { transient: false, reason: "provider-stall" };
-  }
-
-  // TimeoutError: AbortSignal.timeout() fired — transient
-  if (e.name === "TimeoutError") {
-    return { transient: true, reason: "timeout-error" };
-  }
-
-  // AI SDK APICallError with statusCode
-  if (APICallError.isInstance(err)) {
-    const status = err.statusCode;
-    if (status != null) {
-      if (isTransientStatusCode(status)) {
-        return { transient: true, reason: `http-${status}` };
-      }
-      // Any other status code (400, 401, 403, 422, etc.) is not transient
-      return { transient: false, reason: `http-${status}-non-transient` };
-    }
-  }
-
-  // Check plain statusCode / status field (some providers attach it directly)
-  const statusCode = e.statusCode ?? (e as { status?: number }).status;
-  if (typeof statusCode === "number") {
-    if (isTransientStatusCode(statusCode)) {
-      return { transient: true, reason: `http-${statusCode}` };
-    }
-    // Explicit non-transient status
-    if (statusCode >= 400) {
-      return { transient: false, reason: `http-${statusCode}-non-transient` };
-    }
-  }
-
-  const message = typeof e.message === "string" ? e.message : "";
-
-  // Malformed function/tool name errors — non-transient (own handler elsewhere)
-  if (/invalid.*function.*name|function.*name.*invalid|malformed.*tool|NoSuchTool/i.test(message)) {
-    return { transient: false, reason: "malformed-tool-name" };
-  }
-
-  // Network-level error patterns — transient
-  if (isTransientMessage(message)) {
-    return { transient: true, reason: "network-error" };
-  }
-
-  // TypeError with "fetch failed" or network message
-  if (e.name === "TypeError" && isTransientMessage(message)) {
-    return { transient: true, reason: "fetch-failed" };
-  }
-
-  // Recurse into cause (one level only)
-  if (e.cause != null) {
-    const causeResult = classifyStreamError(e.cause, depth + 1);
-    if (causeResult.transient) {
-      return { transient: true, reason: `cause:${causeResult.reason}` };
-    }
-  }
-
-  return { transient: false, reason: "unknown" };
-}
-
-function isTransientStatusCode(code: number): boolean {
-  return code === 408 || code === 425 || code === 429 || (code >= 500 && code <= 599);
-}
-
-function isTransientMessage(message: string): boolean {
-  return /ECONNREFUSED|ETIMEDOUT|ECONNRESET|EAI_AGAIN|fetch failed|Unable to connect|network|socket hang up/i.test(
-    message,
-  );
-}
-
-/**
- * Parse Retry-After header value to milliseconds.
- * Accepts an integer (seconds) or an HTTP-date string.
- * Returns null if the value cannot be parsed.
- */
-export function parseRetryAfterMs(value: string | undefined | null): number | null {
-  if (!value) return null;
-  const seconds = Number(value.trim());
-  if (!Number.isNaN(seconds) && seconds >= 0) {
-    return Math.round(seconds * 1000);
-  }
-  // Try HTTP-date ("Mon, 19 May 2026 12:00:00 GMT")
-  const ts = Date.parse(value);
-  if (!Number.isNaN(ts)) {
-    const diff = ts - Date.now();
-    return diff > 0 ? diff : 0;
-  }
-  return null;
-}

package/src/orchestrator/retry-stream.ts

@@ -1,159 +0,0 @@
-import { classifyStreamError, parseRetryAfterMs } from "./retry-classifier.js";
-
-export interface RetryInfo {
-  attempt: number;
-  maxAttempts: number;
-  errorName: string;
-  errorMessage: string;
-  nextDelayMs: number;
-}
-
-export interface RetryStreamOpts {
-  /** Maximum total attempts (first try + retries). Default: 3. */
-  maxAttempts?: number;
-  /** Base delay in ms for first retry. Default: 500. */
-  baseDelayMs?: number;
-  /** Maximum delay cap in ms. Default: 8000. */
-  maxDelayMs?: number;
-  /** Jitter fraction in 0..1. Delay is adjusted by ±(jitter * delay). Default: 0.25. */
-  jitter?: number;
-  /** User cancellation signal — abort the retry loop immediately. */
-  signal?: AbortSignal;
-  /** Telemetry callback, called before each retry sleep. */
-  onRetry?: (info: RetryInfo) => void;
-  /**
-   * Clock injection seam for tests. Replaces setTimeout-based sleep.
-   * Default: real wall-clock sleep.
-   */
-  delay?: (ms: number) => Promise<void>;
-}
-
-const DEFAULT_MAX_ATTEMPTS = 3;
-const DEFAULT_BASE_DELAY_MS = 500;
-const DEFAULT_MAX_DELAY_MS = 8_000;
-const DEFAULT_JITTER = 0.25;
-
-function computeDelay(attempt: number, baseDelayMs: number, maxDelayMs: number, jitter: number): number {
-  // Exponential: 500 → 2000 → 8000
-  const exp = Math.min(baseDelayMs * 4 ** (attempt - 1), maxDelayMs);
-  const spread = exp * jitter;
-  const delta = (Math.random() * 2 - 1) * spread; // ±jitter*delay
-  return Math.min(Math.max(0, Math.round(exp + delta)), maxDelayMs);
-}
-
-function realDelay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-/**
- * Wraps an async factory so that transient errors trigger exponential-backoff
- * retries. Designed for streamText: the factory is re-invoked on each attempt.
- *
- * Once chunks have started flowing (i.e. the factory promise resolved), we do
- * NOT retry — partial-output corruption would result. The wrapper only catches
- * errors that occur before the promise resolves (i.e. the AI SDK setup phase
- * or the very first network rejection).
- *
- * Because Vercel AI SDK's streamText returns synchronously (the object is
- * available immediately), the actual network error surfaces when you first
- * await result.fullStream or result.response. The caller is expected to wrap
- * "await the first chunk" inside the factory if needed, OR use this wrapper
- * purely to guard the streamText call itself (which can throw on bad config).
- * Either way, the retry only fires when factory() REJECTS — not mid-stream.
- */
-export async function withStreamRetry<T>(factory: () => Promise<T>, opts: RetryStreamOpts = {}): Promise<T> {
-  const maxAttempts = opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
-  const baseDelayMs = opts.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
-  const maxDelayMs = opts.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
-  const jitter = opts.jitter ?? DEFAULT_JITTER;
-  const sleepFn = opts.delay ?? realDelay;
-  const { signal, onRetry } = opts;
-
-  // Bail immediately if already aborted
-  if (signal?.aborted) {
-    throw new DOMException("Aborted before first attempt", "AbortError");
-  }
-
-  let lastError: unknown;
-
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    // Check abort before each attempt (including first)
-    if (signal?.aborted) {
-      throw new DOMException("Aborted", "AbortError");
-    }
-
-    try {
-      return await factory();
-    } catch (err: unknown) {
-      lastError = err;
-
-      // User abort — never retry; surface as AbortError so callers can distinguish
-      if (signal?.aborted) {
-        throw new DOMException("Aborted", "AbortError");
-      }
-
-      const { transient } = classifyStreamError(err);
-      if (!transient) {
-        throw err;
-      }
-
-      // Exhausted attempts — fall through to throw
-      if (attempt >= maxAttempts) {
-        break;
-      }
-
-      // Compute delay — check for Retry-After header from 429 responses
-      let nextDelayMs = computeDelay(attempt, baseDelayMs, maxDelayMs, jitter);
-
-      // Some AI SDK errors carry retryAfter (ms, already parsed by provider layer)
-      // or the raw header string
-      const errWithRetry = err as {
-        retryAfter?: number | string;
-        responseHeaders?: Record<string, string>;
-        headers?: Record<string, string>;
-      };
-
-      const retryAfterRaw =
-        errWithRetry.retryAfter ??
-        errWithRetry.responseHeaders?.["retry-after"] ??
-        errWithRetry.headers?.["retry-after"];
-
-      if (typeof retryAfterRaw === "number" && retryAfterRaw > 0) {
-        nextDelayMs = Math.min(retryAfterRaw, maxDelayMs);
-      } else if (typeof retryAfterRaw === "string") {
-        const parsed = parseRetryAfterMs(retryAfterRaw);
-        if (parsed != null) {
-          nextDelayMs = Math.min(parsed, maxDelayMs);
-        }
-      }
-
-      const errorName = err instanceof Error ? err.name : "Error";
-      const errorMessage = err instanceof Error ? err.message : String(err);
-
-      onRetry?.({
-        attempt,
-        maxAttempts,
-        errorName,
-        errorMessage,
-        nextDelayMs,
-      });
-
-      // Sleep — honor abort signal during the wait
-      await Promise.race([
-        sleepFn(nextDelayMs),
-        new Promise<never>((_, reject) => {
-          if (!signal) return;
-          const onAbort = () => reject(new DOMException("Aborted during retry delay", "AbortError"));
-          signal.addEventListener("abort", onAbort, { once: true });
-        }),
-      ]);
-
-      // Re-check after sleep
-      if (signal?.aborted) {
-        throw new DOMException("Aborted during retry delay", "AbortError");
-      }
-    }
-  }
-
-  throw lastError;
-}

package/src/orchestrator/sandbox.test.ts

@@ -1,117 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-async function importAgentModule() {
-  vi.resetModules();
-  const { loadCatalog } = await import("../models/registry.js");
-  await loadCatalog();
-  vi.doMock("../storage/index", () => ({
-    appendCompaction: vi.fn(),
-    appendMessages: vi.fn(() => []),
-    appendSystemMessage: vi.fn(() => 0),
-    buildChatEntries: vi.fn(() => []),
-    getNextMessageSequence: vi.fn(() => 0),
-    getSessionTotalTokens: vi.fn(() => 0),
-    loadTranscript: vi.fn(() => []),
-    loadTranscriptState: vi.fn(() => ({ messages: [], seqs: [] })),
-    recordUsageEvent: vi.fn(),
-    SessionStore: class {
-      getWorkspace() {
-        return null;
-      }
-      openSession() {
-        return null;
-      }
-      createSession() {
-        return null;
-      }
-      setModel() {}
-      getRequiredSession() {
-        return null;
-      }
-      setMode() {}
-      touchSession() {}
-    },
-  }));
-
-  return import("./orchestrator");
-}
-
-afterEach(() => {
-  vi.restoreAllMocks();
-  vi.resetModules();
-  vi.doUnmock("../storage/index.js");
-});
-
-describe("Agent sandbox mode", { timeout: 30_000 }, () => {
-  it("can switch sandbox mode at runtime", async () => {
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-      sandboxMode: "off",
-    });
-
-    expect(agent.getSandboxMode()).toBe("off");
-
-    agent.setSandboxMode("shuru");
-
-    expect(agent.getSandboxMode()).toBe("shuru");
-  });
-
-  it("passes sandbox mode into background delegations", async () => {
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-      sandboxMode: "shuru",
-    });
-    const startMock = vi.fn(async () => ({ success: true, output: "ok" }));
-    (agent as unknown as { delegations: { start: typeof startMock } }).delegations.start = startMock;
-
-    await (agent as unknown as { runDelegation: (request: unknown) => Promise<unknown> }).runDelegation({
-      agent: "explore",
-      description: "Inspect",
-      prompt: "Look around",
-    });
-
-    expect(startMock).toHaveBeenCalledWith(
-      expect.objectContaining({ agent: "explore" }),
-      expect.objectContaining({ sandboxMode: "shuru" }),
-    );
-  });
-
-  it("can get and set sandbox settings", async () => {
-    const { Agent } = await importAgentModule();
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-      sandboxMode: "shuru",
-      sandboxSettings: { allowNet: true, cpus: 4 },
-    });
-
-    expect(agent.getSandboxSettings()).toEqual({ allowNet: true, cpus: 4 });
-
-    agent.setSandboxSettings({ allowNet: false, memory: 2048 });
-    expect(agent.getSandboxSettings()).toEqual({ allowNet: false, memory: 2048 });
-  });
-
-  it("passes sandbox settings into background delegations", async () => {
-    const { Agent } = await importAgentModule();
-    const settings = { allowNet: true, allowedHosts: ["api.openai.com"] };
-    const agent = new Agent(undefined, undefined, undefined, undefined, {
-      persistSession: false,
-      sandboxMode: "shuru",
-      sandboxSettings: settings,
-    });
-    const startMock = vi.fn(async () => ({ success: true, output: "ok" }));
-    (agent as unknown as { delegations: { start: typeof startMock } }).delegations.start = startMock;
-
-    await (agent as unknown as { runDelegation: (request: unknown) => Promise<unknown> }).runDelegation({
-      agent: "explore",
-      description: "Inspect",
-      prompt: "Look around",
-    });
-
-    expect(startMock).toHaveBeenCalledWith(
-      expect.objectContaining({ agent: "explore" }),
-      expect.objectContaining({ sandboxSettings: settings }),
-    );
-  });
-});