muonroi-cli 1.4.0 → 1.4.1

package/src/pil/session-state.test.ts

@@ -1,88 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import {
-  _resetForTests,
-  bumpSessionTurn,
-  getSessionState,
-  isLikelyFollowUp,
-  markDiscoveryAccepted,
-} from "./session-state.js";
-
-describe("session-state turn counter", () => {
-  beforeEach(() => _resetForTests());
-  afterEach(() => _resetForTests());
-
-  it("increments turnCount for each call per session", () => {
-    expect(bumpSessionTurn("s1")).toBe(1);
-    expect(bumpSessionTurn("s1")).toBe(2);
-    expect(bumpSessionTurn("s1")).toBe(3);
-    expect(getSessionState("s1")?.turnCount).toBe(3);
-  });
-
-  it("isolates counters per session", () => {
-    expect(bumpSessionTurn("a")).toBe(1);
-    expect(bumpSessionTurn("b")).toBe(1);
-    expect(bumpSessionTurn("a")).toBe(2);
-    expect(getSessionState("b")?.turnCount).toBe(1);
-  });
-
-  it("returns 1 and no-ops when sessionId is null/empty", () => {
-    expect(bumpSessionTurn(null)).toBe(1);
-    expect(bumpSessionTurn(undefined)).toBe(1);
-    expect(bumpSessionTurn("")).toBe(1);
-    expect(getSessionState(null)).toBeNull();
-  });
-
-  it("markDiscoveryAccepted records timestamp without resetting turnCount", () => {
-    bumpSessionTurn("s1");
-    bumpSessionTurn("s1");
-    markDiscoveryAccepted("s1", 12345);
-    const state = getSessionState("s1");
-    expect(state?.turnCount).toBe(2);
-    expect(state?.lastAcceptedDiscoveryAt).toBe(12345);
-  });
-});
-
-describe("isLikelyFollowUp", () => {
-  // Positive cases — these MUST be detected as follow-ups so PIL skips the
-  // interview askcard on turn >= 2.
-  it.each([
-    "Can you fix it?",
-    "can you fix harness failures ?",
-    "Could you try again?",
-    "please redo",
-    "now also fix the lint",
-    "what about the second one",
-    "try the other approach",
-    "redo with caching off",
-    "do it again",
-    "fix it",
-    "tiếp tục",
-    "làm tiếp",
-    "vậy thì sao",
-    "nó vẫn lỗi",
-  ])('matches follow-up: "%s"', (raw) => {
-    expect(isLikelyFollowUp(raw)).toBe(true);
-  });
-
-  // Negative cases — fresh task prompts should NOT be classified as follow-ups.
-  it.each([
-    "Add a new endpoint /api/users that returns the list of users with pagination support",
-    "Refactor src/foo.ts to use the new logger interface",
-    "Implement OAuth callback in src/auth/oauth.ts",
-    "", // empty
-    "  ", // whitespace only
-  ])('does NOT match: "%s"', (raw) => {
-    expect(isLikelyFollowUp(raw)).toBe(false);
-  });
-
-  it("does not match long prompts even when they start with 'can you'", () => {
-    const long =
-      "can you walk me through how the harness E2E test framework works, including how spawnCostLeakHarness wires the mock model into the child TUI process";
-    expect(isLikelyFollowUp(long)).toBe(false);
-  });
-
-  it("does not match pronoun-bearing prompts when long enough to be a task description", () => {
-    // 'it' appears, but the prompt is detailed enough to stand on its own.
-    expect(isLikelyFollowUp("Refactor it to use a single shared interface across modules and packages")).toBe(false);
-  });
-});

package/src/pil/session-state.ts

@@ -1,157 +0,0 @@
-/**
- * src/pil/session-state.ts
- *
- * Per-session turn counter and discovery memo. PIL discovery (Layer 1.6
- * Clarity Interview + Layer 1.8 Acceptance) was originally stateless across
- * turns — every user prompt re-ran gap detection from scratch, with no
- * awareness that the user had already had N exchanges in the same session.
- *
- * Evidence (session 1f29e238a816): user typed "Can you fix it?" as a
- * follow-up after a completed CI-fix task. PIL classified the short
- * pronoun-prompt as taskType=debug, detected a scope gap ("no file
- * referenced"), and fired an interview askcard. When the user re-typed
- * their intent as freetext to the askcard, PIL treated it as a gap answer
- * rather than a fresh prompt, looping through accept/adjust → another
- * interview askcard.
- *
- * Root cause: PIL pipeline has no input that says "this is the Nth turn
- * of an ongoing conversation". This module supplies that signal. The
- * discovery layer can use it to short-circuit interview/acceptance on
- * continuation-style prompts.
- *
- * State lives on `globalThis.__muonroiPilSessionState` so it survives
- * across `runPipeline` calls within the same CLI process. There is no
- * persistence — restarting the CLI resets all session state, which
- * matches user mental model (a new session begins discovery from scratch).
- */
-
-export interface PilSessionState {
-  /** Number of user prompts seen in this session so far (incremented per pipeline run). */
-  turnCount: number;
-  /** Timestamp of the most-recent accepted discovery; null if no discovery has been accepted yet. */
-  lastAcceptedDiscoveryAt: number | null;
-}
-
-interface PilSessionGlobals {
-  __muonroiPilSessionState?: Map<string, PilSessionState>;
-}
-
-function getMap(): Map<string, PilSessionState> {
-  const g = globalThis as PilSessionGlobals;
-  let map = g.__muonroiPilSessionState;
-  if (!(map instanceof Map)) {
-    map = new Map<string, PilSessionState>();
-    g.__muonroiPilSessionState = map;
-  }
-  return map;
-}
-
-export function getSessionState(sessionId: string | null | undefined): PilSessionState | null {
-  if (!sessionId) return null;
-  return getMap().get(sessionId) ?? null;
-}
-
-/**
- * Bump the turn counter for `sessionId`. Called once per `runPipeline`
- * invocation. The post-increment count is returned so the caller can act
- * on "first turn" (count===1) vs "follow-up" (count>1) without a second
- * lookup.
- */
-export function bumpSessionTurn(sessionId: string | null | undefined): number {
-  if (!sessionId) return 1;
-  const map = getMap();
-  const prior = map.get(sessionId);
-  const next: PilSessionState = {
-    turnCount: (prior?.turnCount ?? 0) + 1,
-    lastAcceptedDiscoveryAt: prior?.lastAcceptedDiscoveryAt ?? null,
-  };
-  map.set(sessionId, next);
-  return next.turnCount;
-}
-
-export function markDiscoveryAccepted(sessionId: string | null | undefined, at = Date.now()): void {
-  if (!sessionId) return;
-  const map = getMap();
-  const prior = map.get(sessionId);
-  map.set(sessionId, {
-    turnCount: prior?.turnCount ?? 1,
-    lastAcceptedDiscoveryAt: at,
-  });
-}
-
-/** Test helper — clear all session state. Not exported for production use. */
-export function _resetForTests(): void {
-  (globalThis as PilSessionGlobals).__muonroiPilSessionState = undefined;
-}
-
-/**
- * Heuristic: is `raw` likely a continuation of a prior turn rather than a
- * fresh task description?
- *
- * Hits when the prompt is short AND either:
- *   - starts with a request modal that refers to prior context ("can you",
- *     "could you", "please", "now", "also", "what about", "try", "again",
- *     "redo", "do it", "fix it", "tiếp", "làm tiếp", "vậy thì")
- *   - contains a context pronoun ("it", "this", "that", "those", "them",
- *     "nó", "cái đó", "cái này") without any concrete noun anchor
- *
- * Does NOT match long detailed prompts even if they start with "can you"
- * (those genuinely describe a new task). The 80-char cap is empirically
- * tuned: real follow-ups in chat-export samples were 8-50 chars; new
- * task prompts averaged >100 chars.
- */
-// ASCII-only prefix patterns. Vietnamese phrases are matched separately via
-// lowercase substring checks because the JS `\b` boundary is ASCII-aware and
-// fires inside multi-byte characters, breaking simple "starts with this
-// phrase" intent. Splitting the two paths keeps each predicate simple and
-// easy to reason about in unit tests.
-const FOLLOW_UP_PREFIX_RE =
-  /^\s*(can|could|would|will)\s+you\b|^\s*please\b|^\s*(now|also|then|next)\b|^\s*(what|how)\s+about\b|^\s*(try|redo|again|do|fix)\b/i;
-
-// ASCII pronoun anchors. Order matters — checked alongside char-length cap.
-const CONTEXT_PRONOUN_RE = /\b(it|this|that|those|them)\b/i;
-
-// Vietnamese prefix phrases. Compared via lowercased startsWith so diacritics
-// match exactly without relying on \b.
-const VI_PREFIX_PHRASES: ReadonlyArray<string> = [
-  "tiếp",
-  "tiep",
-  "làm tiếp",
-  "lam tiep",
-  "vậy thì",
-  "vay thi",
-  "thế thì",
-  "the thi",
-  "vậy bạn",
-  "vay ban",
-  "vậy hãy",
-  "vay hay",
-  "nó ",
-  "no ",
-  "cái đó",
-  "cai do",
-  "cái này",
-  "cai nay",
-  "và ",
-  "va ",
-];
-
-const MAX_FOLLOWUP_CHARS = 80;
-
-export function isLikelyFollowUp(raw: string): boolean {
-  const t = (raw ?? "").trim();
-  if (!t || t.length > MAX_FOLLOWUP_CHARS) return false;
-  if (FOLLOW_UP_PREFIX_RE.test(t)) return true;
-  const lower = t.toLowerCase();
-  for (const phrase of VI_PREFIX_PHRASES) {
-    if (lower === phrase.trim() || lower.startsWith(phrase)) return true;
-  }
-  // Generic 'so' / 'vậy' check — often used as 'so do X' or 'vậy làm X'
-  if (lower.startsWith("vậy ") || lower.startsWith("vay ")) return true;
-
-  // Pronoun-only path requires the prompt to be quite short (no concrete
-  // file/module name anywhere). "fix the auth flow" is NOT a follow-up;
-  // "fix it" IS. Bound at 40 chars to avoid false positives.
-  if (t.length <= 40 && CONTEXT_PRONOUN_RE.test(t)) return true;
-  return false;
-}

package/src/pil/store.ts

@@ -1,29 +0,0 @@
-/**
- * src/pil/store.ts
- *
- * Module-level last-result store for the /optimize command.
- * Single-threaded per session — no zustand needed.
- */
-
-import type { PipelineContext } from "./types.js";
-
-export type OutputMode = "structured" | "text-fallback" | "conversational";
-
-let _last: PipelineContext | null = null;
-let _lastOutputMode: OutputMode = "conversational";
-
-export function setPilLastResult(ctx: PipelineContext): void {
-  _last = ctx;
-}
-
-export function getPilLastResult(): PipelineContext | null {
-  return _last;
-}
-
-export function setLastOutputMode(mode: OutputMode): void {
-  _lastOutputMode = mode;
-}
-
-export function getLastOutputMode(): OutputMode {
-  return _lastOutputMode;
-}

package/src/pil/task-tier-map.ts

@@ -1,97 +0,0 @@
-/**
- * src/pil/task-tier-map.ts
- *
- * Maps PIL TaskTypes to EE routing tiers.
- * EE tiers: 'fast' | 'balanced' | 'premium'
- *
- * Rationale for each mapping:
- * - fast: Low-complexity tasks where speed matters more than model depth
- * - balanced: Most coding tasks — needs competence but not premium reasoning
- * - premium: High-stakes planning tasks requiring deep reasoning
- */
-
-import type { ModelRole } from "../utils/settings.js";
-
-export type EETier = "fast" | "balanced" | "premium";
-
-const MAP: Record<string, EETier> = {
-  refactor: "balanced",
-  debug: "balanced",
-  plan: "premium",
-  analyze: "balanced",
-  documentation: "fast",
-  generate: "balanced",
-  general: "fast",
-};
-
-/**
- * Map a PIL taskType to an EE routing tier.
- * Returns 'fast' for null (conversational turns).
- * Returns 'balanced' for unknown task types (safe fallback).
- */
-export function taskTypeToTier(taskType: string | null): EETier {
-  if (!taskType) return "fast";
-  return MAP[taskType] ?? "balanced";
-}
-
-/**
- * Map a PIL taskType to an appropriate maxOutputTokens budget.
- *
- * PIL-L6 verbosity fix — budgets cut roughly in half from the prior values
- * (debug 6K→3K, refactor 6K→4K, plan 8K→5K, generate 12K→8K, analyze 4K→2K,
- * docs 4K→3K, default 4K→2K). Old values let "balanced" / "detailed" styles
- * pad answers with end-of-turn summaries that users skip. Truncation at the
- * tighter limit is preferable to bloat — agent will retry if it needs more.
- */
-export function taskTypeToMaxTokens(taskType: string | null): number {
-  switch (taskType) {
-    case "analyze":
-      return 2_048;
-    case "documentation":
-      return 3_072;
-    case "debug":
-      return 3_072;
-    case "refactor":
-      return 4_096;
-    case "plan":
-      return 5_120;
-    case "generate":
-      return 8_192;
-    default:
-      return 2_048; // conversational — keep short
-  }
-}
-
-/**
- * Map a PIL taskType to a reasoning effort level.
- * High-stakes planning gets full reasoning; simple tasks get minimal.
- */
-export function taskTypeToReasoningEffort(taskType: string | null): "low" | "medium" | "high" {
-  switch (taskType) {
-    case "plan":
-      return "high";
-    case "debug":
-    case "refactor":
-    case "generate":
-      return "medium";
-    case "analyze":
-    case "documentation":
-      return "low";
-    default:
-      return "low"; // conversational — minimal reasoning
-  }
-}
-
-const ROLE_MAP: Record<string, ModelRole> = {
-  plan: "leader",
-  analyze: "leader",
-  generate: "implement",
-  refactor: "implement",
-  debug: "verify",
-  documentation: "research",
-};
-
-export function taskTypeToRole(taskType: string | null): ModelRole | null {
-  if (!taskType) return null;
-  return ROLE_MAP[taskType] ?? null;
-}

package/src/pil/timeout.ts

@@ -1,10 +0,0 @@
-/**
- * src/pil/timeout.ts
- *
- * Promise.race timeout helper for the PIL pipeline.
- * Returns a promise that resolves to `value` after `ms` milliseconds.
- */
-
-export function resolveAfter<T>(ms: number, value: T): Promise<T> {
-  return new Promise<T>((resolve) => setTimeout(() => resolve(value), ms));
-}

package/src/pil/types.ts

@@ -1,168 +0,0 @@
-/**
- * src/pil/types.ts
- *
- * Core type definitions for the Prompt Intelligence Layer (PIL) pipeline.
- */
-
-import type { ComplexityTier } from "../gsd/complexity.js";
-import type { GrayAreaQuestion } from "../gsd/gray-areas.js";
-import type { ComplexitySizeResult } from "./layer1_5-complexity-size.js";
-
-export type TaskType = "refactor" | "debug" | "plan" | "analyze" | "documentation" | "generate" | "general";
-
-export type OutputStyle = "concise" | "detailed" | "balanced";
-
-export type { ComplexityTier, GrayAreaQuestion };
-
-export interface LayerResult {
-  name: string;
-  applied: boolean;
-  delta: string | null;
-}
-
-export interface PipelineMetrics {
-  totalMs: number;
-  layerTimings: Array<{ name: string; ms: number }>;
-  inputChars: number;
-  outputChars: number;
-  /** Tokens added to system prompt input by the L6 suffix instruction. NOT tokens saved in output. */
-  suffixInstructionTokens: number;
-  enrichmentTokensAdded: number;
-}
-
-export interface PipelineContext {
-  raw: string;
-  enriched: string;
-  taskType: TaskType | null;
-  domain: string | null;
-  /** Classifier confidence score 0..1. 0 = fallback/timeout path. */
-  confidence: number;
-  outputStyle: OutputStyle | null;
-  tokenBudget: number;
-  metrics: PipelineMetrics | null;
-  layers: LayerResult[];
-  // P2: Session & GSD context (optional — layers skip if absent)
-  gsdPhase?: string | null;
-  resumeDigest?: string | null;
-  activeRunId?: string | null;
-  digestAgeMs?: number | null;
-  sessionId?: string | null;
-  /** GSD-native triage tier (set by layer4). */
-  complexityTier?: ComplexityTier | null;
-  /**
-   * Layer 1.5 deterministic complexity-size classification.
-   * Populated immediately after `layer1Intent` in `runLayers()`. Consumers:
-   *   - 4B step ceiling (task_type × size matrix lookup)
-   *   - 4A reminder cadence K (3 small / 5 medium / 8 large)
-   * Pure heuristic — no LLM call. See `layer1_5-complexity-size.ts`.
-   */
-  complexitySize?: ComplexitySizeResult | null;
-  /** Heuristic gray-area questions surfaced by layer4 when tier === "heavy". */
-  grayAreas?: GrayAreaQuestion[];
-  /**
-   * Coarse intent: "chitchat" for greetings/small-talk/no-coding-intent,
-   * "task" when there is a coding intent, null when undetermined. Set by
-   * layer1; respected by layer4 (skip GSD directive) and layer5 (skip
-   * heavy context like recent-files / flow-state). Distinct from taskType
-   * "general", which conflates chitchat with low-confidence fallback.
-   */
-  intentKind?: "task" | "chitchat" | null;
-  /**
-   * Diagnostic: when the pipeline returns the fallback context, this records
-   * the reason (timeout / schema-reject / exception). Null on the happy path.
-   * Helps distinguish "fallback because brain unreachable" from "fallback
-   * because schema validation failed" when reading interaction_logs.
-   */
-  fallbackReason?: string | null;
-  /**
-   * T1 behavioral rules extracted by Layer 3 from EE proven-tier points.
-   * These are high-hitCount / tier=proven entries that have been promoted to
-   * behavioral reflex status. Layer 6 appends them as MANDATORY RULES to the
-   * output suffix so the model treats them as instructions, not just context.
-   *
-   * TODO(WhoAmI): when EE v4.0 Who Am I is implemented, merge project-level
-   * t1Rules with user-level personality directives from the profile model.
-   */
-  t1Rules?: string[];
-  /**
-   * Brain-derived data populated by Layer 1 when the unified /api/pil-context
-   * call succeeds. Layers 3, 5, 6 read from here instead of issuing their own
-   * brain calls. Null when L1 took the legacy path (brain unreachable, low
-   * pipeline budget, or feature flag disabled).
-   */
-  _brainData?: BrainData | null;
-  /**
-   * Step-by-step task detection trace from Layer 1. Captures which Pass set
-   * the final taskType + style, so cost reports can answer "are we wasting
-   * brain calls when regex would have answered?". Optional — `pipeline.ts`
-   * forwards it to the PIL budget log when present.
-   */
-  _intentTrace?: IntentDetectionTrace | null;
-  _discoveryResult?: import("./discovery-types.js").DiscoveryResult | null;
-}
-
-/**
- * One-shot snapshot of Layer 1's three-pass intent detection cascade.
- * Cheaper passes hit first; later passes only run when earlier ones abstain.
- * Each `*Hit` flag answers "did this pass decide the final taskType/style?"
- * — at most one of `pass1/2/3` should be true for `*Hit` fields.
- */
-export interface IntentDetectionTrace {
-  /**
-   * Detected target framework for BB-aware retrieval.
-   * "muonroi-building-block" when Directory.Build.props + *.sln + src/Muonroi.* heuristic matches.
-   * Undefined when no framework-specific signals detected.
-   */
-  targetFramework?: "muonroi-building-block" | string;
-  /** Classifier reason string (e.g. "regex:debug", "tree-sitter:typescript"). */
-  pass1Reason: string;
-  /** Confidence reported by the classifier (0..1). */
-  pass1Confidence: number;
-  /** taskType derived from pass1Reason via REASON_TO_TASK_TYPE; null if no map. */
-  pass1TaskType: string | null;
-  /** Pass 1 alone decided the final taskType (no later pass overrode it). */
-  pass1Hit: boolean;
-  /** Pass 2 keyword fallback matched. */
-  pass2Hit: boolean;
-  /** Which keyword pattern matched (string repr of regex source) — only set when pass2Hit. */
-  pass2Pattern?: string;
-  /** Pass 2.5 hot-path chitchat short-circuit fired (≤10 chars + ≤2 words). */
-  pass25ChitchatHit: boolean;
-  /** Unified /api/pil-context attempted (feature flag on + weak local signal). */
-  pass3UnifiedAttempted: boolean;
-  /** Unified call returned a non-null response. */
-  pass3UnifiedSucceeded: boolean;
-  /** Legacy brain call attempted for TASK classification (1500ms budget). */
-  pass3LegacyTaskAttempted: boolean;
-  /** Legacy task-classification call returned a non-null response. */
-  pass3LegacyTaskSucceeded: boolean;
-  /** Legacy brain call attempted for STYLE detection (800ms budget). */
-  pass3LegacyStyleAttempted: boolean;
-  /** Legacy style-detection call returned a non-null response. */
-  pass3LegacyStyleSucceeded: boolean;
-  /** Pass 4 LLM fallback attempted (brain returned null / low confidence and orchestrator supplied a closure). */
-  pass4LlmAttempted?: boolean;
-  /** Pass 4 LLM fallback returned a parseable result. */
-  pass4LlmSucceeded?: boolean;
-  /** How the final outputStyle was resolved. */
-  styleSource: "explicit-regex" | "brain-unified" | "brain-legacy" | "chitchat-default" | "classifier-default" | "none";
-  /** Final taskType emitted by Layer 1. */
-  finalTaskType: string | null;
-  /** Final confidence emitted by Layer 1. */
-  finalConfidence: number;
-  /** Heuristic complexity routing decision: low / medium / high. */
-  complexity: "low" | "medium" | "high";
-  /** Raw score that produced complexity (-3..+10 range). */
-  complexityScore: number;
-  /** Layer 1.5 bucketed size — small/medium/large. */
-  complexitySize?: "small" | "medium" | "large";
-  /** Layer 1.5 raw heuristic score. */
-  complexitySizeScore?: number;
-}
-
-export interface BrainData {
-  t0_principles: Array<{ text: string; score: number }>;
-  t1_rules: string[];
-  t2_patterns: Array<{ text: string; score: number }>;
-  retrieval_skipped_reason: string | null;
-}

package/src/product-loop/__tests__/artifact-io.test.ts

@@ -1,97 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { createRun } from "../../flow/run-manager.js";
-import { appendIteration, markIterationCrashed, readIterations, readManifest, writeManifest } from "../artifact-io.js";
-import type { IterationState, ProductRunManifest } from "../types.js";
-
-describe("product-loop artifact-io", () => {
-  let tmpDir: string;
-  let runId: string;
-
-  beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "muonroi-artifact-test-"));
-    const run = await createRun(tmpDir);
-    runId = run.id;
-  });
-
-  afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-  });
-
-  it("should round-trip manifest", async () => {
-    const manifest: ProductRunManifest = {
-      idea: "A revolutionary AI agent",
-      capUsd: 50,
-      maxSprints: 8,
-      doneThreshold: 0.9,
-      createdAt: new Date("2024-01-01T00:00:00Z"),
-      stack: "TypeScript, Vitest",
-    };
-
-    await writeManifest(tmpDir, runId, manifest);
-    const loaded = await readManifest(tmpDir, runId);
-
-    expect(loaded).toEqual(manifest);
-  });
-
-  it("should append and read iterations", async () => {
-    const it1: IterationState = {
-      sprintN: 1,
-      stage: "judge",
-      scoreBefore: 0.0,
-      scoreAfter: 0.4,
-      criteriaMet: 1,
-      criteriaPartial: 1,
-      criteriaUnmet: 4,
-      costUsd: 0.12,
-      lastVerifyResult: "PASS",
-    };
-
-    const it2: IterationState = {
-      sprintN: 2,
-      stage: "judge",
-      scoreBefore: 0.4,
-      scoreAfter: 0.6,
-      criteriaMet: 3,
-      criteriaPartial: 1,
-      criteriaUnmet: 2,
-      costUsd: 0.25,
-      lastVerifyResult: "FAIL",
-    };
-
-    await appendIteration(tmpDir, runId, it1);
-    await appendIteration(tmpDir, runId, it2);
-
-    const iterations = await readIterations(tmpDir, runId);
-    expect(iterations.length).toBe(2);
-    expect(iterations[0]).toEqual(it1);
-    expect(iterations[1]).toEqual(it2);
-  });
-
-  it("should mark iteration crashed", async () => {
-    const it1: IterationState = {
-      sprintN: 1,
-      stage: "implement",
-      scoreBefore: 0.0,
-      scoreAfter: 0.0,
-      criteriaMet: 0,
-      criteriaPartial: 0,
-      criteriaUnmet: 6,
-      costUsd: 0.05,
-      lastVerifyResult: "NONE",
-    };
-
-    await appendIteration(tmpDir, runId, it1);
-    await markIterationCrashed(tmpDir, runId, 1);
-
-    const iterations = await readIterations(tmpDir, runId);
-    expect(iterations[0].crashed).toBe(true);
-  });
-
-  it("should return null for empty manifest", async () => {
-    const loaded = await readManifest(tmpDir, runId);
-    expect(loaded).toBeNull();
-  });
-});