muonroi-cli 1.4.0 → 1.4.1

package/src/orchestrator/scope-ceiling.test.ts

@@ -1,215 +0,0 @@
-/**
- * Tests for scope-ceiling module (Plan 04-4B).
- *
- * Covers:
- *  - Matrix lookup for every task_type × size cell (all 7 task_type rows
- *    referenced verbatim per locked CONTEXT)
- *  - Unknown taskType fallback to "general" row
- *  - parseBudgetOverride flag extraction + prompt cleaning
- *  - Session counter persistence + per-session isolation
- *  - Soft-warn step computation
- *  - forcedFinalize delegates to passed-in model factory (no hardcoded IDs)
- */
-
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  forcedFinalize,
-  getSessionLastTask,
-  getSessionStepCount,
-  incSessionStep,
-  parseBudgetOverride,
-  recordSessionLastTask,
-  resetSessionStep,
-  resolveCeiling,
-  softWarnStep,
-} from "./scope-ceiling.js";
-
-describe("resolveCeiling — matrix lookup (locked verbatim)", () => {
-  it("analyze row", () => {
-    expect(resolveCeiling("analyze", "small")).toBe(5);
-    expect(resolveCeiling("analyze", "medium")).toBe(10);
-    expect(resolveCeiling("analyze", "large")).toBe(15);
-  });
-  it("debug row", () => {
-    expect(resolveCeiling("debug", "small")).toBe(6);
-    expect(resolveCeiling("debug", "medium")).toBe(12);
-    expect(resolveCeiling("debug", "large")).toBe(20);
-  });
-  it("refactor row", () => {
-    expect(resolveCeiling("refactor", "small")).toBe(8);
-    expect(resolveCeiling("refactor", "medium")).toBe(14);
-    expect(resolveCeiling("refactor", "large")).toBe(22);
-  });
-  it("generate row", () => {
-    expect(resolveCeiling("generate", "small")).toBe(10);
-    expect(resolveCeiling("generate", "medium")).toBe(18);
-    expect(resolveCeiling("generate", "large")).toBe(30);
-  });
-  it("plan row", () => {
-    expect(resolveCeiling("plan", "small")).toBe(4);
-    expect(resolveCeiling("plan", "medium")).toBe(8);
-    expect(resolveCeiling("plan", "large")).toBe(12);
-  });
-  it("documentation row", () => {
-    expect(resolveCeiling("documentation", "small")).toBe(5);
-    expect(resolveCeiling("documentation", "medium")).toBe(8);
-    expect(resolveCeiling("documentation", "large")).toBe(12);
-  });
-  it("general row", () => {
-    expect(resolveCeiling("general", "small")).toBe(5);
-    expect(resolveCeiling("general", "medium")).toBe(10);
-    expect(resolveCeiling("general", "large")).toBe(20);
-  });
-
-  it("unknown taskType falls back to general row", () => {
-    expect(resolveCeiling("unknown-task", "small")).toBe(5);
-    expect(resolveCeiling("unknown-task", "medium")).toBe(10);
-    expect(resolveCeiling("unknown-task", "large")).toBe(20);
-  });
-
-  it("null/undefined taskType falls back to general", () => {
-    expect(resolveCeiling(undefined as unknown as string, "medium")).toBe(10);
-    expect(resolveCeiling(null as unknown as string, "large")).toBe(20);
-  });
-});
-
-describe("softWarnStep — floor(ceiling × 0.7)", () => {
-  it("computes 70% floor", () => {
-    expect(softWarnStep(10)).toBe(7);
-    expect(softWarnStep(20)).toBe(14);
-    expect(softWarnStep(5)).toBe(3); // floor(3.5)
-    expect(softWarnStep(8)).toBe(5); // floor(5.6)
-  });
-});
-
-describe("parseBudgetOverride", () => {
-  it("extracts numeric override + strips flag from prompt", () => {
-    const r = parseBudgetOverride("--budget-rounds 20 fix bug");
-    expect(r.override).toBe(20);
-    expect(r.cleanedPrompt).toBe("fix bug");
-  });
-
-  it("handles flag in middle of prompt", () => {
-    const r = parseBudgetOverride("fix --budget-rounds 50 the bug");
-    expect(r.override).toBe(50);
-    expect(r.cleanedPrompt).toBe("fix the bug");
-  });
-
-  it("returns undefined override when flag absent", () => {
-    const r = parseBudgetOverride("no flag here");
-    expect(r.override).toBeUndefined();
-    expect(r.cleanedPrompt).toBe("no flag here");
-  });
-
-  it("preserves empty prompt when flag is whole input", () => {
-    const r = parseBudgetOverride("--budget-rounds 7");
-    expect(r.override).toBe(7);
-    expect(r.cleanedPrompt).toBe("");
-  });
-
-  it("trims surrounding whitespace after strip", () => {
-    const r = parseBudgetOverride("   --budget-rounds 3   do thing   ");
-    expect(r.override).toBe(3);
-    expect(r.cleanedPrompt).toBe("do thing");
-  });
-
-  it("ignores malformed (non-numeric) value", () => {
-    const r = parseBudgetOverride("--budget-rounds abc do thing");
-    expect(r.override).toBeUndefined();
-    expect(r.cleanedPrompt).toBe("--budget-rounds abc do thing");
-  });
-});
-
-describe("session counter", () => {
-  afterEach(() => {
-    resetSessionStep("sess-A");
-    resetSessionStep("sess-B");
-  });
-
-  it("increment + read across two calls preserves count", () => {
-    expect(getSessionStepCount("sess-A")).toBe(0);
-    expect(incSessionStep("sess-A")).toBe(1);
-    expect(incSessionStep("sess-A")).toBe(2);
-    expect(getSessionStepCount("sess-A")).toBe(2);
-  });
-
-  it("different sessionId is isolated", () => {
-    incSessionStep("sess-A");
-    incSessionStep("sess-A");
-    incSessionStep("sess-A");
-    expect(getSessionStepCount("sess-A")).toBe(3);
-    expect(getSessionStepCount("sess-B")).toBe(0);
-    expect(incSessionStep("sess-B")).toBe(1);
-    expect(getSessionStepCount("sess-A")).toBe(3);
-  });
-
-  it("reset clears the counter", () => {
-    incSessionStep("sess-A");
-    incSessionStep("sess-A");
-    resetSessionStep("sess-A");
-    expect(getSessionStepCount("sess-A")).toBe(0);
-  });
-});
-
-describe("forcedFinalize", () => {
-  it("delegates to passed-in model — no hardcoded model id", async () => {
-    // Mock model factory that returns canned text. The shape mirrors what the
-    // AI SDK streamText would expose; forcedFinalize unwraps `.text` (or the
-    // async equivalent) and returns { text }.
-    const mockModel = {
-      __isMock: true,
-      // Marker so the implementation can detect this is a mock and short-circuit.
-    } as unknown;
-
-    const result = await forcedFinalize({
-      model: mockModel,
-      messages: [{ role: "user", content: "hello" }],
-      system: "be brief",
-      // Test-only injection — production callers pass `model` only.
-      __testInvoke: async () => ({ text: "[forced-finalize] partial answer" }),
-    } as unknown as Parameters<typeof forcedFinalize>[0]);
-
-    expect(result.text).toContain("forced-finalize");
-  });
-});
-
-describe("Phase 5 — session last-task tracking (Fix 2)", () => {
-  afterEach(() => {
-    const host = globalThis as unknown as { __muonroiSessionLastTask?: Map<string, unknown> };
-    host.__muonroiSessionLastTask?.clear();
-  });
-
-  it("records and reads the last non-chitchat task row", () => {
-    recordSessionLastTask("sess-X", "generate", "medium");
-    expect(getSessionLastTask("sess-X")).toEqual({ taskType: "generate", size: "medium" });
-  });
-
-  it("returns null when no task has been recorded", () => {
-    expect(getSessionLastTask("sess-empty")).toBeNull();
-  });
-
-  it("ignores chitchat / general / empty taskType writes", () => {
-    recordSessionLastTask("sess-Y", "general", "small");
-    expect(getSessionLastTask("sess-Y")).toBeNull();
-    recordSessionLastTask("sess-Y", "", "small");
-    expect(getSessionLastTask("sess-Y")).toBeNull();
-  });
-
-  it("isolates sessions from each other", () => {
-    recordSessionLastTask("sess-A", "refactor", "large");
-    recordSessionLastTask("sess-B", "debug", "small");
-    expect(getSessionLastTask("sess-A")).toEqual({ taskType: "refactor", size: "large" });
-    expect(getSessionLastTask("sess-B")).toEqual({ taskType: "debug", size: "small" });
-  });
-
-  it("overwrites prior row on subsequent task turns within the same session", () => {
-    recordSessionLastTask("sess-C", "analyze", "small");
-    recordSessionLastTask("sess-C", "refactor", "medium");
-    expect(getSessionLastTask("sess-C")).toEqual({ taskType: "refactor", size: "medium" });
-  });
-
-  it("rejects empty sessionId", () => {
-    recordSessionLastTask("", "generate", "medium");
-    expect(getSessionLastTask("")).toBeNull();
-  });
-});

package/src/orchestrator/scope-ceiling.ts

@@ -1,234 +0,0 @@
-/**
- * src/orchestrator/scope-ceiling.ts
- *
- * Phase 04 Plan 04 (4B) — per-session step ceiling + forced-finalize.
- *
- * Resolves `(task_type × complexity_size)` into a hard step budget. When the
- * budget is hit, the orchestrator makes ONE final LLM call with
- * `toolChoice: "none"` (forced-finalize) so the cheap model synthesizes a
- * partial answer from accumulated context BEFORE the user sees a silent halt.
- *
- * The matrix is LOCKED verbatim by the Phase 4 CONTEXT (see
- * `.planning/phases/04-scope-discipline-for-cheap-models/04-CONTEXT.md` §
- * "Step ceiling + forced-finalize (4B)"). DO NOT alter cells without re-running
- * the baseline regression harness.
- *
- * Session counter lives on `globalThis.__muonroiSessionStepCount: Map<string,
- * number>` — same lifecycle pattern as the 4R bash repeat detector + Phase C3
- * cross-turn dedup. The counter is per-session, NOT per-turn: a wandering
- * agent that bursts 50 tools across 3 user turns still trips the ceiling.
- *
- * Override grammar: `--budget-rounds N` parsed off the raw prompt BEFORE PIL
- * classifies, so the flag never reaches the model and never biases intent
- * classification.
- *
- * Zero Hardcode Rule: NO model / provider IDs in this module. `forcedFinalize`
- * receives the already-resolved model from its caller.
- */
-
-import { withDeadlineRace, withTimeoutSignal } from "../utils/llm-deadline.js";
-import { getProviderStallTimeoutMs } from "../utils/settings.js";
-
-export type TaskType = "analyze" | "debug" | "refactor" | "generate" | "plan" | "documentation" | "general";
-
-export type ComplexitySize = "small" | "medium" | "large";
-
-// ---------------------------------------------------------------------------
-// Ceiling matrix — LOCKED VERBATIM by Phase 4 CONTEXT.
-// ---------------------------------------------------------------------------
-
-const CEILING_MATRIX: Record<TaskType, Record<ComplexitySize, number>> = {
-  analyze: { small: 5, medium: 10, large: 15 },
-  debug: { small: 6, medium: 12, large: 20 },
-  refactor: { small: 8, medium: 14, large: 22 },
-  generate: { small: 10, medium: 18, large: 30 },
-  plan: { small: 4, medium: 8, large: 12 },
-  documentation: { small: 5, medium: 8, large: 12 },
-  general: { small: 5, medium: 10, large: 20 },
-};
-
-const KNOWN_TASK_TYPES = new Set<string>(Object.keys(CEILING_MATRIX));
-
-/**
- * Resolve the hard step ceiling for a (taskType, size) cell. Unknown task
- * types fall back to the `general` row per the locked spec — keeps the system
- * graceful when PIL emits an out-of-band label or null.
- */
-export function resolveCeiling(taskType: string, size: ComplexitySize): number {
-  const row: TaskType = taskType && KNOWN_TASK_TYPES.has(taskType) ? (taskType as TaskType) : "general";
-  return CEILING_MATRIX[row][size];
-}
-
-/**
- * Soft-warn step computation. Triggers the scope-reminder (4A handoff) once
- * the orchestrator reaches floor(ceiling × 0.7) — gives the agent a chance to
- * close cleanly before the hard halt.
- */
-export function softWarnStep(ceiling: number): number {
-  return Math.floor(ceiling * 0.7);
-}
-
-// ---------------------------------------------------------------------------
-// parseBudgetOverride — `--budget-rounds N` extracted BEFORE PIL.
-// ---------------------------------------------------------------------------
-
-// Matches `--budget-rounds 20` anywhere in the prompt. Up to 5 digits is enough
-// (max sane override is well below 100k). Surrounding whitespace is consumed so
-// stripping the flag does not leave double spaces.
-const BUDGET_OVERRIDE_RE = /(^|\s)--budget-rounds\s+(\d{1,5})(\s|$)/;
-
-export interface BudgetOverrideResult {
-  override: number | undefined;
-  cleanedPrompt: string;
-}
-
-export function parseBudgetOverride(raw: string): BudgetOverrideResult {
-  if (!raw) return { override: undefined, cleanedPrompt: raw ?? "" };
-  const match = raw.match(BUDGET_OVERRIDE_RE);
-  if (!match) return { override: undefined, cleanedPrompt: raw };
-  const n = Number.parseInt(match[2]!, 10);
-  if (!Number.isFinite(n) || n <= 0) return { override: undefined, cleanedPrompt: raw };
-  // Strip the entire matched segment including its leading/trailing whitespace
-  // and re-collapse the surrounding spaces.
-  const cleaned = (raw.slice(0, match.index ?? 0) + " " + raw.slice((match.index ?? 0) + match[0].length))
-    .replace(/\s+/g, " ")
-    .trim();
-  return { override: n, cleanedPrompt: cleaned };
-}
-
-// ---------------------------------------------------------------------------
-// Session counter — globalThis-backed, mirrors 4R bash repeat detector pattern.
-// ---------------------------------------------------------------------------
-
-interface GlobalCounterHost {
-  __muonroiSessionStepCount?: Map<string, number>;
-}
-
-function getCounterMap(): Map<string, number> {
-  const host = globalThis as unknown as GlobalCounterHost;
-  if (!host.__muonroiSessionStepCount) {
-    host.__muonroiSessionStepCount = new Map<string, number>();
-  }
-  return host.__muonroiSessionStepCount;
-}
-
-export function getSessionStepCount(sessionId: string): number {
-  return getCounterMap().get(sessionId) ?? 0;
-}
-
-export function incSessionStep(sessionId: string): number {
-  const map = getCounterMap();
-  const next = (map.get(sessionId) ?? 0) + 1;
-  map.set(sessionId, next);
-  return next;
-}
-
-export function resetSessionStep(sessionId: string): void {
-  getCounterMap().delete(sessionId);
-}
-
-// ---------------------------------------------------------------------------
-// Phase 5 — Session last-task ceiling row.
-//
-// When a user's continuation message ("tiếp tục" / "continue") is classified
-// chitchat by PIL Layer 1 Pass 0, the natural ceiling resolution collapses
-// from the original task's row (e.g. generate × medium = 18) to general ×
-// small = 5. After turn 1 used 18 tools, any continuation would be halted
-// almost immediately because the per-session step counter never resets.
-//
-// Fix part 2: record the (taskType, size) of every NON-chitchat turn so
-// continuation turns can inherit it. The lifetime mirrors __muonroiSessionStepCount
-// — global Map, cleared at process exit. Memory is bounded (one entry per
-// active session).
-// ---------------------------------------------------------------------------
-
-interface GlobalLastTaskHost {
-  __muonroiSessionLastTask?: Map<string, { taskType: string; size: ComplexitySize }>;
-}
-
-function getLastTaskMap(): Map<string, { taskType: string; size: ComplexitySize }> {
-  const host = globalThis as unknown as GlobalLastTaskHost;
-  if (!host.__muonroiSessionLastTask) {
-    host.__muonroiSessionLastTask = new Map<string, { taskType: string; size: ComplexitySize }>();
-  }
-  return host.__muonroiSessionLastTask;
-}
-
-/** Record the most recent NON-chitchat (taskType, size) for this session. */
-export function recordSessionLastTask(sessionId: string, taskType: string, size: ComplexitySize): void {
-  if (!sessionId || !taskType || taskType === "general") return;
-  getLastTaskMap().set(sessionId, { taskType, size });
-}
-
-/** Read the most recent non-chitchat task row, or null when none recorded. */
-export function getSessionLastTask(sessionId: string): { taskType: string; size: ComplexitySize } | null {
-  if (!sessionId) return null;
-  return getLastTaskMap().get(sessionId) ?? null;
-}
-
-// ---------------------------------------------------------------------------
-// forcedFinalize — single LLM call with toolChoice:"none" after ceiling hit.
-// ---------------------------------------------------------------------------
-
-export interface ForcedFinalizeOptions {
-  /** AI-SDK language model instance (already resolved by caller). */
-  model: unknown;
-  /** Accumulated conversation history at the point of halt. */
-  messages: unknown[];
-  /** Optional system prompt — caller passes the SAME prompt used during the run. */
-  system?: string;
-  /**
-   * Test-only injection. Production callers MUST omit this. When present, the
-   * implementation skips the AI SDK call and returns the value verbatim — used
-   * in unit tests so we can exercise the signature without spinning up the
-   * provider runtime.
-   */
-  __testInvoke?: () => Promise<{ text: string }>;
-}
-
-export interface ForcedFinalizeResult {
-  text: string;
-}
-
-/**
- * Make one final LLM call with `toolChoice: "none"` to coerce a text-only
- * synthesis from the model. The caller appends `text` to the assistant output,
- * then emits the `halted: step ceiling exceeded ...` toast.
- *
- * NOTE: this helper deliberately keeps its signature minimal. Callers in
- * message-processor and stream-runner adapt their existing streamText
- * scaffolding (system + messages + providerOptions) and pass the same model.
- */
-export async function forcedFinalize(opts: ForcedFinalizeOptions): Promise<ForcedFinalizeResult> {
-  if (opts.__testInvoke) {
-    return opts.__testInvoke();
-  }
-  // Lazy import keeps test-only paths from paying the AI SDK import cost.
-  const { generateText } = await import("ai");
-  // Cast to `any` at the call boundary — the AI SDK's generic Prompt shape
-  // requires either `prompt` xor `messages`, and we have already validated
-  // `messages` shape at the orchestrator caller. Keeping types loose here
-  // keeps this helper provider-agnostic per the Zero Hardcode Rule.
-  // biome-ignore lint/suspicious/noExplicitAny: AI SDK generic call boundary
-  const callArgs: any = {
-    model: opts.model,
-    messages: opts.messages,
-    toolChoice: "none",
-    maxRetries: 0,
-  };
-  if (opts.system) callArgs.system = opts.system;
-  // Bound the forced-finalize call: a wedged provider response must not freeze
-  // the orchestrator silently (no streamText stall watchdog covers this call).
-  const { signal: timedSignal, cleanup: cleanupTimeout } = withTimeoutSignal(undefined, getProviderStallTimeoutMs());
-  callArgs.abortSignal = timedSignal;
-  try {
-    const result = await withDeadlineRace(
-      () => generateText(callArgs),
-      getProviderStallTimeoutMs() + 5_000,
-      "forced_finalize",
-    );
-    return { text: result.text ?? "" };
-  } finally {
-    cleanupTimeout();
-  }
-}

package/src/orchestrator/scope-reminder.test.ts

@@ -1,232 +0,0 @@
-/**
- * src/orchestrator/scope-reminder.test.ts
- *
- * Phase 04 / Plan 4A — REQ-005 scope reminder cadence + format + soft-warn.
- *
- * Locked behaviour per 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)
- *   - Reminder lives in tool_result/system message — never in system prompt
- */
-
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import {
-  attachReminderToMessages,
-  buildScopeReminder,
-  cadenceForSize,
-  shouldInjectCeilingCrossing,
-  shouldInjectReminder,
-  shouldInjectSoftWarn,
-} from "./scope-reminder.js";
-
-describe("cadenceForSize", () => {
-  it("locks 3/5/8 for small/medium/large with hard floor >= 3", () => {
-    expect(cadenceForSize("small")).toBe(3);
-    expect(cadenceForSize("medium")).toBe(5);
-    expect(cadenceForSize("large")).toBe(8);
-  });
-
-  it("defends the K >= 3 hard floor against unknown sizes", () => {
-    // Cast through unknown — the public contract is "small"|"medium"|"large"
-    // but a caller can still pass garbage at runtime. Floor must hold.
-    expect(cadenceForSize("tiny" as unknown as "small")).toBeGreaterThanOrEqual(3);
-  });
-});
-
-describe("shouldInjectReminder", () => {
-  it("returns true at every multiple of K, false elsewhere", () => {
-    expect(shouldInjectReminder(0, 3)).toBe(false); // step 0 is pre-loop
-    expect(shouldInjectReminder(1, 3)).toBe(false);
-    expect(shouldInjectReminder(2, 3)).toBe(false);
-    expect(shouldInjectReminder(3, 3)).toBe(true);
-    expect(shouldInjectReminder(4, 3)).toBe(false);
-    expect(shouldInjectReminder(5, 3)).toBe(false);
-    expect(shouldInjectReminder(6, 3)).toBe(true);
-    expect(shouldInjectReminder(9, 3)).toBe(true);
-  });
-
-  it("works for K=5 (medium) and K=8 (large)", () => {
-    expect(shouldInjectReminder(5, 5)).toBe(true);
-    expect(shouldInjectReminder(10, 5)).toBe(true);
-    expect(shouldInjectReminder(7, 5)).toBe(false);
-    expect(shouldInjectReminder(8, 8)).toBe(true);
-    expect(shouldInjectReminder(16, 8)).toBe(true);
-    expect(shouldInjectReminder(9, 8)).toBe(false);
-  });
-
-  it("never fires for non-positive step", () => {
-    expect(shouldInjectReminder(-1, 3)).toBe(false);
-    expect(shouldInjectReminder(0, 3)).toBe(false);
-  });
-});
-
-describe("shouldInjectSoftWarn", () => {
-  beforeEach(() => {
-    // Reset global one-shot guard between tests.
-    (globalThis as Record<string, unknown>).__muonroiSoftWarnFired = undefined;
-  });
-  afterEach(() => {
-    (globalThis as Record<string, unknown>).__muonroiSoftWarnFired = undefined;
-  });
-
-  it("fires once at floor(ceiling * 0.7) per session", () => {
-    // ceiling 10 -> floor(7) = 7
-    expect(shouldInjectSoftWarn(6, 10, "sess-A")).toBe(false);
-    expect(shouldInjectSoftWarn(7, 10, "sess-A")).toBe(true);
-    // Subsequent calls within same session return false.
-    expect(shouldInjectSoftWarn(7, 10, "sess-A")).toBe(false);
-    expect(shouldInjectSoftWarn(8, 10, "sess-A")).toBe(false);
-  });
-
-  it("fires independently per session id", () => {
-    expect(shouldInjectSoftWarn(7, 10, "sess-A")).toBe(true);
-    // Different session — fresh one-shot.
-    expect(shouldInjectSoftWarn(7, 10, "sess-B")).toBe(true);
-    expect(shouldInjectSoftWarn(7, 10, "sess-B")).toBe(false);
-  });
-
-  it("does not fire below threshold", () => {
-    // ceiling 20 -> floor(14)
-    expect(shouldInjectSoftWarn(13, 20, "s1")).toBe(false);
-    expect(shouldInjectSoftWarn(14, 20, "s1")).toBe(true);
-  });
-});
-
-describe("shouldInjectCeilingCrossing", () => {
-  beforeEach(() => {
-    (globalThis as Record<string, unknown>).__muonroiCeilingCrossingFired = undefined;
-  });
-  afterEach(() => {
-    (globalThis as Record<string, unknown>).__muonroiCeilingCrossingFired = undefined;
-  });
-
-  it("fires exactly once per session at the first step past the natural ceiling", () => {
-    expect(shouldInjectCeilingCrossing(6, 6, "s1")).toBe(false); // equal, not past
-    expect(shouldInjectCeilingCrossing(7, 6, "s1")).toBe(true); // first crossing
-    expect(shouldInjectCeilingCrossing(8, 6, "s1")).toBe(false); // already fired
-    expect(shouldInjectCeilingCrossing(77, 6, "s1")).toBe(false); // still suppressed
-  });
-
-  it("fires independently per session", () => {
-    expect(shouldInjectCeilingCrossing(7, 6, "a")).toBe(true);
-    expect(shouldInjectCeilingCrossing(7, 6, "b")).toBe(true);
-    expect(shouldInjectCeilingCrossing(8, 6, "b")).toBe(false);
-  });
-
-  it("never fires below or at the ceiling", () => {
-    expect(shouldInjectCeilingCrossing(1, 6, "x")).toBe(false);
-    expect(shouldInjectCeilingCrossing(6, 6, "x")).toBe(false);
-  });
-
-  it("rejects non-positive or non-finite inputs", () => {
-    expect(shouldInjectCeilingCrossing(0, 6, "x")).toBe(false);
-    expect(shouldInjectCeilingCrossing(-1, 6, "x")).toBe(false);
-    expect(shouldInjectCeilingCrossing(7, 0, "x")).toBe(false);
-    expect(shouldInjectCeilingCrossing(Number.NaN, 6, "x")).toBe(false);
-  });
-});
-
-describe("buildScopeReminder", () => {
-  it("contains verbatim first 100 chars of prompt and stays <= 200 chars", () => {
-    const prompt = "A".repeat(200);
-    const out = buildScopeReminder({
-      step: 3,
-      ceiling: 10,
-      taskType: "refactor",
-      size: "small",
-      originalPrompt: prompt,
-    });
-    expect(out.length).toBeLessThanOrEqual(200);
-    // First 100 chars of prompt must appear verbatim.
-    expect(out).toContain("A".repeat(100));
-    // Header marker present (4V harness asserts this exact prefix).
-    expect(out).toMatch(/\[scope-check step 3\//);
-    expect(out).toContain("still on scope?");
-  });
-
-  it("uses whole prompt when shorter than 100 chars (no padding)", () => {
-    const out = buildScopeReminder({
-      step: 5,
-      ceiling: 14,
-      taskType: "debug",
-      size: "medium",
-      originalPrompt: "short prompt",
-    });
-    expect(out).toContain('"short prompt"');
-    expect(out.length).toBeLessThanOrEqual(200);
-  });
-
-  it("escapes embedded quote characters in the snippet", () => {
-    const out = buildScopeReminder({
-      step: 3,
-      ceiling: 10,
-      taskType: "generate",
-      size: "small",
-      originalPrompt: 'fix bug with "quoted" word',
-    });
-    // Embedded quote must be escaped to keep the snippet parseable.
-    expect(out).toMatch(/\\"quoted\\"/);
-    expect(out.length).toBeLessThanOrEqual(200);
-  });
-
-  it("hard-truncates final string to 200 chars defensively", () => {
-    // Even with monster taskType / size labels, hard cap holds.
-    const out = buildScopeReminder({
-      step: 9999,
-      ceiling: 99999,
-      taskType: "x".repeat(50),
-      size: "y".repeat(50),
-      originalPrompt: "P".repeat(500),
-    });
-    expect(out.length).toBeLessThanOrEqual(200);
-  });
-});
-
-describe("attachReminderToMessages", () => {
-  it("appends reminder text to the last tool message", () => {
-    const messages = [
-      { role: "user", content: "do the thing" },
-      {
-        role: "tool",
-        content: [
-          {
-            type: "tool-result",
-            toolCallId: "id1",
-            toolName: "read_file",
-            output: { type: "text", value: "file contents" },
-          },
-        ],
-      },
-    ];
-    const out = attachReminderToMessages(messages, "[scope-check step 3/10] etc") as Array<Record<string, unknown>>;
-    expect(out.length).toBe(2);
-    const last = out[1]!;
-    expect(last.role).toBe("tool");
-    // Reminder text appears appended either as a new tool-result text
-    // value, or as a wrapper around the existing one. The contract is:
-    // the reminder string is now present in the JSON-stringified last msg.
-    expect(JSON.stringify(last)).toContain("[scope-check step 3/10] etc");
-  });
-
-  it("appends a system message when last message is text-only assistant", () => {
-    const messages = [
-      { role: "user", content: "hi" },
-      { role: "assistant", content: "ok" },
-    ];
-    const out = attachReminderToMessages(messages, "remind") as Array<Record<string, unknown>>;
-    expect(out.length).toBe(3);
-    const tail = out[2]!;
-    expect(tail.role).toBe("system");
-    expect(tail.content).toBe("remind");
-  });
-
-  it("returns input unchanged when reminder is empty", () => {
-    const messages = [{ role: "user", content: "hi" }];
-    const out = attachReminderToMessages(messages, "");
-    expect(out).toEqual(messages);
-  });
-});