codeharness 0.23.0 → 0.24.1

package/dist/index.js

@@ -51,17 +51,65 @@ function jsonOutput(data) {
 }
 
 // src/modules/infra/init-project.ts
-import { existsSync as existsSync8 } from "fs";
-import { basename as basename3 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { basename as basename3, join as join9 } from "path";
 
 // src/lib/stack-detect.ts
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, readdirSync } from "fs";
 import { join } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "target",
+  "__pycache__",
+  "dist",
+  "build",
+  "coverage",
+  ".venv",
+  "venv",
+  ".tox",
+  ".mypy_cache",
+  ".cache"
+]);
+var STACK_MARKERS = [
+  { stack: "nodejs", files: ["package.json"] },
+  { stack: "python", files: ["requirements.txt", "pyproject.toml", "setup.py"] },
+  { stack: "rust", files: ["Cargo.toml"] }
+];
+function detectStacks(dir = process.cwd()) {
+  const results = [];
+  for (const marker of STACK_MARKERS) {
+    for (const file of marker.files) {
+      if (existsSync(join(dir, file))) {
+        results.push({ stack: marker.stack, dir: "." });
+        break;
+      }
+    }
+  }
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    entries = [];
+  }
+  const subdirs = entries.filter((e) => e.isDirectory() && !SKIP_DIRS.has(e.name)).map((e) => e.name).sort();
+  for (const subdir of subdirs) {
+    const subdirPath = join(dir, subdir);
+    for (const marker of STACK_MARKERS) {
+      for (const file of marker.files) {
+        if (existsSync(join(subdirPath, file))) {
+          results.push({ stack: marker.stack, dir: subdir });
+          break;
+        }
+      }
+    }
+  }
+  return results;
+}
 function detectStack(dir = process.cwd()) {
-  if (existsSync(join(dir, "package.json"))) return "nodejs";
-  if (existsSync(join(dir, "requirements.txt"))) return "python";
-  if (existsSync(join(dir, "pyproject.toml"))) return "python";
-  if (existsSync(join(dir, "setup.py"))) return "python";
+  const stacks = detectStacks(dir);
+  const rootStack = stacks.find((s) => s.dir === ".");
+  if (rootStack) return rootStack.stack;
   warn("No recognized stack detected");
   return null;
 }
@@ -69,6 +117,8 @@ var AGENT_DEPS_NODE = ["anthropic", "@anthropic-ai/sdk", "openai", "langchain",
 var AGENT_DEPS_PYTHON = ["anthropic", "openai", "langchain", "llama-index", "traceloop-sdk"];
 var WEB_FRAMEWORK_DEPS = ["react", "vue", "svelte", "angular", "@angular/core", "next", "nuxt", "vite", "webpack"];
 var PYTHON_WEB_FRAMEWORKS = ["flask", "django", "fastapi", "streamlit"];
+var RUST_WEB_FRAMEWORKS = ["actix-web", "axum", "rocket", "tide", "warp"];
+var RUST_AGENT_DEPS = ["async-openai", "anthropic", "llm-chain"];
 function readJsonSafe(path) {
   try {
     if (!existsSync(path)) return null;
@@ -102,6 +152,18 @@ function hasPythonDep(content, dep) {
   const pattern = new RegExp(`(?:^|[\\s"',])${escaped}(?:[\\[>=<~!;\\s"',]|$)`, "m");
   return pattern.test(content);
 }
+function getCargoDepsSection(content) {
+  const match = content.match(/^\[dependencies\]\s*$/m);
+  if (!match || match.index === void 0) return "";
+  const start = match.index + match[0].length;
+  const nextSection = content.slice(start).search(/^\[/m);
+  return nextSection === -1 ? content.slice(start) : content.slice(start, start + nextSection);
+}
+function hasCargoDep(depsSection, dep) {
+  const escaped = dep.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`(?:^|\\s)${escaped}(?:\\s*=|\\s*\\{)`, "m");
+  return pattern.test(depsSection);
+}
 function getPythonDepsContent(dir) {
   const files = ["requirements.txt", "pyproject.toml", "setup.py"];
   const parts = [];
@@ -155,6 +217,24 @@ function detectAppType(dir, stack) {
     }
     return "generic";
   }
+  if (stack === "rust") {
+    const cargoContent = readTextSafe(join(dir, "Cargo.toml"));
+    if (!cargoContent) return "generic";
+    const depsSection = getCargoDepsSection(cargoContent);
+    if (RUST_AGENT_DEPS.some((d) => hasCargoDep(depsSection, d))) {
+      return "agent";
+    }
+    if (RUST_WEB_FRAMEWORKS.some((d) => hasCargoDep(depsSection, d))) {
+      return "server";
+    }
+    if (/^\[\[bin\]\]\s*$/m.test(cargoContent)) {
+      return "cli";
+    }
+    if (/^\[lib\]\s*$/m.test(cargoContent)) {
+      return "generic";
+    }
+    return "generic";
+  }
   return "generic";
 }
 
@@ -162,14 +242,35 @@ function detectAppType(dir, stack) {
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
 import { join as join2 } from "path";
 import { parse, stringify } from "yaml";
+function migrateState(state) {
+  const raw = state;
+  if (Array.isArray(raw.stacks) && raw.stacks.length > 0) {
+    state.stacks = raw.stacks;
+    state.stack = state.stacks[0] ?? null;
+    return state;
+  }
+  if (typeof raw.stack === "string" && raw.stack) {
+    state.stacks = [raw.stack];
+    return state;
+  }
+  state.stacks = [];
+  state.stack = null;
+  return state;
+}
 var STATE_DIR = ".claude";
 var STATE_FILE = "codeharness.local.md";
 var DEFAULT_BODY = "\n# Codeharness State\n\nThis file is managed by the codeharness CLI. Do not edit manually.\n";
+function getDefaultCoverageTool(stack) {
+  if (stack === "python") return "coverage.py";
+  if (stack === "rust") return "cargo-tarpaulin";
+  return "c8";
+}
 function getDefaultState(stack) {
   return {
     harness_version: "0.1.0",
     initialized: false,
     stack: stack ?? null,
+    stacks: stack ? [stack] : [],
     enforcement: {
       frontend: true,
       database: true,
@@ -179,7 +280,7 @@ function getDefaultState(stack) {
       target: 90,
       baseline: null,
       current: null,
-      tool: "c8"
+      tool: getDefaultCoverageTool(stack)
     },
     session_flags: {
       logs_queried: false,
@@ -197,7 +298,11 @@ function writeState(state, dir, body) {
   const baseDir = dir ?? process.cwd();
   const claudeDir = join2(baseDir, STATE_DIR);
   mkdirSync(claudeDir, { recursive: true });
-  const yamlContent = stringify(state, { nullStr: "null" });
+  const toWrite = { ...state };
+  if (toWrite.stacks && toWrite.stacks.length > 0) {
+    toWrite.stack = toWrite.stacks[0];
+  }
+  const yamlContent = stringify(toWrite, { nullStr: "null" });
   const markdownBody = body ?? DEFAULT_BODY;
   const fileContent = `---
 ${yamlContent}---
@@ -220,7 +325,7 @@ function readState(dir) {
     if (!isValidState(state)) {
       return recoverCorruptedState(baseDir);
     }
-    return state;
+    return migrateState(state);
   } catch {
     return recoverCorruptedState(baseDir);
   }
@@ -244,7 +349,7 @@ function readStateWithBody(dir) {
       return { state: recovered, body: DEFAULT_BODY };
     }
     const body = parts.slice(2).join("---");
-    return { state, body: body || DEFAULT_BODY };
+    return { state: migrateState(state), body: body || DEFAULT_BODY };
   } catch {
     const state = recoverCorruptedState(baseDir);
     return { state, body: DEFAULT_BODY };
@@ -260,12 +365,20 @@ function isValidState(state) {
   if (!s.coverage || typeof s.coverage !== "object") return false;
   if (!s.session_flags || typeof s.session_flags !== "object") return false;
   if (!Array.isArray(s.verification_log)) return false;
+  if (s.stacks !== void 0 && !Array.isArray(s.stacks)) return false;
+  if (Array.isArray(s.stacks) && s.stacks.some((v) => typeof v !== "string")) return false;
   return true;
 }
 function recoverCorruptedState(dir) {
   warn("State file corrupted \u2014 recreating from detected config");
   const stack = detectStack(dir);
+  const allStacks = detectStacks(dir);
   const state = getDefaultState(stack);
+  const uniqueStackNames = [...new Set(allStacks.map((s) => s.stack))];
+  state.stacks = uniqueStackNames;
+  if (state.stack === null && uniqueStackNames.length > 0) {
+    state.stack = uniqueStackNames[0];
+  }
   writeState(state, dir);
   return state;
 }
@@ -332,6 +445,12 @@ var PYTHON_OTLP_PACKAGES = [
   "opentelemetry-distro",
   "opentelemetry-exporter-otlp"
 ];
+var RUST_OTLP_PACKAGES = [
+  "opentelemetry",
+  "opentelemetry-otlp",
+  "tracing-opentelemetry",
+  "tracing-subscriber"
+];
 var WEB_OTLP_PACKAGES = [
   "@opentelemetry/sdk-trace-web",
   "@opentelemetry/instrumentation-fetch",
@@ -423,6 +542,26 @@ function installPythonOtlp(projectDir) {
     error: "Failed to install Python OTLP packages"
   };
 }
+function installRustOtlp(projectDir) {
+  try {
+    execFileSync("cargo", ["add", ...RUST_OTLP_PACKAGES], { cwd: projectDir, stdio: "pipe", timeout: 3e5 });
+    return {
+      status: "configured",
+      packages_installed: true,
+      start_script_patched: false,
+      env_vars_configured: false
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown error";
+    return {
+      status: "failed",
+      packages_installed: false,
+      start_script_patched: false,
+      env_vars_configured: false,
+      error: `Failed to install Rust OTLP packages: ${truncateError(message)}`
+    };
+  }
+}
 function configureCli(projectDir) {
   const { state, body } = readStateWithBody(projectDir);
   if (!state.otlp) return;
@@ -496,6 +635,9 @@ function configureAgent(projectDir, stack) {
       } catch {
       }
     }
+  } else if (stack === "rust") {
+    info("Rust agent SDK not yet supported \u2014 skipping agent configuration");
+    return;
   }
   const { state, body } = readStateWithBody(projectDir);
   if (state.otlp) {
@@ -521,6 +663,23 @@ function ensureServiceNameEnvVar(projectDir, serviceName) {
     writeFileSync2(envFilePath, envLine + "\n", "utf-8");
   }
 }
+function ensureEndpointEnvVar(projectDir, endpoint) {
+  const envFilePath = join3(projectDir, ".env.codeharness");
+  const envLine = `OTEL_EXPORTER_OTLP_ENDPOINT=${endpoint}`;
+  if (existsSync3(envFilePath)) {
+    const content = readFileSync3(envFilePath, "utf-8");
+    const lines = content.split("\n").filter((l, i, arr) => i < arr.length - 1 || l.trim() !== "");
+    const idx = lines.findIndex((l) => l.startsWith("OTEL_EXPORTER_OTLP_ENDPOINT="));
+    if (idx !== -1) {
+      lines[idx] = envLine;
+    } else {
+      lines.push(envLine);
+    }
+    writeFileSync2(envFilePath, lines.join("\n") + "\n", "utf-8");
+  } else {
+    writeFileSync2(envFilePath, envLine + "\n", "utf-8");
+  }
+}
 function configureOtlpEnvVars(projectDir, stack, opts) {
   const projectName = basename(projectDir);
   const { state, body } = readStateWithBody(projectDir);
@@ -530,11 +689,15 @@ function configureOtlpEnvVars(projectDir, stack, opts) {
     service_name: projectName,
     mode: state.otlp?.mode ?? "local-shared",
     ...stack === "nodejs" ? { node_require: NODE_REQUIRE_FLAG } : {},
-    ...stack === "python" ? { python_wrapper: "opentelemetry-instrument" } : {}
+    ...stack === "python" ? { python_wrapper: "opentelemetry-instrument" } : {},
+    ...stack === "rust" ? { rust_env_hint: "OTEL_EXPORTER_OTLP_ENDPOINT" } : {}
   };
   state.otlp.resource_attributes = "service.instance.id=$(hostname)-$$";
   writeState(state, projectDir, body);
   ensureServiceNameEnvVar(projectDir, projectName);
+  if (stack === "rust") {
+    ensureEndpointEnvVar(projectDir, state.otlp.endpoint);
+  }
 }
 function instrumentProject(projectDir, stack, opts) {
   const isJson = opts?.json === true;
@@ -560,6 +723,11 @@ function instrumentProject(projectDir, stack, opts) {
       ok("OTLP: Python packages installed");
       info("OTLP: wrap your command with: opentelemetry-instrument <command>");
     }
+  } else if (stack === "rust") {
+    result = installRustOtlp(projectDir);
+    if (result.status === "configured" && !isJson) {
+      ok("OTLP: Rust packages installed");
+    }
   } else {
     return {
       status: "skipped",
@@ -861,6 +1029,33 @@ var DEPENDENCY_REGISTRY = [
     ],
     checkCommand: { cmd: "bd", args: ["--version"] },
     critical: false
+  },
+  {
+    name: "semgrep",
+    displayName: "Semgrep",
+    installCommands: [
+      { cmd: "pipx", args: ["install", "semgrep"] },
+      { cmd: "pip", args: ["install", "semgrep"] }
+    ],
+    checkCommand: { cmd: "semgrep", args: ["--version"] },
+    critical: false
+  },
+  {
+    name: "bats",
+    displayName: "BATS",
+    installCommands: [
+      { cmd: "brew", args: ["install", "bats-core"] },
+      { cmd: "npm", args: ["install", "-g", "bats"] }
+    ],
+    checkCommand: { cmd: "bats", args: ["--version"] },
+    critical: false
+  },
+  {
+    name: "cargo-tarpaulin",
+    displayName: "cargo-tarpaulin",
+    installCommands: [{ cmd: "cargo", args: ["install", "cargo-tarpaulin"] }],
+    checkCommand: { cmd: "cargo", args: ["tarpaulin", "--version"] },
+    critical: false
   }
 ];
 function checkInstalled(spec) {
@@ -1138,7 +1333,7 @@ var PATCH_TEMPLATES = {
 
 // src/lib/beads.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { existsSync as existsSync5, readdirSync } from "fs";
+import { existsSync as existsSync5, readdirSync as readdirSync2 } from "fs";
 import { join as join5 } from "path";
 var BeadsError = class extends Error {
   constructor(command, originalMessage) {
@@ -1228,7 +1423,7 @@ function detectBeadsHooks(dir) {
     return { hasHooks: false, hookTypes: [] };
   }
   try {
-    const entries = readdirSync(hooksDir);
+    const entries = readdirSync2(hooksDir);
     const hookTypes = entries.filter((e) => !e.startsWith("."));
     return {
       hasHooks: hookTypes.length > 0,
@@ -1776,9 +1971,15 @@ function readmeTemplate(config) {
   return lines.join("\n");
 }
 function getInstallCommand(stack) {
-  if (stack === "python") {
-    return "pip install codeharness";
+  if (Array.isArray(stack)) {
+    const commands = stack.map((s) => getSingleInstallCommand(s));
+    return [...new Set(commands)].join("\n");
   }
+  return getSingleInstallCommand(stack);
+}
+function getSingleInstallCommand(stack) {
+  if (stack === "python") return "pip install codeharness";
+  if (stack === "rust") return "cargo install codeharness";
   return "npm install -g codeharness";
 }
 
@@ -1795,20 +1996,46 @@ function getProjectName(projectDir) {
     }
   } catch {
   }
+  try {
+    const cargoPath = join7(projectDir, "Cargo.toml");
+    if (existsSync7(cargoPath)) {
+      const content = readFileSync7(cargoPath, "utf-8");
+      const packageMatch = content.match(/\[package\]([\s\S]*?)(?=\n\[|$)/s);
+      if (packageMatch) {
+        const nameMatch = packageMatch[1].match(/^\s*name\s*=\s*["']([^"']+)["']/m);
+        if (nameMatch) {
+          return nameMatch[1];
+        }
+      }
+    }
+  } catch {
+  }
   return basename2(projectDir);
 }
 function getStackLabel(stack) {
+  if (Array.isArray(stack)) {
+    if (stack.length === 0) return "Unknown";
+    return stack.map((s) => getStackLabel(s)).join(" + ");
+  }
   if (stack === "nodejs") return "Node.js (package.json)";
   if (stack === "python") return "Python";
+  if (stack === "rust") return "Rust (Cargo.toml)";
   return "Unknown";
 }
 function getCoverageTool(stack) {
   if (stack === "python") return "coverage.py";
+  if (stack === "rust") return "cargo-tarpaulin";
   return "c8";
 }
 function generateAgentsMdContent(projectDir, stack) {
+  if (Array.isArray(stack) && stack.length > 1) {
+    return generateMultiStackAgentsMd(projectDir, stack);
+  }
+  if (Array.isArray(stack)) {
+    stack = stack.length === 1 ? stack[0].stack : null;
+  }
   const projectName = basename2(projectDir);
-  const stackLabel = stack === "nodejs" ? "Node.js" : stack === "python" ? "Python" : "Unknown";
+  const stackLabel = stack === "nodejs" ? "Node.js" : stack === "python" ? "Python" : stack === "rust" ? "Rust" : "Unknown";
   const lines = [
     `# ${projectName}`,
     "",
@@ -1834,6 +2061,14 @@ function generateAgentsMdContent(projectDir, stack) {
       "python -m pytest                 # Run tests",
       "```"
     );
+  } else if (stack === "rust") {
+    lines.push(
+      "```bash",
+      "cargo build    # Build the project",
+      "cargo test     # Run tests",
+      "cargo tarpaulin --out json  # Run coverage",
+      "```"
+    );
   } else {
     lines.push("```bash", "# No recognized stack \u2014 add build/test commands here", "```");
   }
@@ -1858,6 +2093,70 @@ function generateAgentsMdContent(projectDir, stack) {
   );
   return lines.join("\n");
 }
+function stackDisplayName(stack) {
+  if (stack === "nodejs") return "Node.js";
+  if (stack === "python") return "Python";
+  if (stack === "rust") return "Rust";
+  return "Unknown";
+}
+function generateMultiStackAgentsMd(projectDir, stacks) {
+  const projectName = basename2(projectDir);
+  const stackNames = stacks.map((s) => stackDisplayName(s.stack));
+  const lines = [
+    `# ${projectName}`,
+    "",
+    "## Stack",
+    "",
+    `- **Language/Runtime:** ${stackNames.join(" + ")}`,
+    "",
+    "## Build & Test Commands",
+    ""
+  ];
+  for (const detection of stacks) {
+    const label = stackDisplayName(detection.stack);
+    const heading = detection.dir === "." ? `### ${label}` : `### ${label} (${detection.dir}/)`;
+    const prefix = detection.dir === "." ? "" : `cd ${detection.dir} && `;
+    lines.push(heading, "", "```bash");
+    if (detection.stack === "nodejs") {
+      lines.push(
+        `${prefix}npm install    # Install dependencies`,
+        `${prefix}npm run build  # Build the project`,
+        `${prefix}npm test       # Run tests`
+      );
+    } else if (detection.stack === "python") {
+      lines.push(
+        `${prefix}pip install -r requirements.txt  # Install dependencies`,
+        `${prefix}python -m pytest                 # Run tests`
+      );
+    } else if (detection.stack === "rust") {
+      lines.push(
+        `${prefix}cargo build    # Build the project`,
+        `${prefix}cargo test     # Run tests`,
+        `${prefix}cargo tarpaulin --out json  # Run coverage`
+      );
+    }
+    lines.push("```", "");
+  }
+  lines.push(
+    "## Project Structure",
+    "",
+    "```",
+    `${projectName}/`,
+    "\u251C\u2500\u2500 src/           # Source code",
+    "\u251C\u2500\u2500 tests/         # Test files",
+    "\u251C\u2500\u2500 docs/          # Documentation",
+    "\u2514\u2500\u2500 .claude/       # Codeharness state",
+    "```",
+    "",
+    "## Conventions",
+    "",
+    "- All changes must pass tests before commit",
+    "- Maintain test coverage targets",
+    "- Follow existing code style and patterns",
+    ""
+  );
+  return lines.join("\n");
+}
 function generateDocsIndexContent() {
   return [
     "# Project Documentation",
@@ -1884,7 +2183,8 @@ async function scaffoldDocs(opts) {
     let readme = "skipped";
     const agentsMdPath = join7(opts.projectDir, "AGENTS.md");
     if (!existsSync7(agentsMdPath)) {
-      const content = generateAgentsMdContent(opts.projectDir, opts.stack);
+      const stackArg = opts.stacks && opts.stacks.length > 1 ? opts.stacks : opts.stack;
+      const content = generateAgentsMdContent(opts.projectDir, stackArg);
       generateFile(agentsMdPath, content);
       agentsMd = "created";
     } else {
@@ -1913,9 +2213,10 @@ async function scaffoldDocs(opts) {
       } catch {
         cliHelpOutput = "Run: codeharness --help";
       }
+      const readmeStack = opts.stacks && opts.stacks.length > 1 ? opts.stacks.map((s) => s.stack) : opts.stack;
       const readmeContent = readmeTemplate({
         projectName: getProjectName(opts.projectDir),
-        stack: opts.stack,
+        stack: readmeStack,
         cliHelpOutput
       });
       generateFile(readmePath, readmeContent);
@@ -1939,12 +2240,209 @@ async function scaffoldDocs(opts) {
   }
 }
 
+// src/modules/infra/dockerfile-template.ts
+import { existsSync as existsSync8, writeFileSync as writeFileSync5 } from "fs";
+import { join as join8 } from "path";
+function nodejsTemplate() {
+  return `# Base image \u2014 pinned version for reproducibility
+FROM node:22-slim
+
+ARG TARBALL=package.tgz
+
+# System utilities for verification
+RUN apt-get update && apt-get install -y --no-install-recommends curl jq && rm -rf /var/lib/apt/lists/*
+
+# Install project from tarball (black-box: no source code)
+COPY \${TARBALL} /tmp/\${TARBALL}
+RUN npm install -g /tmp/\${TARBALL} && rm /tmp/\${TARBALL}
+
+# Run as non-root user
+USER node
+
+WORKDIR /workspace
+`;
+}
+function pythonTemplate() {
+  return `# Base image \u2014 pinned version for reproducibility
+FROM python:3.12-slim
+
+# System utilities for verification
+RUN apt-get update && apt-get install -y --no-install-recommends curl jq && rm -rf /var/lib/apt/lists/*
+
+# Install project from wheel or sdist
+COPY dist/ /tmp/dist/
+RUN pip install /tmp/dist/*.whl && rm -rf /tmp/dist/ && pip cache purge
+
+# Run as non-root user
+USER nobody
+
+WORKDIR /workspace
+`;
+}
+function rustTemplate() {
+  return `# === Builder stage ===
+FROM rust:1.82-slim AS builder
+
+WORKDIR /build
+
+# Copy project files
+COPY . .
+
+# Build release binary
+RUN cargo build --release
+
+# === Runtime stage ===
+FROM debian:bookworm-slim
+
+# System utilities for verification
+RUN apt-get update && apt-get install -y --no-install-recommends curl jq && rm -rf /var/lib/apt/lists/*
+
+# Install compiled binary from builder (update 'myapp' to your binary name)
+COPY --from=builder /build/target/release/myapp /usr/local/bin/myapp
+
+# Run as non-root user
+USER nobody
+
+WORKDIR /workspace
+`;
+}
+function genericTemplate() {
+  return `# Base image \u2014 pinned version for reproducibility
+FROM node:22-slim
+
+# System utilities for verification
+RUN apt-get update && apt-get install -y --no-install-recommends bash curl jq git && rm -rf /var/lib/apt/lists/*
+
+# Install project binary (update this for your project)
+RUN npm install -g placeholder && npm cache clean --force
+
+# Run as non-root user
+USER node
+
+WORKDIR /workspace
+`;
+}
+function nodejsBuildStage() {
+  return `# === Build stage: nodejs ===
+FROM node:22-slim AS build-nodejs
+WORKDIR /build
+COPY package*.json ./
+RUN npm ci --production
+COPY . .
+`;
+}
+function pythonBuildStage() {
+  return `# === Build stage: python ===
+FROM python:3.12-slim AS build-python
+WORKDIR /build
+COPY . .
+RUN pip install --target=/build/dist .
+`;
+}
+function rustBuildStage() {
+  return `# === Build stage: rust ===
+FROM rust:1.82-slim AS build-rust
+WORKDIR /build
+COPY . .
+RUN cargo build --release
+`;
+}
+function runtimeCopyDirectives(stacks) {
+  const lines = [];
+  for (const stack of stacks) {
+    if (stack === "nodejs") {
+      lines.push("COPY --from=build-nodejs /build/node_modules ./node_modules");
+      lines.push("COPY --from=build-nodejs /build/ ./app/");
+    } else if (stack === "python") {
+      lines.push("COPY --from=build-python /build/dist /opt/app/python/");
+    } else if (stack === "rust") {
+      lines.push("COPY --from=build-rust /build/target/release/myapp /usr/local/bin/myapp");
+    }
+  }
+  return lines.join("\n");
+}
+var MULTI_STAGE_STACKS = /* @__PURE__ */ new Set(["nodejs", "python", "rust"]);
+function multiStageTemplate(detections) {
+  const supported = detections.filter((d) => MULTI_STAGE_STACKS.has(d.stack));
+  if (supported.length === 0) {
+    return genericTemplate();
+  }
+  const buildStages = [];
+  const stacks = supported.map((d) => d.stack);
+  for (const stack of stacks) {
+    if (stack === "nodejs") buildStages.push(nodejsBuildStage());
+    else if (stack === "python") buildStages.push(pythonBuildStage());
+    else if (stack === "rust") buildStages.push(rustBuildStage());
+  }
+  const copyLines = runtimeCopyDirectives(stacks);
+  return `# NOTE: Customize COPY paths for your monorepo layout. Each build stage should only copy its own sources.
+${buildStages.join("\n")}
+# === Runtime stage ===
+FROM debian:bookworm-slim
+
+# System utilities for verification
+RUN apt-get update && apt-get install -y --no-install-recommends curl jq && rm -rf /var/lib/apt/lists/*
+
+# Install artifacts from build stages
+${copyLines}
+
+# Run as non-root user
+USER nobody
+
+WORKDIR /workspace
+`;
+}
+function generateDockerfileTemplate(projectDir, stackOrDetections) {
+  if (!projectDir) {
+    return fail2("projectDir is required");
+  }
+  const dockerfilePath = join8(projectDir, "Dockerfile");
+  if (existsSync8(dockerfilePath)) {
+    return fail2("Dockerfile already exists");
+  }
+  if (Array.isArray(stackOrDetections) && stackOrDetections.length > 1) {
+    const content2 = multiStageTemplate(stackOrDetections);
+    const stacks = stackOrDetections.map((d) => d.stack);
+    try {
+      writeFileSync5(dockerfilePath, content2, "utf-8");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return fail2(`Failed to write Dockerfile: ${message}`);
+    }
+    return ok2({ path: dockerfilePath, stack: stacks[0], stacks });
+  }
+  const stack = Array.isArray(stackOrDetections) ? stackOrDetections.length === 1 ? stackOrDetections[0].stack : null : stackOrDetections;
+  let content;
+  let resolvedStack;
+  if (stack === "nodejs") {
+    content = nodejsTemplate();
+    resolvedStack = "nodejs";
+  } else if (stack === "python") {
+    content = pythonTemplate();
+    resolvedStack = "python";
+  } else if (stack === "rust") {
+    content = rustTemplate();
+    resolvedStack = "rust";
+  } else {
+    content = genericTemplate();
+    resolvedStack = "generic";
+  }
+  try {
+    writeFileSync5(dockerfilePath, content, "utf-8");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return fail2(`Failed to write Dockerfile: ${message}`);
+  }
+  return ok2({ path: dockerfilePath, stack: resolvedStack, stacks: [resolvedStack] });
+}
+
 // src/modules/infra/init-project.ts
-var HARNESS_VERSION = true ? "0.23.0" : "0.0.0-dev";
+var HARNESS_VERSION = true ? "0.24.1" : "0.0.0-dev";
 function failResult(opts, error) {
   return {
     status: "fail",
     stack: null,
+    stacks: [],
     error,
     enforcement: { frontend: opts.frontend, database: opts.database, api: opts.api },
     documentation: { agents_md: "skipped", docs_scaffold: "skipped", readme: "skipped" }
@@ -1971,6 +2469,7 @@ async function initProjectInner(opts) {
   const result = {
     status: "ok",
     stack: null,
+    stacks: [],
     enforcement: { frontend: opts.frontend, database: opts.database, api: opts.api },
     documentation: { agents_md: "skipped", docs_scaffold: "skipped", readme: "skipped" }
   };
@@ -1981,14 +2480,29 @@ async function initProjectInner(opts) {
     emitError(urlError, isJson);
     return ok2(failResult(opts, urlError));
   }
-  const stack = detectStack(projectDir);
+  const allStacks = detectStacks(projectDir);
+  const rootDetection = allStacks.find((s) => s.dir === ".");
+  const stack = rootDetection ? rootDetection.stack : null;
+  if (!stack && !isJson) warn("No recognized stack detected");
   result.stack = stack;
+  result.stacks = [...new Set(allStacks.map((s) => s.stack))];
   const appType = detectAppType(projectDir, stack);
   result.app_type = appType;
   if (!isJson) {
-    if (stack) info(`Stack detected: ${getStackLabel(stack)}`);
+    if (result.stacks.length > 0) {
+      info(`Stack detected: ${getStackLabel(result.stacks)}`);
+    } else if (stack) {
+      info(`Stack detected: ${getStackLabel(stack)}`);
+    }
     info(`App type: ${appType}`);
   }
+  const dfResult = generateDockerfileTemplate(projectDir, allStacks);
+  if (isOk(dfResult)) {
+    result.dockerfile = { generated: true, stack: dfResult.data.stack, stacks: dfResult.data.stacks };
+    if (!isJson) info(`Generated Dockerfile for ${dfResult.data.stacks.join("+") || dfResult.data.stack} project.`);
+  } else {
+    if (!isJson) info("Dockerfile already exists -- skipping template generation.");
+  }
   const dockerCheck = checkDocker({ observability: opts.observability, otelEndpoint: opts.otelEndpoint, logsUrl: opts.logsUrl, opensearchUrl: opts.opensearchUrl, isJson });
   if (!isOk(dockerCheck)) return fail2(dockerCheck.error);
   const { available: dockerAvailable, criticalFailure, dockerResult: criticalDockerResult } = dockerCheck.data;
@@ -2027,16 +2541,31 @@ async function initProjectInner(opts) {
   state.initialized = true;
   state.app_type = appType;
   state.enforcement = { frontend: opts.frontend, database: opts.database, api: opts.api };
+  const coverageTools = {};
+  for (const detection of allStacks) {
+    coverageTools[detection.stack] = getCoverageTool(detection.stack);
+  }
   state.coverage.tool = getCoverageTool(stack);
+  state.coverage.tools = coverageTools;
+  state.stacks = result.stacks;
   writeState(state, projectDir);
   if (!isJson) ok("State file: .claude/codeharness.local.md created");
-  const docsResult = await scaffoldDocs({ projectDir, stack, isJson });
+  const docsResult = await scaffoldDocs({ projectDir, stack, stacks: allStacks, isJson });
   if (isOk(docsResult)) result.documentation = docsResult.data;
   if (!opts.observability) {
     result.otlp = { status: "skipped", packages_installed: false, start_script_patched: false, env_vars_configured: false };
     if (!isJson) info("OTLP: skipped (--no-observability)");
   } else {
-    result.otlp = instrumentProject(projectDir, stack, { json: isJson, appType });
+    for (const detection of allStacks) {
+      const stackDir = detection.dir === "." ? projectDir : join9(projectDir, detection.dir);
+      const stackOtlp = instrumentProject(stackDir, detection.stack, { json: isJson, appType });
+      if (detection.dir === "." && detection.stack === stack) {
+        result.otlp = stackOtlp;
+      }
+    }
+    if (!result.otlp) {
+      result.otlp = instrumentProject(projectDir, stack, { json: isJson, appType });
+    }
   }
   try {
     const u = readState(projectDir);
@@ -2071,7 +2600,7 @@ async function initProjectInner(opts) {
 }
 function handleRerun(opts, result) {
   const { projectDir, json: isJson = false } = opts;
-  if (!existsSync8(getStatePath(projectDir))) return null;
+  if (!existsSync9(getStatePath(projectDir))) return null;
   try {
     const existingState = readState(projectDir);
     const legacyObsDisabled = existingState.enforcement.observability === false;
@@ -2080,6 +2609,7 @@ function handleRerun(opts, result) {
       return null;
     }
     result.stack = existingState.stack;
+    result.stacks = existingState.stacks ?? [];
     result.enforcement = existingState.enforcement;
     result.documentation = { agents_md: "exists", docs_scaffold: "exists", readme: "exists" };
     result.dependencies = verifyDeps(isJson);
@@ -2123,6 +2653,136 @@ var DEFAULT_LOGS_URL = `http://localhost:${DEFAULT_PORTS.logs}`;
 var DEFAULT_METRICS_URL = `http://localhost:${DEFAULT_PORTS.metrics}`;
 var DEFAULT_TRACES_URL = `http://localhost:${DEFAULT_PORTS.traces}`;
 
+// src/modules/infra/dockerfile-validator.ts
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { join as join10 } from "path";
+var DEFAULT_RULES = {
+  requirePinnedFrom: true,
+  requireBinaryOnPath: true,
+  verificationTools: ["curl", "jq"],
+  forbidSourceCopy: true,
+  requireNonRootUser: true,
+  requireCacheCleanup: true
+};
+function dfGap(rule, description, suggestedFix, line) {
+  const g = { rule, description, suggestedFix };
+  if (line !== void 0) return { ...g, line };
+  return g;
+}
+function loadRules(projectDir) {
+  const rulesPath = join10(projectDir, "patches", "infra", "dockerfile-rules.md");
+  if (!existsSync10(rulesPath)) {
+    return {
+      rules: DEFAULT_RULES,
+      warnings: ["dockerfile-rules.md not found -- using defaults."]
+    };
+  }
+  return { rules: DEFAULT_RULES, warnings: [] };
+}
+function checkPinnedFrom(lines) {
+  const gaps = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (!/^\s*FROM\s+/i.test(lines[i])) continue;
+    const ref = lines[i].replace(/^\s*FROM\s+/i, "").split(/\s+/)[0];
+    if (ref.endsWith(":latest")) {
+      gaps.push(dfGap("pinned-from", `unpinned base image -- use specific version.`, `Pin ${ref} to a specific version tag`, i + 1));
+    } else if (!ref.includes(":") && !ref.includes("@")) {
+      gaps.push(dfGap("pinned-from", `unpinned base image -- use specific version.`, `Pin ${ref} to a specific version tag (e.g., ${ref}:22-slim)`, i + 1));
+    }
+  }
+  return gaps;
+}
+function checkBinaryOnPath(lines) {
+  const content = lines.join("\n");
+  const hasBinary = /npm\s+install\s+(-g|--global)\b/i.test(content) || /pip\s+install\b/i.test(content) || /COPY\s+--from=/i.test(content);
+  if (!hasBinary) {
+    return [dfGap("binary-on-path", "project binary not installed.", "Add npm install -g, pip install, or COPY --from to install the project binary")];
+  }
+  return [];
+}
+function checkVerificationTools(lines, tools) {
+  const gaps = [];
+  for (const tool of tools) {
+    let found = false;
+    for (const line of lines) {
+      const lower = line.toLowerCase();
+      const isInstallLine = lower.includes("apt-get install") || lower.includes("apk add");
+      if (isInstallLine && new RegExp(`\\b${tool.toLowerCase()}\\b`).test(lower)) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      gaps.push(dfGap("verification-tools", `verification tool missing: ${tool}`, `Install ${tool} via apt-get install or apk add`));
+    }
+  }
+  return gaps;
+}
+function checkNoSourceCopy(lines) {
+  const gaps = [];
+  const sourcePatterns = [/COPY\s+(?:--\S+\s+)*src\//i, /COPY\s+(?:--\S+\s+)*lib\//i, /COPY\s+(?:--\S+\s+)*test\//i];
+  for (let i = 0; i < lines.length; i++) {
+    for (const pattern of sourcePatterns) {
+      if (pattern.test(lines[i])) {
+        gaps.push(dfGap("no-source-copy", "source code copied into container -- use build artifact instead.", "Use COPY --from=builder or COPY dist/ instead of copying source", i + 1));
+      }
+    }
+  }
+  return gaps;
+}
+function checkNonRootUser(lines) {
+  const userLines = lines.filter((l) => /^\s*USER\s+/i.test(l));
+  if (userLines.length === 0) {
+    return [dfGap("non-root-user", "no non-root USER instruction found.", "Add USER <non-root-user> instruction (e.g., USER node)")];
+  }
+  const hasNonRoot = userLines.some((l) => {
+    const user = l.replace(/^\s*USER\s+/i, "").trim().split(/\s+/)[0];
+    return user.toLowerCase() !== "root";
+  });
+  if (!hasNonRoot) {
+    return [dfGap("non-root-user", "no non-root USER instruction found.", "Add USER <non-root-user> instruction (e.g., USER node)")];
+  }
+  return [];
+}
+function checkCacheCleanup(lines) {
+  const content = lines.join("\n");
+  const hasCleanup = /rm\s+-rf\s+\/var\/lib\/apt\/lists/i.test(content) || /rm\s+-rf\s+\/var\/cache\/apk/i.test(content) || /npm\s+cache\s+clean/i.test(content) || /pip\s+cache\s+purge/i.test(content);
+  if (!hasCleanup) {
+    return [dfGap("cache-cleanup", "no cache cleanup detected.", "Add cache cleanup: rm -rf /var/lib/apt/lists/*, npm cache clean --force, or pip cache purge")];
+  }
+  return [];
+}
+function validateDockerfile(projectDir) {
+  const dfPath = join10(projectDir, "Dockerfile");
+  if (!existsSync10(dfPath)) {
+    return fail2("No Dockerfile found");
+  }
+  let content;
+  try {
+    content = readFileSync8(dfPath, "utf-8");
+  } catch {
+    return fail2("Dockerfile exists but could not be read");
+  }
+  const lines = content.split("\n");
+  const fromLines = lines.filter((l) => /^\s*FROM\s+/i.test(l));
+  if (fromLines.length === 0) {
+    return fail2("Dockerfile has no FROM instruction");
+  }
+  const { rules, warnings } = loadRules(projectDir);
+  const gaps = [];
+  if (rules.requirePinnedFrom) gaps.push(...checkPinnedFrom(lines));
+  if (rules.requireBinaryOnPath) gaps.push(...checkBinaryOnPath(lines));
+  gaps.push(...checkVerificationTools(lines, rules.verificationTools));
+  if (rules.forbidSourceCopy) gaps.push(...checkNoSourceCopy(lines));
+  if (rules.requireNonRootUser) gaps.push(...checkNonRootUser(lines));
+  if (rules.requireCacheCleanup) gaps.push(...checkCacheCleanup(lines));
+  return ok2({
+    passed: gaps.length === 0,
+    gaps,
+    warnings
+  });
+}
+
 // src/modules/infra/index.ts
 async function initProject2(opts) {
   return initProject(opts);
@@ -2156,7 +2816,7 @@ function registerInitCommand(program) {
 }
 
 // src/commands/bridge.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 function registerBridgeCommand(program) {
   program.command("bridge").description("Bridge BMAD epics/stories into beads task store").option("--epics <path>", "Path to BMAD epics markdown file").option("--dry-run", "Parse and display without creating beads issues").action((opts, cmd) => {
     const globalOpts = cmd.optsWithGlobals();
@@ -2168,7 +2828,7 @@ function registerBridgeCommand(program) {
       process.exitCode = 2;
       return;
     }
-    if (!existsSync9(epicsPath)) {
+    if (!existsSync11(epicsPath)) {
       fail(`Epics file not found: ${epicsPath}`, { json: isJson });
       process.exitCode = 1;
       return;
@@ -2241,14 +2901,13 @@ function registerBridgeCommand(program) {
 
 // src/commands/run.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync16, mkdirSync as mkdirSync4, readFileSync as readFileSync14, writeFileSync as writeFileSync9 } from "fs";
-import { join as join13, dirname as dirname4 } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync4, readFileSync as readFileSync15, writeFileSync as writeFileSync10 } from "fs";
+import { join as join16, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { StringDecoder } from "string_decoder";
 
 // src/lib/beads-sync.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { join as join11 } from "path";
 import { parse as parse2 } from "yaml";
 var BEADS_TO_STORY_STATUS = {
   open: "in-progress",
@@ -2279,10 +2938,10 @@ function resolveStoryFilePath(beadsIssue) {
   return trimmed;
 }
 function readStoryFileStatus(filePath) {
-  if (!existsSync10(filePath)) {
+  if (!existsSync12(filePath)) {
     return null;
   }
-  const content = readFileSync8(filePath, "utf-8");
+  const content = readFileSync9(filePath, "utf-8");
   const match = content.match(/^Status:\s*(.+)$/m);
   if (!match) {
     return null;
@@ -2290,11 +2949,11 @@ function readStoryFileStatus(filePath) {
   return match[1].trim();
 }
 function updateStoryFileStatus(filePath, newStatus) {
-  const content = readFileSync8(filePath, "utf-8");
+  const content = readFileSync9(filePath, "utf-8");
   const statusRegex = /^Status:\s*.+$/m;
   if (statusRegex.test(content)) {
     const updated = content.replace(statusRegex, `Status: ${newStatus}`);
-    writeFileSync5(filePath, updated, "utf-8");
+    writeFileSync6(filePath, updated, "utf-8");
   } else {
     const lines = content.split("\n");
     const titleIndex = lines.findIndex((l) => l.startsWith("# "));
@@ -2303,18 +2962,18 @@ function updateStoryFileStatus(filePath, newStatus) {
     } else {
       lines.unshift(`Status: ${newStatus}`, "");
     }
-    writeFileSync5(filePath, lines.join("\n"), "utf-8");
+    writeFileSync6(filePath, lines.join("\n"), "utf-8");
   }
 }
 var SPRINT_STATUS_PATH = "_bmad-output/implementation-artifacts/sprint-status.yaml";
 function readSprintStatus(dir) {
   const root = dir ?? process.cwd();
-  const filePath = join8(root, SPRINT_STATUS_PATH);
-  if (!existsSync10(filePath)) {
+  const filePath = join11(root, SPRINT_STATUS_PATH);
+  if (!existsSync12(filePath)) {
     return {};
   }
   try {
-    const content = readFileSync8(filePath, "utf-8");
+    const content = readFileSync9(filePath, "utf-8");
     const parsed = parse2(content);
     if (!parsed || typeof parsed !== "object") {
       return {};
@@ -2330,18 +2989,18 @@ function readSprintStatus(dir) {
 }
 function updateSprintStatus(storyKey, newStatus, dir) {
   const root = dir ?? process.cwd();
-  const filePath = join8(root, SPRINT_STATUS_PATH);
-  if (!existsSync10(filePath)) {
+  const filePath = join11(root, SPRINT_STATUS_PATH);
+  if (!existsSync12(filePath)) {
     warn(`sprint-status.yaml not found at ${filePath}, skipping update`);
     return;
   }
-  const content = readFileSync8(filePath, "utf-8");
+  const content = readFileSync9(filePath, "utf-8");
   const keyPattern = new RegExp(`^(\\s*${escapeRegExp(storyKey)}:\\s*)\\S+(.*)$`, "m");
   if (!keyPattern.test(content)) {
     return;
   }
   const updated = content.replace(keyPattern, `$1${newStatus}$2`);
-  writeFileSync5(filePath, updated, "utf-8");
+  writeFileSync6(filePath, updated, "utf-8");
 }
 function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -2376,7 +3035,7 @@ function syncBeadsToStoryFile(beadsId, beadsFns, dir) {
     };
   }
   const storyKey = storyKeyFromPath(storyFilePath);
-  const fullPath = join8(root, storyFilePath);
+  const fullPath = join11(root, storyFilePath);
   const currentStoryStatus = readStoryFileStatus(fullPath);
   if (currentStoryStatus === null) {
     return {
@@ -2421,7 +3080,7 @@ function syncBeadsToStoryFile(beadsId, beadsFns, dir) {
 function syncStoryFileToBeads(storyKey, beadsFns, dir) {
   const root = dir ?? process.cwd();
   const storyFilePath = `_bmad-output/implementation-artifacts/${storyKey}.md`;
-  const fullPath = join8(root, storyFilePath);
+  const fullPath = join11(root, storyFilePath);
   const currentStoryStatus = readStoryFileStatus(fullPath);
   if (currentStoryStatus === null) {
     return {
@@ -2510,10 +3169,10 @@ function syncClose(beadsId, beadsFns, dir) {
     };
   }
   const storyKey = storyKeyFromPath(storyFilePath);
-  const fullPath = join8(root, storyFilePath);
+  const fullPath = join11(root, storyFilePath);
   const previousStatus = readStoryFileStatus(fullPath);
   if (previousStatus === null) {
-    if (!existsSync10(fullPath)) {
+    if (!existsSync12(fullPath)) {
       return {
         storyKey,
         beadsId,
@@ -2645,176 +3304,25 @@ function generateRalphPrompt(config) {
 
 `;
     prompt += `The following stories have exceeded the retry limit and should be skipped:
-`;
-    for (const story of config.flaggedStories) {
-      prompt += `- \`${story}\`
-`;
-    }
-  }
-  return prompt;
-}
-
-// src/lib/stream-parser.ts
-function parseStreamLine(line) {
-  const trimmed = line.trim();
-  if (trimmed.length === 0) {
-    return null;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch {
-    return null;
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    return null;
-  }
-  const wrapperType = parsed.type;
-  if (wrapperType === "stream_event") {
-    return parseStreamEvent(parsed);
-  }
-  if (wrapperType === "system") {
-    return parseSystemEvent(parsed);
-  }
-  if (wrapperType === "result") {
-    return parseResultEvent(parsed);
-  }
-  return null;
-}
-function parseStreamEvent(parsed) {
-  const event = parsed.event;
-  if (!event || typeof event !== "object") {
-    return null;
-  }
-  const eventType = event.type;
-  if (eventType === "content_block_start") {
-    return parseContentBlockStart(event);
-  }
-  if (eventType === "content_block_delta") {
-    return parseContentBlockDelta(event);
-  }
-  if (eventType === "content_block_stop") {
-    return { type: "tool-complete" };
-  }
-  return null;
-}
-function parseContentBlockStart(event) {
-  const contentBlock = event.content_block;
-  if (!contentBlock || typeof contentBlock !== "object") {
-    return null;
-  }
-  if (contentBlock.type === "tool_use") {
-    const name = contentBlock.name;
-    const id = contentBlock.id;
-    if (typeof name === "string" && typeof id === "string") {
-      return { type: "tool-start", name, id };
-    }
-  }
-  return null;
-}
-function parseContentBlockDelta(event) {
-  const delta = event.delta;
-  if (!delta || typeof delta !== "object") {
-    return null;
-  }
-  if (delta.type === "input_json_delta") {
-    const partialJson = delta.partial_json;
-    if (typeof partialJson === "string") {
-      return { type: "tool-input", partial: partialJson };
-    }
-    return null;
-  }
-  if (delta.type === "text_delta") {
-    const text = delta.text;
-    if (typeof text === "string") {
-      return { type: "text", text };
-    }
-    return null;
-  }
-  return null;
-}
-function parseSystemEvent(parsed) {
-  const subtype = parsed.subtype;
-  if (subtype === "api_retry") {
-    const attempt = parsed.attempt;
-    const delay = parsed.retry_delay_ms;
-    if (typeof attempt === "number" && typeof delay === "number") {
-      return { type: "retry", attempt, delay };
+`;
+    for (const story of config.flaggedStories) {
+      prompt += `- \`${story}\`
+`;
     }
-    return null;
-  }
-  return null;
-}
-function parseResultEvent(parsed) {
-  const costUsd = parsed.cost_usd;
-  const sessionId = parsed.session_id;
-  if (typeof costUsd === "number" && typeof sessionId === "string") {
-    return { type: "result", cost: costUsd, sessionId };
   }
-  return null;
+  return prompt;
 }
 
 // src/lib/ink-renderer.tsx
 import { render as inkRender } from "ink";
 
 // src/lib/ink-components.tsx
-import { Text, Box, Static } from "ink";
+import { Text as Text2, Box as Box3 } from "ink";
+
+// src/lib/ink-activity-components.tsx
+import { Text, Box } from "ink";
 import { Spinner } from "@inkjs/ui";
 import { jsx, jsxs } from "react/jsx-runtime";
-function Header({ info: info2 }) {
-  if (!info2) return null;
-  const pct = info2.total > 0 ? Math.round(info2.done / info2.total * 100) : 0;
-  return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [
-    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "\u25C6 " }),
-    /* @__PURE__ */ jsx(Text, { bold: true, children: info2.storyKey || "(waiting)" }),
-    /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2014 " }),
-    /* @__PURE__ */ jsx(Text, { color: "yellow", children: info2.phase || "..." }),
-    info2.elapsed && /* @__PURE__ */ jsx(Text, { dimColor: true, children: ` \u2502 ${info2.elapsed}` }),
-    /* @__PURE__ */ jsx(Text, { dimColor: true, children: " \u2502 Sprint: " }),
-    /* @__PURE__ */ jsx(Text, { bold: true, color: "green", children: info2.done }),
-    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "/" }),
-    /* @__PURE__ */ jsx(Text, { children: String(info2.total) }),
-    /* @__PURE__ */ jsx(Text, { dimColor: true, children: ` (${pct}%)` })
-  ] });
-}
-function shortKey(key) {
-  const m = key.match(/^(\d+-\d+)/);
-  return m ? m[1] : key;
-}
-function StoryBreakdown({ stories }) {
-  if (stories.length === 0) return null;
-  const groups = {};
-  for (const s of stories) {
-    if (!groups[s.status]) groups[s.status] = [];
-    groups[s.status].push(s.key);
-  }
-  return /* @__PURE__ */ jsxs(Box, { paddingX: 1, gap: 2, children: [
-    groups["done"]?.length && /* @__PURE__ */ jsxs(Text, { children: [
-      /* @__PURE__ */ jsxs(Text, { color: "green", children: [
-        groups["done"].length,
-        " \u2713"
-      ] }),
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: " done" })
-    ] }),
-    groups["in-progress"]?.map((k) => /* @__PURE__ */ jsxs(Text, { children: [
-      /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u25C6 " }),
-      /* @__PURE__ */ jsx(Text, { bold: true, children: k })
-    ] }, k)),
-    groups["pending"]?.length && /* @__PURE__ */ jsxs(Text, { children: [
-      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "next: " }),
-      /* @__PURE__ */ jsx(Text, { children: groups["pending"].slice(0, 3).map((k) => shortKey(k)).join(" ") }),
-      groups["pending"].length > 3 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: ` +${groups["pending"].length - 3}` })
-    ] }),
-    groups["failed"]?.map((k) => /* @__PURE__ */ jsx(Text, { children: /* @__PURE__ */ jsxs(Text, { color: "red", children: [
-      "\u2717 ",
-      shortKey(k)
-    ] }) }, k)),
-    groups["blocked"]?.map((k) => /* @__PURE__ */ jsx(Text, { children: /* @__PURE__ */ jsxs(Text, { color: "yellow", children: [
-      "\u2715 ",
-      shortKey(k)
-    ] }) }, k))
-  ] });
-}
 var MESSAGE_STYLE = {
   ok: { prefix: "[OK]", color: "green" },
   warn: { prefix: "[WARN]", color: "yellow" },
@@ -2873,24 +3381,159 @@ function RetryNotice({ info: info2 }) {
     "ms)"
   ] });
 }
-function App({
-  state
-}) {
-  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx(Static, { items: state.messages, children: (msg, i) => /* @__PURE__ */ jsx(StoryMessageLine, { msg }, i) }),
-    /* @__PURE__ */ jsx(Header, { info: state.sprintInfo }),
-    /* @__PURE__ */ jsx(StoryBreakdown, { stories: state.stories }),
-    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [
-      /* @__PURE__ */ jsx(CompletedTools, { tools: state.completedTools }),
-      state.activeTool && /* @__PURE__ */ jsx(ActiveTool, { name: state.activeTool.name }),
-      state.lastThought && /* @__PURE__ */ jsx(LastThought, { text: state.lastThought }),
-      state.retryInfo && /* @__PURE__ */ jsx(RetryNotice, { info: state.retryInfo })
+
+// src/lib/ink-app.tsx
+import { Box as Box2, Static } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function App({ state }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx2(Static, { items: state.messages, children: (msg, i) => /* @__PURE__ */ jsx2(StoryMessageLine, { msg }, i) }),
+    /* @__PURE__ */ jsx2(Header, { info: state.sprintInfo }),
+    /* @__PURE__ */ jsx2(StoryBreakdown, { stories: state.stories, sprintInfo: state.sprintInfo }),
+    state.stories.length > 0 && /* @__PURE__ */ jsx2(Separator, {}),
+    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", paddingLeft: 1, children: [
+      /* @__PURE__ */ jsx2(CompletedTools, { tools: state.completedTools }),
+      state.activeTool && /* @__PURE__ */ jsx2(ActiveTool, { name: state.activeTool.name }),
+      state.lastThought && /* @__PURE__ */ jsx2(LastThought, { text: state.lastThought }),
+      state.retryInfo && /* @__PURE__ */ jsx2(RetryNotice, { info: state.retryInfo })
     ] })
   ] });
 }
 
+// src/lib/ink-components.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function Separator() {
+  const width = process.stdout.columns || 60;
+  return /* @__PURE__ */ jsx3(Text2, { children: "\u2501".repeat(width) });
+}
+function shortKey(key) {
+  const m = key.match(/^(\d+-\d+)/);
+  return m ? m[1] : key;
+}
+function formatCost(cost) {
+  return `$${cost.toFixed(2)}`;
+}
+function Header({ info: info2 }) {
+  if (!info2) return null;
+  const parts = ["codeharness run"];
+  if (info2.iterationCount != null) {
+    parts.push(`iteration ${info2.iterationCount}`);
+  }
+  if (info2.elapsed) {
+    parts.push(`${info2.elapsed} elapsed`);
+  }
+  if (info2.totalCost != null) {
+    parts.push(`${formatCost(info2.totalCost)} spent`);
+  }
+  const headerLine = parts.join(" | ");
+  let phaseLine = "";
+  if (info2.phase) {
+    phaseLine = `Phase: ${info2.phase}`;
+    if (info2.acProgress) {
+      phaseLine += ` \u2192 AC ${info2.acProgress}`;
+    }
+    if (info2.currentCommand) {
+      phaseLine += ` (${info2.currentCommand})`;
+    }
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx3(Text2, { children: headerLine }),
+    /* @__PURE__ */ jsx3(Separator, {}),
+    /* @__PURE__ */ jsx3(Text2, { children: `Story: ${info2.storyKey || "(waiting)"}` }),
+    phaseLine && /* @__PURE__ */ jsx3(Text2, { children: phaseLine })
+  ] });
+}
+function StoryBreakdown({ stories, sprintInfo }) {
+  if (stories.length === 0) return null;
+  const done = [];
+  const inProgress = [];
+  const pending = [];
+  const failed = [];
+  const blocked = [];
+  for (const s of stories) {
+    switch (s.status) {
+      case "done":
+        done.push(s);
+        break;
+      case "in-progress":
+        inProgress.push(s);
+        break;
+      case "pending":
+        pending.push(s);
+        break;
+      case "failed":
+        failed.push(s);
+        break;
+      case "blocked":
+        blocked.push(s);
+        break;
+    }
+  }
+  const lines = [];
+  if (done.length > 0) {
+    const doneItems = done.map((s) => `${shortKey(s.key)} \u2713`).join("  ");
+    lines.push(
+      /* @__PURE__ */ jsxs3(Text2, { children: [
+        /* @__PURE__ */ jsx3(Text2, { color: "green", children: "Done: " }),
+        /* @__PURE__ */ jsx3(Text2, { color: "green", children: doneItems })
+      ] }, "done")
+    );
+  }
+  if (inProgress.length > 0) {
+    for (const s of inProgress) {
+      let thisText = `${shortKey(s.key)} \u25C6`;
+      if (sprintInfo && sprintInfo.storyKey && shortKey(s.key) === shortKey(sprintInfo.storyKey)) {
+        if (sprintInfo.phase) thisText += ` ${sprintInfo.phase}`;
+        if (sprintInfo.acProgress) thisText += ` (${sprintInfo.acProgress} ACs)`;
+      }
+      lines.push(
+        /* @__PURE__ */ jsxs3(Text2, { children: [
+          /* @__PURE__ */ jsx3(Text2, { color: "cyan", children: "This: " }),
+          /* @__PURE__ */ jsx3(Text2, { color: "cyan", children: thisText })
+        ] }, `this-${s.key}`)
+      );
+    }
+  }
+  if (pending.length > 0) {
+    lines.push(
+      /* @__PURE__ */ jsxs3(Text2, { children: [
+        /* @__PURE__ */ jsx3(Text2, { children: "Next: " }),
+        /* @__PURE__ */ jsx3(Text2, { children: shortKey(pending[0].key) }),
+        pending.length > 1 && /* @__PURE__ */ jsx3(Text2, { dimColor: true, children: ` (+${pending.length - 1} more)` })
+      ] }, "next")
+    );
+  }
+  if (blocked.length > 0) {
+    const blockedItems = blocked.map((s) => {
+      let item = `${shortKey(s.key)} \u2715`;
+      if (s.retryCount != null && s.maxRetries != null) item += ` (${s.retryCount}/${s.maxRetries})`;
+      return item;
+    }).join("  ");
+    lines.push(
+      /* @__PURE__ */ jsxs3(Text2, { children: [
+        /* @__PURE__ */ jsx3(Text2, { color: "yellow", children: "Blocked: " }),
+        /* @__PURE__ */ jsx3(Text2, { color: "yellow", children: blockedItems })
+      ] }, "blocked")
+    );
+  }
+  if (failed.length > 0) {
+    const failedItems = failed.map((s) => {
+      let item = `${shortKey(s.key)} \u2717`;
+      if (s.retryCount != null && s.maxRetries != null) item += ` (${s.retryCount}/${s.maxRetries})`;
+      return item;
+    }).join("  ");
+    lines.push(
+      /* @__PURE__ */ jsxs3(Text2, { children: [
+        /* @__PURE__ */ jsx3(Text2, { color: "red", children: "Failed: " }),
+        /* @__PURE__ */ jsx3(Text2, { color: "red", children: failedItems })
+      ] }, "failed")
+    );
+  }
+  return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: lines });
+}
+
 // src/lib/ink-renderer.tsx
-import { jsx as jsx2 } from "react/jsx-runtime";
+import { jsx as jsx4 } from "react/jsx-runtime";
 var noopHandle = {
   update() {
   },
@@ -2919,18 +3562,16 @@ function startRenderer(options) {
     retryInfo: null
   };
   let cleaned = false;
-  const inkInstance = inkRender(/* @__PURE__ */ jsx2(App, { state }), {
+  const inkInstance = inkRender(/* @__PURE__ */ jsx4(App, { state }), {
     exitOnCtrlC: false,
-    patchConsole: false,
+    patchConsole: !options?._forceTTY,
     incrementalRendering: true,
-    // Only redraw changed lines (v6.5+)
     maxFps: 15
-    // Dashboard doesn't need 30fps
   });
   function rerender() {
     if (!cleaned) {
       state = { ...state };
-      inkInstance.rerender(/* @__PURE__ */ jsx2(App, { state }));
+      inkInstance.rerender(/* @__PURE__ */ jsx4(App, { state }));
     }
   }
   function cleanup() {
@@ -2968,7 +3609,8 @@ function startRenderer(options) {
         break;
       case "tool-input":
         state.activeToolArgs += event.partial;
-        break;
+        return;
+      // Skip rerender — args only shown on completion
       case "tool-complete":
         if (state.activeTool) {
           const entry = {
@@ -2989,13 +3631,28 @@ function startRenderer(options) {
         state.retryInfo = { attempt: event.attempt, delay: event.delay };
         break;
       case "result":
+        if (event.cost > 0 && state.sprintInfo) {
+          state.sprintInfo = {
+            ...state.sprintInfo,
+            totalCost: (state.sprintInfo.totalCost ?? 0) + event.cost
+          };
+        }
         break;
     }
     rerender();
   }
   function updateSprintState(sprintState) {
     if (cleaned) return;
-    state.sprintInfo = sprintState ?? null;
+    if (sprintState && state.sprintInfo) {
+      state.sprintInfo = {
+        ...sprintState,
+        totalCost: sprintState.totalCost ?? state.sprintInfo.totalCost,
+        acProgress: sprintState.acProgress ?? state.sprintInfo.acProgress,
+        currentCommand: sprintState.currentCommand ?? state.sprintInfo.currentCommand
+      };
+    } else {
+      state.sprintInfo = sprintState ?? null;
+    }
     rerender();
   }
   function updateStories(stories) {
@@ -3012,12 +3669,12 @@ function startRenderer(options) {
 }
 
 // src/modules/sprint/state.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, renameSync, existsSync as existsSync12 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, renameSync, existsSync as existsSync14 } from "fs";
+import { join as join13 } from "path";
 
 // src/modules/sprint/migration.ts
-import { readFileSync as readFileSync9, existsSync as existsSync11 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync13 } from "fs";
+import { join as join12 } from "path";
 var OLD_FILES = {
   storyRetries: "ralph/.story_retries",
   flaggedStories: "ralph/.flagged_stories",
@@ -3026,13 +3683,13 @@ var OLD_FILES = {
   sessionIssues: "_bmad-output/implementation-artifacts/.session-issues.md"
 };
 function resolve(relative2) {
-  return join9(process.cwd(), relative2);
+  return join12(process.cwd(), relative2);
 }
 function readIfExists(relative2) {
   const p = resolve(relative2);
-  if (!existsSync11(p)) return null;
+  if (!existsSync13(p)) return null;
   try {
-    return readFileSync9(p, "utf-8");
+    return readFileSync10(p, "utf-8");
   } catch {
     return null;
   }
@@ -3101,7 +3758,11 @@ function parseRalphStatus(content) {
       iteration: data.loop_count ?? 0,
       cost: 0,
       completed: [],
-      failed: []
+      failed: [],
+      currentStory: null,
+      currentPhase: null,
+      lastAction: null,
+      acProgress: null
     };
   } catch {
     return null;
@@ -3132,7 +3793,7 @@ function parseSessionIssues(content) {
   return items;
 }
 function migrateFromOldFormat() {
-  const hasAnyOldFile = Object.values(OLD_FILES).some((rel) => existsSync11(resolve(rel)));
+  const hasAnyOldFile = Object.values(OLD_FILES).some((rel) => existsSync13(resolve(rel)));
   if (!hasAnyOldFile) return fail2("No old format files found for migration");
   try {
     const stories = {};
@@ -3173,10 +3834,10 @@ function projectRoot() {
   return process.cwd();
 }
 function statePath() {
-  return join10(projectRoot(), "sprint-state.json");
+  return join13(projectRoot(), "sprint-state.json");
 }
 function tmpPath() {
-  return join10(projectRoot(), ".sprint-state.json.tmp");
+  return join13(projectRoot(), ".sprint-state.json.tmp");
 }
 function defaultState() {
   return {
@@ -3209,7 +3870,7 @@ function writeStateAtomic(state) {
     const data = JSON.stringify(state, null, 2) + "\n";
     const tmp = tmpPath();
     const final = statePath();
-    writeFileSync6(tmp, data, "utf-8");
+    writeFileSync7(tmp, data, "utf-8");
     renameSync(tmp, final);
     return ok2(void 0);
   } catch (err) {
@@ -3219,9 +3880,9 @@ function writeStateAtomic(state) {
 }
 function getSprintState() {
   const fp = statePath();
-  if (existsSync12(fp)) {
+  if (existsSync14(fp)) {
     try {
-      const raw = readFileSync10(fp, "utf-8");
+      const raw = readFileSync11(fp, "utf-8");
       const parsed = JSON.parse(raw);
       const defaults = defaultState();
       const run = parsed.run;
@@ -3518,9 +4179,9 @@ function generateReport(state, now) {
 }
 
 // src/modules/sprint/timeout.ts
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, existsSync as existsSync13, mkdirSync as mkdirSync3, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, existsSync as existsSync15, mkdirSync as mkdirSync3, readdirSync as readdirSync3 } from "fs";
 import { execSync } from "child_process";
-import { join as join11 } from "path";
+import { join as join14 } from "path";
 var GIT_TIMEOUT_MS = 5e3;
 var DEFAULT_MAX_LINES = 100;
 function captureGitDiff() {
@@ -3549,14 +4210,14 @@ function captureGitDiff() {
 }
 function captureStateDelta(beforePath, afterPath) {
   try {
-    if (!existsSync13(beforePath)) {
+    if (!existsSync15(beforePath)) {
       return fail2(`State snapshot not found: ${beforePath}`);
     }
-    if (!existsSync13(afterPath)) {
+    if (!existsSync15(afterPath)) {
       return fail2(`Current state file not found: ${afterPath}`);
     }
-    const beforeRaw = readFileSync11(beforePath, "utf-8");
-    const afterRaw = readFileSync11(afterPath, "utf-8");
+    const beforeRaw = readFileSync12(beforePath, "utf-8");
+    const afterRaw = readFileSync12(afterPath, "utf-8");
     const before = JSON.parse(beforeRaw);
     const after = JSON.parse(afterRaw);
     const beforeStories = before.stories ?? {};
@@ -3581,10 +4242,10 @@ function captureStateDelta(beforePath, afterPath) {
 }
 function capturePartialStderr(outputFile, maxLines = DEFAULT_MAX_LINES) {
   try {
-    if (!existsSync13(outputFile)) {
+    if (!existsSync15(outputFile)) {
       return fail2(`Output file not found: ${outputFile}`);
     }
-    const content = readFileSync11(outputFile, "utf-8");
+    const content = readFileSync12(outputFile, "utf-8");
     const lines = content.split("\n");
     if (lines.length > 0 && lines[lines.length - 1] === "") {
       lines.pop();
@@ -3632,7 +4293,7 @@ function captureTimeoutReport(opts) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const gitResult = captureGitDiff();
     const gitDiff = gitResult.success ? gitResult.data : `(unavailable: ${gitResult.error})`;
-    const statePath2 = join11(process.cwd(), "sprint-state.json");
+    const statePath2 = join14(process.cwd(), "sprint-state.json");
     const deltaResult = captureStateDelta(opts.stateSnapshotPath, statePath2);
     const stateDelta = deltaResult.success ? deltaResult.data : `(unavailable: ${deltaResult.error})`;
     const stderrResult = capturePartialStderr(opts.outputFile);
@@ -3646,15 +4307,15 @@ function captureTimeoutReport(opts) {
       partialStderr,
       timestamp
     };
-    const reportDir = join11(process.cwd(), "ralph", "logs");
+    const reportDir = join14(process.cwd(), "ralph", "logs");
     const safeStoryKey = opts.storyKey.replace(/[^a-zA-Z0-9._-]/g, "_");
     const reportFileName = `timeout-report-${opts.iteration}-${safeStoryKey}.md`;
-    const reportPath = join11(reportDir, reportFileName);
-    if (!existsSync13(reportDir)) {
+    const reportPath = join14(reportDir, reportFileName);
+    if (!existsSync15(reportDir)) {
       mkdirSync3(reportDir, { recursive: true });
     }
     const reportContent = formatReport(capture);
-    writeFileSync7(reportPath, reportContent, "utf-8");
+    writeFileSync8(reportPath, reportContent, "utf-8");
     return ok2({
       filePath: reportPath,
       capture
@@ -3666,14 +4327,14 @@ function captureTimeoutReport(opts) {
 }
 function findLatestTimeoutReport(storyKey) {
   try {
-    const reportDir = join11(process.cwd(), "ralph", "logs");
-    if (!existsSync13(reportDir)) {
+    const reportDir = join14(process.cwd(), "ralph", "logs");
+    if (!existsSync15(reportDir)) {
       return ok2(null);
     }
     const safeStoryKey = storyKey.replace(/[^a-zA-Z0-9._-]/g, "_");
     const prefix = `timeout-report-`;
     const suffix = `-${safeStoryKey}.md`;
-    const files = readdirSync2(reportDir, { encoding: "utf-8" });
+    const files = readdirSync3(reportDir, { encoding: "utf-8" });
     const matches = [];
     for (const f of files) {
       if (f.startsWith(prefix) && f.endsWith(suffix)) {
@@ -3689,8 +4350,8 @@ function findLatestTimeoutReport(storyKey) {
     }
     matches.sort((a, b) => b.iteration - a.iteration);
     const latest = matches[0];
-    const reportPath = join11(reportDir, latest.fileName);
-    const content = readFileSync11(reportPath, "utf-8");
+    const reportPath = join14(reportDir, latest.fileName);
+    const content = readFileSync12(reportPath, "utf-8");
     let durationMinutes = 0;
     let filesChanged = 0;
     const durationMatch = content.match(/\*\*Duration:\*\*\s*(\d+)\s*minutes/);
@@ -3719,12 +4380,12 @@ function findLatestTimeoutReport(storyKey) {
 }
 
 // src/modules/sprint/feedback.ts
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "fs";
-import { existsSync as existsSync14 } from "fs";
-import { join as join12 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync16 } from "fs";
+import { join as join15 } from "path";
 
 // src/modules/sprint/validator.ts
-import { readFileSync as readFileSync13, existsSync as existsSync15 } from "fs";
+import { readFileSync as readFileSync14, existsSync as existsSync17 } from "fs";
 var VALID_STATUSES = /* @__PURE__ */ new Set([
   "backlog",
   "ready",
@@ -3755,10 +4416,10 @@ function parseSprintStatusKeys(content) {
 }
 function parseStateFile(statePath2) {
   try {
-    if (!existsSync15(statePath2)) {
+    if (!existsSync17(statePath2)) {
       return fail2(`State file not found: ${statePath2}`);
     }
-    const raw = readFileSync13(statePath2, "utf-8");
+    const raw = readFileSync14(statePath2, "utf-8");
     const parsed = JSON.parse(raw);
     return ok2(parsed);
   } catch (err) {
@@ -3773,10 +4434,10 @@ function validateStateConsistency(statePath2, sprintStatusPath) {
       return fail2(stateResult.error);
     }
     const state = stateResult.data;
-    if (!existsSync15(sprintStatusPath)) {
+    if (!existsSync17(sprintStatusPath)) {
       return fail2(`Sprint status file not found: ${sprintStatusPath}`);
     }
-    const statusContent = readFileSync13(sprintStatusPath, "utf-8");
+    const statusContent = readFileSync14(sprintStatusPath, "utf-8");
     const keysResult = parseSprintStatusKeys(statusContent);
     if (!keysResult.success) {
       return fail2(keysResult.error);
@@ -3894,6 +4555,109 @@ function clearRunProgress2() {
   return clearRunProgress();
 }
 
+// src/lib/run-helpers.ts
+import { StringDecoder } from "string_decoder";
+
+// src/lib/stream-parser.ts
+function parseStreamLine(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return null;
+  }
+  const wrapperType = parsed.type;
+  if (wrapperType === "stream_event") {
+    return parseStreamEvent(parsed);
+  }
+  if (wrapperType === "system") {
+    return parseSystemEvent(parsed);
+  }
+  if (wrapperType === "result") {
+    return parseResultEvent(parsed);
+  }
+  return null;
+}
+function parseStreamEvent(parsed) {
+  const event = parsed.event;
+  if (!event || typeof event !== "object") {
+    return null;
+  }
+  const eventType = event.type;
+  if (eventType === "content_block_start") {
+    return parseContentBlockStart(event);
+  }
+  if (eventType === "content_block_delta") {
+    return parseContentBlockDelta(event);
+  }
+  if (eventType === "content_block_stop") {
+    return { type: "tool-complete" };
+  }
+  return null;
+}
+function parseContentBlockStart(event) {
+  const contentBlock = event.content_block;
+  if (!contentBlock || typeof contentBlock !== "object") {
+    return null;
+  }
+  if (contentBlock.type === "tool_use") {
+    const name = contentBlock.name;
+    const id = contentBlock.id;
+    if (typeof name === "string" && typeof id === "string") {
+      return { type: "tool-start", name, id };
+    }
+  }
+  return null;
+}
+function parseContentBlockDelta(event) {
+  const delta = event.delta;
+  if (!delta || typeof delta !== "object") {
+    return null;
+  }
+  if (delta.type === "input_json_delta") {
+    const partialJson = delta.partial_json;
+    if (typeof partialJson === "string") {
+      return { type: "tool-input", partial: partialJson };
+    }
+    return null;
+  }
+  if (delta.type === "text_delta") {
+    const text = delta.text;
+    if (typeof text === "string") {
+      return { type: "text", text };
+    }
+    return null;
+  }
+  return null;
+}
+function parseSystemEvent(parsed) {
+  const subtype = parsed.subtype;
+  if (subtype === "api_retry") {
+    const attempt = parsed.attempt;
+    const delay = parsed.retry_delay_ms;
+    if (typeof attempt === "number" && typeof delay === "number") {
+      return { type: "retry", attempt, delay };
+    }
+    return null;
+  }
+  return null;
+}
+function parseResultEvent(parsed) {
+  const costUsd = parsed.cost_usd;
+  const sessionId = parsed.session_id;
+  if (typeof costUsd === "number" && typeof sessionId === "string") {
+    return { type: "result", cost: costUsd, sessionId };
+  }
+  return null;
+}
+
 // src/lib/run-helpers.ts
 var STORY_KEY_PATTERN = /^\d+-\d+-/;
 function countStories(statuses) {
@@ -3928,6 +4692,9 @@ function buildSpawnArgs(opts) {
     "--prompt",
     opts.promptFile
   ];
+  if (!opts.quiet) {
+    args.push("--live");
+  }
   if (opts.maxStoryRetries !== void 0) {
     args.push("--max-story-retries", String(opts.maxStoryRetries));
   }
@@ -3979,6 +4746,7 @@ var TIMESTAMP_PREFIX = /^\[[\d-]+\s[\d:]+\]\s*/;
 var SUCCESS_STORY = /\[SUCCESS\]\s+Story\s+([\w-]+):\s+DONE(.*)/;
 var WARN_STORY_RETRY = /\[WARN\]\s+Story\s+([\w-]+)\s+exceeded retry limit/;
 var WARN_STORY_RETRYING = /\[WARN\]\s+Story\s+([\w-]+)\s+.*retry\s+(\d+)\/(\d+)/;
+var LOOP_ITERATION = /\[LOOP\]\s+iteration\s+(\d+)/;
 var ERROR_LINE = /\[ERROR\]\s+(.+)/;
 function parseRalphMessage(rawLine) {
   const clean = rawLine.replace(ANSI_ESCAPE, "").replace(TIMESTAMP_PREFIX, "").trim();
@@ -4023,6 +4791,41 @@ function parseRalphMessage(rawLine) {
   }
   return null;
 }
+function parseIterationMessage(rawLine) {
+  const clean = rawLine.replace(ANSI_ESCAPE, "").replace(TIMESTAMP_PREFIX, "").trim();
+  if (clean.length === 0) return null;
+  const match = LOOP_ITERATION.exec(clean);
+  if (match) {
+    return parseInt(match[1], 10);
+  }
+  return null;
+}
+function createLineProcessor(callbacks, opts) {
+  let partial = "";
+  const decoder = new StringDecoder("utf8");
+  return (data) => {
+    const text = partial + decoder.write(data);
+    const parts = text.split("\n");
+    partial = parts.pop() ?? "";
+    for (const line of parts) {
+      if (line.trim().length === 0) continue;
+      const event = parseStreamLine(line);
+      if (event) {
+        callbacks.onEvent(event);
+      }
+      if (opts?.parseRalph) {
+        const msg = parseRalphMessage(line);
+        if (msg && callbacks.onMessage) {
+          callbacks.onMessage(msg);
+        }
+        const iteration = parseIterationMessage(line);
+        if (iteration !== null && callbacks.onIteration) {
+          callbacks.onIteration(iteration);
+        }
+      }
+    }
+  };
+}
 
 // src/commands/run.ts
 var SPRINT_STATUS_REL = "_bmad-output/implementation-artifacts/sprint-status.yaml";
@@ -4033,10 +4836,10 @@ function resolveRalphPath() {
   if (root.endsWith("/src") || root.endsWith("\\src")) {
     root = dirname4(root);
   }
-  return join13(root, "ralph", "ralph.sh");
+  return join16(root, "ralph", "ralph.sh");
 }
 function resolvePluginDir() {
-  return join13(process.cwd(), ".claude");
+  return join16(process.cwd(), ".claude");
 }
 function registerRunCommand(program) {
   program.command("run").description("Execute the autonomous coding loop").option("--max-iterations <n>", "Maximum loop iterations", "50").option("--timeout <seconds>", "Total loop timeout in seconds", "43200").option("--iteration-timeout <minutes>", "Per-iteration timeout in minutes", "30").option("--quiet", "Suppress terminal output (background mode)", false).option("--calls <n>", "Max API calls per hour", "100").option("--max-story-retries <n>", "Max retries per story before flagging", "10").option("--reset", "Clear retry counters, flagged stories, and circuit breaker before starting", false).action(async (options, cmd) => {
@@ -4044,19 +4847,19 @@ function registerRunCommand(program) {
     const isJson = !!globalOpts.json;
     const outputOpts = { json: isJson };
     const ralphPath = resolveRalphPath();
-    if (!existsSync16(ralphPath)) {
+    if (!existsSync18(ralphPath)) {
       fail("Ralph loop not found \u2014 reinstall codeharness", outputOpts);
       process.exitCode = 1;
       return;
     }
     const pluginDir = resolvePluginDir();
-    if (!existsSync16(pluginDir)) {
+    if (!existsSync18(pluginDir)) {
       fail("Plugin directory not found \u2014 run codeharness init first", outputOpts);
       process.exitCode = 1;
       return;
     }
     const projectDir = process.cwd();
-    const sprintStatusPath = join13(projectDir, SPRINT_STATUS_REL);
+    const sprintStatusPath = join16(projectDir, SPRINT_STATUS_REL);
     const statuses = readSprintStatus(projectDir);
     const counts = countStories(statuses);
     if (counts.total === 0) {
@@ -4075,12 +4878,12 @@ function registerRunCommand(program) {
       process.exitCode = 1;
       return;
     }
-    const promptFile = join13(projectDir, "ralph", ".harness-prompt.md");
-    const flaggedFilePath = join13(projectDir, "ralph", ".flagged_stories");
+    const promptFile = join16(projectDir, "ralph", ".harness-prompt.md");
+    const flaggedFilePath = join16(projectDir, "ralph", ".flagged_stories");
     let flaggedStories;
-    if (existsSync16(flaggedFilePath)) {
+    if (existsSync18(flaggedFilePath)) {
       try {
-        const flaggedContent = readFileSync14(flaggedFilePath, "utf-8");
+        const flaggedContent = readFileSync15(flaggedFilePath, "utf-8");
         flaggedStories = flaggedContent.split("\n").filter((s) => s.trim().length > 0);
       } catch {
       }
@@ -4092,7 +4895,7 @@ function registerRunCommand(program) {
     });
     try {
       mkdirSync4(dirname4(promptFile), { recursive: true });
-      writeFileSync9(promptFile, promptContent, "utf-8");
+      writeFileSync10(promptFile, promptContent, "utf-8");
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       fail(`Failed to write prompt file: ${message}`, outputOpts);
@@ -4119,6 +4922,7 @@ function registerRunCommand(program) {
     const rendererHandle = startRenderer({ quiet });
     let sprintStateInterval = null;
     const sessionStartTime = Date.now();
+    let currentIterationCount = 0;
     try {
       const initialState = getSprintState2();
       if (initialState.success) {
@@ -4128,7 +4932,8 @@ function registerRunCommand(program) {
           phase: s.run.currentPhase ?? "",
           done: s.sprint.done,
           total: s.sprint.total,
-          elapsed: formatElapsed(Date.now() - sessionStartTime)
+          elapsed: formatElapsed(Date.now() - sessionStartTime),
+          iterationCount: currentIterationCount
         };
         rendererHandle.updateSprintState(sprintInfo);
       }
@@ -4143,30 +4948,18 @@ function registerRunCommand(program) {
         env
       });
       if (!quiet && child.stdout && child.stderr) {
-        const makeLineHandler = (opts) => {
-          let partial = "";
-          const decoder = new StringDecoder("utf8");
-          return (data) => {
-            const text = partial + decoder.write(data);
-            const parts = text.split("\n");
-            partial = parts.pop() ?? "";
-            for (const line of parts) {
-              if (line.trim().length === 0) continue;
-              const event = parseStreamLine(line);
-              if (event) {
-                rendererHandle.update(event);
-              }
-              if (opts?.parseRalph) {
-                const msg = parseRalphMessage(line);
-                if (msg) {
-                  rendererHandle.addMessage(msg);
-                }
-              }
-            }
-          };
-        };
-        child.stdout.on("data", makeLineHandler());
-        child.stderr.on("data", makeLineHandler({ parseRalph: true }));
+        const stdoutHandler = createLineProcessor({
+          onEvent: (event) => rendererHandle.update(event)
+        });
+        const stderrHandler = createLineProcessor({
+          onEvent: (event) => rendererHandle.update(event),
+          onMessage: (msg) => rendererHandle.addMessage(msg),
+          onIteration: (iteration) => {
+            currentIterationCount = iteration;
+          }
+        }, { parseRalph: true });
+        child.stdout.on("data", stdoutHandler);
+        child.stderr.on("data", stderrHandler);
         sprintStateInterval = setInterval(() => {
           try {
             const stateResult = getSprintState2();
@@ -4177,7 +4970,8 @@ function registerRunCommand(program) {
                 phase: s.run.currentPhase ?? "",
                 done: s.sprint.done,
                 total: s.sprint.total,
-                elapsed: formatElapsed(Date.now() - sessionStartTime)
+                elapsed: formatElapsed(Date.now() - sessionStartTime),
+                iterationCount: currentIterationCount
               };
               rendererHandle.updateSprintState(sprintInfo);
             }
@@ -4201,10 +4995,10 @@ function registerRunCommand(program) {
         });
       });
       if (isJson) {
-        const statusFile = join13(projectDir, "ralph", "status.json");
-        if (existsSync16(statusFile)) {
+        const statusFile = join16(projectDir, "ralph", "status.json");
+        if (existsSync18(statusFile)) {
           try {
-            const statusData = JSON.parse(readFileSync14(statusFile, "utf-8"));
+            const statusData = JSON.parse(readFileSync15(statusFile, "utf-8"));
             const finalStatuses = readSprintStatus(projectDir);
             const finalCounts = countStories(finalStatuses);
             jsonOutput({
@@ -4256,14 +5050,14 @@ function registerRunCommand(program) {
 }
 
 // src/commands/verify.ts
-import { existsSync as existsSync25, readFileSync as readFileSync23 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync24 } from "fs";
+import { join as join25 } from "path";
 
 // src/modules/verify/index.ts
-import { readFileSync as readFileSync22 } from "fs";
+import { readFileSync as readFileSync23 } from "fs";
 
 // src/modules/verify/proof.ts
-import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync16 } from "fs";
 function classifyEvidenceCommands(proofContent) {
   const results = [];
   const codeBlockPattern = /```(?:bash|shell)\n([\s\S]*?)```/g;
@@ -4349,10 +5143,10 @@ function validateProofQuality(proofPath) {
     otherCount: 0,
     blackBoxPass: false
   };
-  if (!existsSync17(proofPath)) {
+  if (!existsSync19(proofPath)) {
     return emptyResult;
   }
-  const content = readFileSync15(proofPath, "utf-8");
+  const content = readFileSync16(proofPath, "utf-8");
   const bbTierMatch = /\*\*Tier:\*\*\s*(unit-testable|black-box)/i.exec(content);
   const bbIsUnitTestable = bbTierMatch ? bbTierMatch[1].toLowerCase() === "unit-testable" : false;
   const bbEnforcement = bbIsUnitTestable ? { blackBoxPass: true, grepSrcCount: 0, dockerExecCount: 0, observabilityCount: 0, otherCount: 0, grepRatio: 0, acsMissingDockerExec: [] } : checkBlackBoxEnforcement(content);
@@ -4495,21 +5289,21 @@ function validateProofQuality(proofPath) {
 
 // src/modules/verify/orchestrator.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync11 } from "fs";
-import { join as join15 } from "path";
+import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync12 } from "fs";
+import { join as join18 } from "path";
 
 // src/lib/doc-health.ts
 import { execSync as execSync2 } from "child_process";
 import {
-  existsSync as existsSync18,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync5,
-  readFileSync as readFileSync16,
-  readdirSync as readdirSync3,
+  readFileSync as readFileSync17,
+  readdirSync as readdirSync4,
   statSync,
   unlinkSync,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "fs";
-import { join as join14, relative } from "path";
+import { join as join17, relative } from "path";
 var DO_NOT_EDIT_HEADER2 = "<!-- DO NOT EDIT MANUALLY";
 var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".py"]);
 var DEFAULT_MODULE_THRESHOLD = 3;
@@ -4520,7 +5314,7 @@ function findModules(dir, threshold) {
   function walk(current) {
     let entries;
     try {
-      entries = readdirSync3(current);
+      entries = readdirSync4(current);
     } catch {
       return;
     }
@@ -4531,7 +5325,7 @@ function findModules(dir, threshold) {
     let sourceCount = 0;
     const subdirs = [];
     for (const entry of entries) {
-      const fullPath = join14(current, entry);
+      const fullPath = join17(current, entry);
       let stat;
       try {
         stat = statSync(fullPath);
@@ -4572,14 +5366,14 @@ function getNewestSourceMtime(dir) {
   function walk(current) {
     let entries;
     try {
-      entries = readdirSync3(current);
+      entries = readdirSync4(current);
     } catch {
       return;
     }
     const dirName = current.split("/").pop() ?? "";
     if (dirName === "node_modules" || dirName === ".git") return;
     for (const entry of entries) {
-      const fullPath = join14(current, entry);
+      const fullPath = join17(current, entry);
       let stat;
       try {
         stat = statSync(fullPath);
@@ -4608,14 +5402,14 @@ function getSourceFilesInModule(modulePath) {
   function walk(current) {
     let entries;
     try {
-      entries = readdirSync3(current);
+      entries = readdirSync4(current);
     } catch {
       return;
     }
     const dirName = current.split("/").pop() ?? "";
     if (dirName === "node_modules" || dirName === ".git" || dirName === "__tests__" || dirName === "dist" || dirName === "coverage" || dirName.startsWith(".") && current !== modulePath) return;
     for (const entry of entries) {
-      const fullPath = join14(current, entry);
+      const fullPath = join17(current, entry);
       let stat;
       try {
         stat = statSync(fullPath);
@@ -4636,8 +5430,8 @@ function getSourceFilesInModule(modulePath) {
   return files;
 }
 function getMentionedFilesInAgentsMd(agentsPath) {
-  if (!existsSync18(agentsPath)) return [];
-  const content = readFileSync16(agentsPath, "utf-8");
+  if (!existsSync20(agentsPath)) return [];
+  const content = readFileSync17(agentsPath, "utf-8");
   const mentioned = /* @__PURE__ */ new Set();
   const filenamePattern = /[\w./-]*[\w-]+\.(?:ts|js|py)\b/g;
   let match;
@@ -4661,12 +5455,12 @@ function checkAgentsMdCompleteness(agentsPath, modulePath) {
 }
 function checkAgentsMdForModule(modulePath, dir) {
   const root = dir ?? process.cwd();
-  const fullModulePath = join14(root, modulePath);
-  let agentsPath = join14(fullModulePath, "AGENTS.md");
-  if (!existsSync18(agentsPath)) {
-    agentsPath = join14(root, "AGENTS.md");
+  const fullModulePath = join17(root, modulePath);
+  let agentsPath = join17(fullModulePath, "AGENTS.md");
+  if (!existsSync20(agentsPath)) {
+    agentsPath = join17(root, "AGENTS.md");
   }
-  if (!existsSync18(agentsPath)) {
+  if (!existsSync20(agentsPath)) {
     return {
       path: relative(root, agentsPath),
       grade: "missing",
@@ -4697,9 +5491,9 @@ function checkAgentsMdForModule(modulePath, dir) {
   };
 }
 function checkDoNotEditHeaders(docPath) {
-  if (!existsSync18(docPath)) return false;
+  if (!existsSync20(docPath)) return false;
   try {
-    const content = readFileSync16(docPath, "utf-8");
+    const content = readFileSync17(docPath, "utf-8");
     if (content.length === 0) return false;
     return content.trimStart().startsWith(DO_NOT_EDIT_HEADER2);
   } catch {
@@ -4711,17 +5505,17 @@ function scanDocHealth(dir) {
   const root = dir ?? process.cwd();
   const documents = [];
   const modules = findModules(root);
-  const rootAgentsPath = join14(root, "AGENTS.md");
-  if (existsSync18(rootAgentsPath)) {
+  const rootAgentsPath = join17(root, "AGENTS.md");
+  if (existsSync20(rootAgentsPath)) {
     if (modules.length > 0) {
       const docMtime = statSync(rootAgentsPath).mtime;
       let allMissing = [];
       let staleModule = "";
       let newestCode = null;
       for (const mod of modules) {
-        const fullModPath = join14(root, mod);
-        const modAgentsPath = join14(fullModPath, "AGENTS.md");
-        if (existsSync18(modAgentsPath)) continue;
+        const fullModPath = join17(root, mod);
+        const modAgentsPath = join17(fullModPath, "AGENTS.md");
+        if (existsSync20(modAgentsPath)) continue;
         const { missing } = checkAgentsMdCompleteness(rootAgentsPath, fullModPath);
         if (missing.length > 0 && staleModule === "") {
           staleModule = mod;
@@ -4769,8 +5563,8 @@ function scanDocHealth(dir) {
     });
   }
   for (const mod of modules) {
-    const modAgentsPath = join14(root, mod, "AGENTS.md");
-    if (existsSync18(modAgentsPath)) {
+    const modAgentsPath = join17(root, mod, "AGENTS.md");
+    if (existsSync20(modAgentsPath)) {
       const result = checkAgentsMdForModule(mod, root);
       if (result.path !== "AGENTS.md") {
         documents.push(result);
@@ -4778,9 +5572,9 @@ function scanDocHealth(dir) {
       }
     }
   }
-  const indexPath = join14(root, "docs", "index.md");
-  if (existsSync18(indexPath)) {
-    const content = readFileSync16(indexPath, "utf-8");
+  const indexPath = join17(root, "docs", "index.md");
+  if (existsSync20(indexPath)) {
+    const content = readFileSync17(indexPath, "utf-8");
     const hasAbsolutePaths = /https?:\/\/|file:\/\//i.test(content);
     documents.push({
       path: "docs/index.md",
@@ -4790,11 +5584,11 @@ function scanDocHealth(dir) {
       reason: hasAbsolutePaths ? "Contains absolute URLs (may violate NFR25)" : "Uses relative paths"
     });
   }
-  const activeDir = join14(root, "docs", "exec-plans", "active");
-  if (existsSync18(activeDir)) {
-    const files = readdirSync3(activeDir).filter((f) => f.endsWith(".md"));
+  const activeDir = join17(root, "docs", "exec-plans", "active");
+  if (existsSync20(activeDir)) {
+    const files = readdirSync4(activeDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const filePath = join14(activeDir, file);
+      const filePath = join17(activeDir, file);
       documents.push({
         path: `docs/exec-plans/active/${file}`,
         grade: "fresh",
@@ -4805,11 +5599,11 @@ function scanDocHealth(dir) {
     }
   }
   for (const subdir of ["quality", "generated"]) {
-    const dirPath = join14(root, "docs", subdir);
-    if (!existsSync18(dirPath)) continue;
-    const files = readdirSync3(dirPath).filter((f) => !f.startsWith("."));
+    const dirPath = join17(root, "docs", subdir);
+    if (!existsSync20(dirPath)) continue;
+    const files = readdirSync4(dirPath).filter((f) => !f.startsWith("."));
     for (const file of files) {
-      const filePath = join14(dirPath, file);
+      const filePath = join17(dirPath, file);
       let stat;
       try {
         stat = statSync(filePath);
@@ -4842,7 +5636,7 @@ function scanDocHealth(dir) {
 }
 function checkAgentsMdLineCount(filePath, docPath, documents) {
   try {
-    const content = readFileSync16(filePath, "utf-8");
+    const content = readFileSync17(filePath, "utf-8");
     const lineCount = content.split("\n").length;
     if (lineCount > 100) {
       documents.push({
@@ -4880,15 +5674,15 @@ function checkStoryDocFreshness(storyId, dir) {
   for (const mod of modulesToCheck) {
     const result = checkAgentsMdForModule(mod, root);
     documents.push(result);
-    const moduleAgentsPath = join14(root, mod, "AGENTS.md");
-    const actualAgentsPath = existsSync18(moduleAgentsPath) ? moduleAgentsPath : join14(root, "AGENTS.md");
-    if (existsSync18(actualAgentsPath)) {
+    const moduleAgentsPath = join17(root, mod, "AGENTS.md");
+    const actualAgentsPath = existsSync20(moduleAgentsPath) ? moduleAgentsPath : join17(root, "AGENTS.md");
+    if (existsSync20(actualAgentsPath)) {
       checkAgentsMdLineCount(actualAgentsPath, result.path, documents);
     }
   }
   if (modulesToCheck.length === 0) {
-    const rootAgentsPath = join14(root, "AGENTS.md");
-    if (existsSync18(rootAgentsPath)) {
+    const rootAgentsPath = join17(root, "AGENTS.md");
+    if (existsSync20(rootAgentsPath)) {
       documents.push({
         path: "AGENTS.md",
         grade: "fresh",
@@ -4926,11 +5720,11 @@ function getRecentlyChangedFiles(dir) {
 }
 function completeExecPlan(storyId, dir) {
   const root = dir ?? process.cwd();
-  const activePath = join14(root, "docs", "exec-plans", "active", `${storyId}.md`);
-  if (!existsSync18(activePath)) {
+  const activePath = join17(root, "docs", "exec-plans", "active", `${storyId}.md`);
+  if (!existsSync20(activePath)) {
     return null;
   }
-  let content = readFileSync16(activePath, "utf-8");
+  let content = readFileSync17(activePath, "utf-8");
   content = content.replace(/^Status:\s*active$/m, "Status: completed");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   content = content.replace(
@@ -4938,10 +5732,10 @@ function completeExecPlan(storyId, dir) {
     `$1
 Completed: ${timestamp}`
   );
-  const completedDir = join14(root, "docs", "exec-plans", "completed");
+  const completedDir = join17(root, "docs", "exec-plans", "completed");
   mkdirSync5(completedDir, { recursive: true });
-  const completedPath = join14(completedDir, `${storyId}.md`);
-  writeFileSync10(completedPath, content, "utf-8");
+  const completedPath = join17(completedDir, `${storyId}.md`);
+  writeFileSync11(completedPath, content, "utf-8");
   try {
     unlinkSync(activePath);
   } catch {
@@ -5066,8 +5860,8 @@ function checkPreconditions(dir, storyId) {
 }
 function createProofDocument(storyId, storyTitle, acs, dir) {
   const root = dir ?? process.cwd();
-  const verificationDir = join15(root, "verification");
-  const screenshotsDir = join15(verificationDir, "screenshots");
+  const verificationDir = join18(root, "verification");
+  const screenshotsDir = join18(verificationDir, "screenshots");
   mkdirSync6(verificationDir, { recursive: true });
   mkdirSync6(screenshotsDir, { recursive: true });
   const criteria = acs.map((ac) => ({
@@ -5081,8 +5875,8 @@ function createProofDocument(storyId, storyTitle, acs, dir) {
     storyTitle,
     acceptanceCriteria: criteria
   });
-  const proofPath = join15(verificationDir, `${storyId}-proof.md`);
-  writeFileSync11(proofPath, content, "utf-8");
+  const proofPath = join18(verificationDir, `${storyId}-proof.md`);
+  writeFileSync12(proofPath, content, "utf-8");
   return proofPath;
 }
 function runShowboatVerify(proofPath) {
@@ -5134,7 +5928,7 @@ function closeBeadsIssue(storyId, dir) {
 }
 
 // src/modules/verify/parser.ts
-import { existsSync as existsSync20, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync18 } from "fs";
 var UI_KEYWORDS = [
   "agent-browser",
   "screenshot",
@@ -5204,12 +5998,12 @@ function classifyAC(description) {
   return "general";
 }
 function parseStoryACs(storyFilePath) {
-  if (!existsSync20(storyFilePath)) {
+  if (!existsSync22(storyFilePath)) {
     throw new Error(
       `Story file not found: ${storyFilePath}. Ensure the story file exists at the expected path.`
     );
   }
-  const content = readFileSync17(storyFilePath, "utf-8");
+  const content = readFileSync18(storyFilePath, "utf-8");
   const lines = content.split("\n");
   let acSectionStart = -1;
   for (let i = 0; i < lines.length; i++) {
@@ -5301,7 +6095,7 @@ function parseObservabilityGaps(proofContent) {
 
 // src/modules/observability/analyzer.ts
 import { execFileSync as execFileSync8 } from "child_process";
-import { join as join16 } from "path";
+import { join as join19 } from "path";
 var DEFAULT_RULES_DIR = "patches/observability/";
 var DEFAULT_TIMEOUT = 6e4;
 var FUNCTION_NO_LOG_RULE = "function-no-debug-log";
@@ -5335,7 +6129,7 @@ function analyze(projectDir, config) {
   }
   const rulesDir = config?.rulesDir ?? DEFAULT_RULES_DIR;
   const timeout = config?.timeout ?? DEFAULT_TIMEOUT;
-  const fullRulesDir = join16(projectDir, rulesDir);
+  const fullRulesDir = join19(projectDir, rulesDir);
   const rawResult = runSemgrep(projectDir, fullRulesDir, timeout);
   if (!rawResult.success) {
     return fail2(rawResult.error);
@@ -5419,8 +6213,8 @@ function normalizeSeverity(severity) {
 }
 
 // src/modules/observability/coverage.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, renameSync as renameSync2, existsSync as existsSync21 } from "fs";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync13, renameSync as renameSync2, existsSync as existsSync23 } from "fs";
+import { join as join20 } from "path";
 var STATE_FILE2 = "sprint-state.json";
 var DEFAULT_STATIC_TARGET = 80;
 function defaultCoverageState() {
@@ -5436,12 +6230,12 @@ function defaultCoverageState() {
   };
 }
 function readStateFile(projectDir) {
-  const fp = join17(projectDir, STATE_FILE2);
-  if (!existsSync21(fp)) {
+  const fp = join20(projectDir, STATE_FILE2);
+  if (!existsSync23(fp)) {
     return ok2({});
   }
   try {
-    const raw = readFileSync18(fp, "utf-8");
+    const raw = readFileSync19(fp, "utf-8");
     const parsed = JSON.parse(raw);
     return ok2(parsed);
   } catch (err) {
@@ -5508,8 +6302,8 @@ function parseGapArray(raw) {
 }
 
 // src/modules/observability/runtime-coverage.ts
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync13, renameSync as renameSync3, existsSync as existsSync22 } from "fs";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync14, renameSync as renameSync3, existsSync as existsSync24 } from "fs";
+import { join as join21 } from "path";
 
 // src/modules/observability/coverage-gate.ts
 var DEFAULT_STATIC_TARGET2 = 80;
@@ -5551,8 +6345,8 @@ function checkObservabilityCoverageGate(projectDir, overrides) {
 
 // src/modules/observability/runtime-validator.ts
 import { execSync as execSync3 } from "child_process";
-import { readdirSync as readdirSync4, statSync as statSync2 } from "fs";
-import { join as join19 } from "path";
+import { readdirSync as readdirSync5, statSync as statSync2 } from "fs";
+import { join as join22 } from "path";
 var DEFAULT_CONFIG = {
   testCommand: "npm test",
   otlpEndpoint: "http://localhost:4318",
@@ -5679,11 +6473,11 @@ function mapEventsToModules(events, projectDir, modules) {
   });
 }
 function discoverModules(projectDir) {
-  const srcDir = join19(projectDir, "src");
+  const srcDir = join22(projectDir, "src");
   try {
-    return readdirSync4(srcDir).filter((name) => {
+    return readdirSync5(srcDir).filter((name) => {
       try {
-        return statSync2(join19(srcDir, name)).isDirectory();
+        return statSync2(join22(srcDir, name)).isDirectory();
       } catch {
         return false;
       }
@@ -5712,7 +6506,7 @@ function parseLogEvents(text) {
 
 // src/modules/verify/browser.ts
 import { execFileSync as execFileSync9 } from "child_process";
-import { existsSync as existsSync23, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync25, readFileSync as readFileSync21 } from "fs";
 
 // src/modules/verify/validation-ac-fr.ts
 var FR_ACS = [
@@ -6350,8 +7144,8 @@ function getACById(id) {
 
 // src/modules/verify/validation-runner.ts
 import { execSync as execSync4 } from "child_process";
-import { writeFileSync as writeFileSync14, mkdirSync as mkdirSync7 } from "fs";
-import { join as join20, dirname as dirname5 } from "path";
+import { writeFileSync as writeFileSync15, mkdirSync as mkdirSync7 } from "fs";
+import { join as join23, dirname as dirname5 } from "path";
 var MAX_VALIDATION_ATTEMPTS = 10;
 var AC_COMMAND_TIMEOUT_MS = 3e4;
 var VAL_KEY_PREFIX = "val-";
@@ -6460,7 +7254,7 @@ function executeValidationAC(ac) {
 function createFixStory(ac, error) {
   try {
     const storyKey = `val-fix-${ac.id}`;
-    const storyPath = join20(
+    const storyPath = join23(
       process.cwd(),
       "_bmad-output",
       "implementation-artifacts",
@@ -6504,7 +7298,7 @@ function createFixStory(ac, error) {
       ""
     ].join("\n");
     mkdirSync7(dirname5(storyPath), { recursive: true });
-    writeFileSync14(storyPath, markdown, "utf-8");
+    writeFileSync15(storyPath, markdown, "utf-8");
     return ok2(storyKey);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -6830,8 +7624,8 @@ function runValidationCycle() {
 
 // src/modules/verify/env.ts
 import { execFileSync as execFileSync11 } from "child_process";
-import { existsSync as existsSync24, mkdirSync as mkdirSync8, readdirSync as readdirSync5, readFileSync as readFileSync21, cpSync, rmSync, statSync as statSync3 } from "fs";
-import { join as join21, basename as basename4 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync8, readdirSync as readdirSync6, readFileSync as readFileSync22, cpSync, rmSync, statSync as statSync3 } from "fs";
+import { join as join24, basename as basename4 } from "path";
 import { createHash } from "crypto";
 var IMAGE_TAG = "codeharness-verify";
 var STORY_DIR = "_bmad-output/implementation-artifacts";
@@ -6844,20 +7638,20 @@ function isValidStoryKey(storyKey) {
   return /^[a-zA-Z0-9_-]+$/.test(storyKey);
 }
 function computeDistHash(projectDir) {
-  const distDir = join21(projectDir, "dist");
-  if (!existsSync24(distDir)) return null;
+  const distDir = join24(projectDir, "dist");
+  if (!existsSync26(distDir)) return null;
   const hash = createHash("sha256");
   const files = collectFiles(distDir).sort();
   for (const file of files) {
     hash.update(file.slice(distDir.length));
-    hash.update(readFileSync21(file));
+    hash.update(readFileSync22(file));
   }
   return hash.digest("hex");
 }
 function collectFiles(dir) {
   const results = [];
-  for (const entry of readdirSync5(dir, { withFileTypes: true })) {
-    const fullPath = join21(dir, entry.name);
+  for (const entry of readdirSync6(dir, { withFileTypes: true })) {
+    const fullPath = join24(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...collectFiles(fullPath));
     } else {
@@ -6884,10 +7678,13 @@ function storeDistHash(projectDir, hash) {
   }
 }
 function detectProjectType(projectDir) {
-  const stack = detectStack(projectDir);
+  const allStacks = detectStacks(projectDir);
+  const rootDetection = allStacks.find((s) => s.dir === ".");
+  const stack = rootDetection ? rootDetection.stack : null;
   if (stack === "nodejs") return "nodejs";
   if (stack === "python") return "python";
-  if (existsSync24(join21(projectDir, ".claude-plugin", "plugin.json"))) return "plugin";
+  if (stack === "rust") return "rust";
+  if (existsSync26(join24(projectDir, ".claude-plugin", "plugin.json"))) return "plugin";
   return "generic";
 }
 function buildVerifyImage(options = {}) {
@@ -6897,7 +7694,7 @@ function buildVerifyImage(options = {}) {
   }
   const projectType = detectProjectType(projectDir);
   const currentHash = computeDistHash(projectDir);
-  if (projectType === "generic" || projectType === "plugin") {
+  if (projectType === "generic" || projectType === "plugin" || projectType === "rust") {
   } else if (!currentHash) {
     throw new Error("No dist/ directory found. Run your build command first (e.g., npm run build).");
   }
@@ -6912,10 +7709,12 @@ function buildVerifyImage(options = {}) {
     buildNodeImage(projectDir);
   } else if (projectType === "python") {
     buildPythonImage(projectDir);
+  } else if (projectType === "rust") {
+    buildSimpleImage(projectDir, "rust", 3e5);
   } else if (projectType === "plugin") {
     buildPluginImage(projectDir);
   } else {
-    buildGenericImage(projectDir);
+    buildSimpleImage(projectDir, "generic");
   }
   if (currentHash) {
     storeDistHash(projectDir, currentHash);
@@ -6931,12 +7730,12 @@ function buildNodeImage(projectDir) {
   const lastLine = packOutput.split("\n").pop()?.trim();
   if (!lastLine) throw new Error("npm pack produced no output \u2014 cannot determine tarball filename.");
   const tarballName = basename4(lastLine);
-  const tarballPath = join21("/tmp", tarballName);
-  const buildContext = join21("/tmp", `codeharness-verify-build-${Date.now()}`);
+  const tarballPath = join24("/tmp", tarballName);
+  const buildContext = join24("/tmp", `codeharness-verify-build-${Date.now()}`);
   mkdirSync8(buildContext, { recursive: true });
   try {
-    cpSync(tarballPath, join21(buildContext, tarballName));
-    cpSync(resolveDockerfileTemplate(projectDir), join21(buildContext, "Dockerfile"));
+    cpSync(tarballPath, join24(buildContext, tarballName));
+    cpSync(resolveDockerfileTemplate(projectDir), join24(buildContext, "Dockerfile"));
     execFileSync11("docker", ["build", "-t", IMAGE_TAG, "--build-arg", `TARBALL=${tarballName}`, "."], {
       cwd: buildContext,
       stdio: "pipe",
@@ -6948,17 +7747,17 @@ function buildNodeImage(projectDir) {
   }
 }
 function buildPythonImage(projectDir) {
-  const distDir = join21(projectDir, "dist");
-  const distFiles = readdirSync5(distDir).filter((f) => f.endsWith(".tar.gz") || f.endsWith(".whl"));
+  const distDir = join24(projectDir, "dist");
+  const distFiles = readdirSync6(distDir).filter((f) => f.endsWith(".tar.gz") || f.endsWith(".whl"));
   if (distFiles.length === 0) {
     throw new Error("No distribution files found in dist/. Run your build command first (e.g., python -m build).");
   }
   const distFile = distFiles.filter((f) => f.endsWith(".tar.gz"))[0] ?? distFiles[0];
-  const buildContext = join21("/tmp", `codeharness-verify-build-${Date.now()}`);
+  const buildContext = join24("/tmp", `codeharness-verify-build-${Date.now()}`);
   mkdirSync8(buildContext, { recursive: true });
   try {
-    cpSync(join21(distDir, distFile), join21(buildContext, distFile));
-    cpSync(resolveDockerfileTemplate(projectDir), join21(buildContext, "Dockerfile"));
+    cpSync(join24(distDir, distFile), join24(buildContext, distFile));
+    cpSync(resolveDockerfileTemplate(projectDir), join24(buildContext, "Dockerfile"));
     execFileSync11("docker", ["build", "-t", IMAGE_TAG, "--build-arg", `TARBALL=${distFile}`, "."], {
       cwd: buildContext,
       stdio: "pipe",
@@ -6973,19 +7772,19 @@ function prepareVerifyWorkspace(storyKey, projectDir) {
   if (!isValidStoryKey(storyKey)) {
     throw new Error(`Invalid story key: ${storyKey}. Keys must contain only alphanumeric characters, hyphens, and underscores.`);
   }
-  const storyFile = join21(root, STORY_DIR, `${storyKey}.md`);
-  if (!existsSync24(storyFile)) throw new Error(`Story file not found: ${storyFile}`);
+  const storyFile = join24(root, STORY_DIR, `${storyKey}.md`);
+  if (!existsSync26(storyFile)) throw new Error(`Story file not found: ${storyFile}`);
   const workspace = `${TEMP_PREFIX}${storyKey}`;
-  if (existsSync24(workspace)) rmSync(workspace, { recursive: true, force: true });
+  if (existsSync26(workspace)) rmSync(workspace, { recursive: true, force: true });
   mkdirSync8(workspace, { recursive: true });
-  cpSync(storyFile, join21(workspace, "story.md"));
-  const readmePath = join21(root, "README.md");
-  if (existsSync24(readmePath)) cpSync(readmePath, join21(workspace, "README.md"));
-  const docsDir = join21(root, "docs");
-  if (existsSync24(docsDir) && statSync3(docsDir).isDirectory()) {
-    cpSync(docsDir, join21(workspace, "docs"), { recursive: true });
-  }
-  mkdirSync8(join21(workspace, "verification"), { recursive: true });
+  cpSync(storyFile, join24(workspace, "story.md"));
+  const readmePath = join24(root, "README.md");
+  if (existsSync26(readmePath)) cpSync(readmePath, join24(workspace, "README.md"));
+  const docsDir = join24(root, "docs");
+  if (existsSync26(docsDir) && statSync3(docsDir).isDirectory()) {
+    cpSync(docsDir, join24(workspace, "docs"), { recursive: true });
+  }
+  mkdirSync8(join24(workspace, "verification"), { recursive: true });
   return workspace;
 }
 function checkVerifyEnv() {
@@ -7027,7 +7826,7 @@ function cleanupVerifyEnv(storyKey) {
   }
   const workspace = `${TEMP_PREFIX}${storyKey}`;
   const containerName = `codeharness-verify-${storyKey}`;
-  if (existsSync24(workspace)) rmSync(workspace, { recursive: true, force: true });
+  if (existsSync26(workspace)) rmSync(workspace, { recursive: true, force: true });
   try {
     execFileSync11("docker", ["stop", containerName], { stdio: "pipe", timeout: 15e3 });
   } catch {
@@ -7038,18 +7837,18 @@ function cleanupVerifyEnv(storyKey) {
   }
 }
 function buildPluginImage(projectDir) {
-  const buildContext = join21("/tmp", `codeharness-verify-build-${Date.now()}`);
+  const buildContext = join24("/tmp", `codeharness-verify-build-${Date.now()}`);
   mkdirSync8(buildContext, { recursive: true });
   try {
-    const pluginDir = join21(projectDir, ".claude-plugin");
-    cpSync(pluginDir, join21(buildContext, ".claude-plugin"), { recursive: true });
+    const pluginDir = join24(projectDir, ".claude-plugin");
+    cpSync(pluginDir, join24(buildContext, ".claude-plugin"), { recursive: true });
     for (const dir of ["commands", "hooks", "knowledge", "skills"]) {
-      const src = join21(projectDir, dir);
-      if (existsSync24(src) && statSync3(src).isDirectory()) {
-        cpSync(src, join21(buildContext, dir), { recursive: true });
+      const src = join24(projectDir, dir);
+      if (existsSync26(src) && statSync3(src).isDirectory()) {
+        cpSync(src, join24(buildContext, dir), { recursive: true });
       }
     }
-    cpSync(resolveDockerfileTemplate(projectDir, "generic"), join21(buildContext, "Dockerfile"));
+    cpSync(resolveDockerfileTemplate(projectDir, "generic"), join24(buildContext, "Dockerfile"));
     execFileSync11("docker", ["build", "-t", IMAGE_TAG, "."], {
       cwd: buildContext,
       stdio: "pipe",
@@ -7059,27 +7858,31 @@ function buildPluginImage(projectDir) {
     rmSync(buildContext, { recursive: true, force: true });
   }
 }
-function buildGenericImage(projectDir) {
-  const buildContext = join21("/tmp", `codeharness-verify-build-${Date.now()}`);
+function buildSimpleImage(projectDir, variant, timeout = 12e4) {
+  const buildContext = join24("/tmp", `codeharness-verify-build-${Date.now()}`);
   mkdirSync8(buildContext, { recursive: true });
   try {
-    cpSync(resolveDockerfileTemplate(projectDir, "generic"), join21(buildContext, "Dockerfile"));
+    cpSync(resolveDockerfileTemplate(projectDir, variant), join24(buildContext, "Dockerfile"));
     execFileSync11("docker", ["build", "-t", IMAGE_TAG, "."], {
       cwd: buildContext,
       stdio: "pipe",
-      timeout: 12e4
+      timeout
     });
   } finally {
     rmSync(buildContext, { recursive: true, force: true });
   }
 }
+var DOCKERFILE_VARIANTS = {
+  generic: "Dockerfile.verify.generic",
+  rust: "Dockerfile.verify.rust"
+};
 function resolveDockerfileTemplate(projectDir, variant) {
-  const filename = variant === "generic" ? "Dockerfile.verify.generic" : "Dockerfile.verify";
-  const local = join21(projectDir, "templates", filename);
-  if (existsSync24(local)) return local;
+  const filename = (variant && DOCKERFILE_VARIANTS[variant]) ?? "Dockerfile.verify";
+  const local = join24(projectDir, "templates", filename);
+  if (existsSync26(local)) return local;
   const pkgDir = new URL("../../", import.meta.url).pathname;
-  const pkg = join21(pkgDir, "templates", filename);
-  if (existsSync24(pkg)) return pkg;
+  const pkg = join24(pkgDir, "templates", filename);
+  if (existsSync26(pkg)) return pkg;
   throw new Error(`${filename} not found. Ensure templates/${filename} exists.`);
 }
 function dockerImageExists(tag) {
@@ -7154,8 +7957,8 @@ function verifyRetro(opts, isJson, root) {
     return;
   }
   const retroFile = `epic-${epicNum}-retrospective.md`;
-  const retroPath = join22(root, STORY_DIR2, retroFile);
-  if (!existsSync25(retroPath)) {
+  const retroPath = join25(root, STORY_DIR2, retroFile);
+  if (!existsSync27(retroPath)) {
     if (isJson) {
       jsonOutput({ status: "fail", epic: epicNum, retroFile, message: `${retroFile} not found` });
     } else {
@@ -7172,7 +7975,7 @@ function verifyRetro(opts, isJson, root) {
     warn(`Failed to update sprint status: ${message}`);
   }
   if (isJson) {
-    jsonOutput({ status: "ok", epic: epicNum, retroFile: join22(STORY_DIR2, retroFile) });
+    jsonOutput({ status: "ok", epic: epicNum, retroFile: join25(STORY_DIR2, retroFile) });
   } else {
     ok(`Epic ${epicNum} retrospective: marked done`);
   }
@@ -7183,8 +7986,8 @@ function verifyStory(storyId, isJson, root) {
     process.exitCode = 1;
     return;
   }
-  const readmePath = join22(root, "README.md");
-  if (!existsSync25(readmePath)) {
+  const readmePath = join25(root, "README.md");
+  if (!existsSync27(readmePath)) {
     if (isJson) {
       jsonOutput({ status: "fail", message: "No README.md found \u2014 verification requires user documentation" });
     } else {
@@ -7193,8 +7996,8 @@ function verifyStory(storyId, isJson, root) {
     process.exitCode = 1;
     return;
   }
-  const storyFilePath = join22(root, STORY_DIR2, `${storyId}.md`);
-  if (!existsSync25(storyFilePath)) {
+  const storyFilePath = join25(root, STORY_DIR2, `${storyId}.md`);
+  if (!existsSync27(storyFilePath)) {
     fail(`Story file not found: ${storyFilePath}`, { json: isJson });
     process.exitCode = 1;
     return;
@@ -7234,8 +8037,8 @@ function verifyStory(storyId, isJson, root) {
     return;
   }
   const storyTitle = extractStoryTitle(storyFilePath);
-  const expectedProofPath = join22(root, "verification", `${storyId}-proof.md`);
-  const proofPath = existsSync25(expectedProofPath) ? expectedProofPath : createProofDocument(storyId, storyTitle, acs, root);
+  const expectedProofPath = join25(root, "verification", `${storyId}-proof.md`);
+  const proofPath = existsSync27(expectedProofPath) ? expectedProofPath : createProofDocument(storyId, storyTitle, acs, root);
   const proofQuality = validateProofQuality(proofPath);
   if (!proofQuality.passed) {
     if (isJson) {
@@ -7278,7 +8081,7 @@ function verifyStory(storyId, isJson, root) {
   let observabilityGapCount = 0;
   let runtimeCoveragePercent = 0;
   try {
-    const proofContent = readFileSync23(proofPath, "utf-8");
+    const proofContent = readFileSync24(proofPath, "utf-8");
     const gapResult = parseObservabilityGaps(proofContent);
     observabilityGapCount = gapResult.gapCount;
     runtimeCoveragePercent = gapResult.totalACs === 0 ? 0 : gapResult.coveredCount / gapResult.totalACs * 100;
@@ -7340,7 +8143,7 @@ function verifyStory(storyId, isJson, root) {
 }
 function extractStoryTitle(filePath) {
   try {
-    const content = readFileSync23(filePath, "utf-8");
+    const content = readFileSync24(filePath, "utf-8");
     const match = /^#\s+(.+)$/m.exec(content);
     return match ? match[1] : "Unknown Story";
   } catch {
@@ -7349,14 +8152,14 @@ function extractStoryTitle(filePath) {
 }
 
 // src/lib/onboard-checks.ts
-import { existsSync as existsSync27 } from "fs";
-import { join as join24, dirname as dirname6 } from "path";
+import { existsSync as existsSync29 } from "fs";
+import { join as join27, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/coverage.ts
 import { execSync as execSync6 } from "child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync24 } from "fs";
-import { join as join23 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync25 } from "fs";
+import { join as join26 } from "path";
 function detectCoverageTool(dir) {
   const baseDir = dir ?? process.cwd();
   const stateHint = getStateToolHint(baseDir);
@@ -7367,6 +8170,27 @@ function detectCoverageTool(dir) {
   if (stack === "python") {
     return detectPythonCoverageTool(baseDir);
   }
+  if (stack === "rust") {
+    try {
+      execSync6("cargo tarpaulin --version", { stdio: "pipe", timeout: 1e4 });
+    } catch {
+      warn("cargo-tarpaulin not installed \u2014 coverage detection unavailable");
+      return { tool: "unknown", runCommand: "", reportFormat: "" };
+    }
+    const cargoPath = join26(baseDir, "Cargo.toml");
+    let isWorkspace = false;
+    try {
+      const cargoContent = readFileSync25(cargoPath, "utf-8");
+      isWorkspace = /^\[workspace\]/m.test(cargoContent);
+    } catch {
+    }
+    const wsFlag = isWorkspace ? " --workspace" : "";
+    return {
+      tool: "cargo-tarpaulin",
+      runCommand: `cargo tarpaulin --out json --output-dir coverage/${wsFlag}`,
+      reportFormat: "tarpaulin-json"
+    };
+  }
   warn("No recognized stack detected \u2014 cannot determine coverage tool");
   return { tool: "unknown", runCommand: "", reportFormat: "" };
 }
@@ -7379,16 +8203,16 @@ function getStateToolHint(dir) {
   }
 }
 function detectNodeCoverageTool(dir, stateHint) {
-  const hasVitestConfig = existsSync26(join23(dir, "vitest.config.ts")) || existsSync26(join23(dir, "vitest.config.js"));
-  const pkgPath = join23(dir, "package.json");
+  const hasVitestConfig = existsSync28(join26(dir, "vitest.config.ts")) || existsSync28(join26(dir, "vitest.config.js"));
+  const pkgPath = join26(dir, "package.json");
   let hasVitestCoverageV8 = false;
   let hasVitestCoverageIstanbul = false;
   let hasC8 = false;
   let hasJest = false;
   let pkgScripts = {};
-  if (existsSync26(pkgPath)) {
+  if (existsSync28(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync24(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync25(pkgPath, "utf-8"));
       const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
       hasVitestCoverageV8 = "@vitest/coverage-v8" in allDeps;
       hasVitestCoverageIstanbul = "@vitest/coverage-istanbul" in allDeps;
@@ -7441,10 +8265,10 @@ function getNodeTestCommand(scripts, runner) {
   return "npm test";
 }
 function detectPythonCoverageTool(dir) {
-  const reqPath = join23(dir, "requirements.txt");
-  if (existsSync26(reqPath)) {
+  const reqPath = join26(dir, "requirements.txt");
+  if (existsSync28(reqPath)) {
     try {
-      const content = readFileSync24(reqPath, "utf-8");
+      const content = readFileSync25(reqPath, "utf-8");
       if (content.includes("pytest-cov") || content.includes("coverage")) {
         return {
           tool: "coverage.py",
@@ -7455,10 +8279,10 @@ function detectPythonCoverageTool(dir) {
     } catch {
     }
   }
-  const pyprojectPath = join23(dir, "pyproject.toml");
-  if (existsSync26(pyprojectPath)) {
+  const pyprojectPath = join26(dir, "pyproject.toml");
+  if (existsSync28(pyprojectPath)) {
     try {
-      const content = readFileSync24(pyprojectPath, "utf-8");
+      const content = readFileSync25(pyprojectPath, "utf-8");
       if (content.includes("pytest-cov") || content.includes("coverage")) {
         return {
           tool: "coverage.py",
@@ -7531,6 +8355,9 @@ function parseCoverageReport(dir, format) {
   if (format === "coverage-py-json") {
     return parsePythonCoverage(dir);
   }
+  if (format === "tarpaulin-json") {
+    return parseTarpaulinCoverage(dir);
+  }
   return 0;
 }
 function parseVitestCoverage(dir) {
@@ -7540,7 +8367,7 @@ function parseVitestCoverage(dir) {
     return 0;
   }
   try {
-    const report = JSON.parse(readFileSync24(reportPath, "utf-8"));
+    const report = JSON.parse(readFileSync25(reportPath, "utf-8"));
     return report.total?.statements?.pct ?? 0;
   } catch {
     warn("Failed to parse coverage report");
@@ -7548,19 +8375,33 @@ function parseVitestCoverage(dir) {
   }
 }
 function parsePythonCoverage(dir) {
-  const reportPath = join23(dir, "coverage.json");
-  if (!existsSync26(reportPath)) {
+  const reportPath = join26(dir, "coverage.json");
+  if (!existsSync28(reportPath)) {
     warn("Coverage report not found at coverage.json");
     return 0;
   }
   try {
-    const report = JSON.parse(readFileSync24(reportPath, "utf-8"));
+    const report = JSON.parse(readFileSync25(reportPath, "utf-8"));
     return report.totals?.percent_covered ?? 0;
   } catch {
     warn("Failed to parse coverage report");
     return 0;
   }
 }
+function parseTarpaulinCoverage(dir) {
+  const reportPath = join26(dir, "coverage", "tarpaulin-report.json");
+  if (!existsSync28(reportPath)) {
+    warn("Tarpaulin report not found at coverage/tarpaulin-report.json");
+    return 0;
+  }
+  try {
+    const report = JSON.parse(readFileSync25(reportPath, "utf-8"));
+    return report.coverage ?? 0;
+  } catch {
+    warn("Failed to parse tarpaulin coverage report");
+    return 0;
+  }
+}
 function parseTestCounts(output) {
   const vitestMatch = /Tests\s+(\d+)\s+passed(?:\s*\|\s*(\d+)\s+failed)?/i.exec(output);
   if (vitestMatch) {
@@ -7576,6 +8417,18 @@ function parseTestCounts(output) {
       failCount: jestMatch[1] ? parseInt(jestMatch[1], 10) : 0
     };
   }
+  const cargoRegex = /test result:.*?(\d+)\s+passed;\s*(\d+)\s+failed/gi;
+  let cargoMatch = cargoRegex.exec(output);
+  if (cargoMatch) {
+    let totalPass = 0;
+    let totalFail = 0;
+    while (cargoMatch) {
+      totalPass += parseInt(cargoMatch[1], 10);
+      totalFail += parseInt(cargoMatch[2], 10);
+      cargoMatch = cargoRegex.exec(output);
+    }
+    return { passCount: totalPass, failCount: totalFail };
+  }
   const pytestMatch = /(\d+)\s+passed(?:,\s*(\d+)\s+failed)?/i.exec(output);
   if (pytestMatch) {
     return {
@@ -7655,7 +8508,7 @@ function checkPerFileCoverage(floor, dir) {
   }
   let report;
   try {
-    report = JSON.parse(readFileSync24(reportPath, "utf-8"));
+    report = JSON.parse(readFileSync25(reportPath, "utf-8"));
   } catch {
     warn("Failed to parse coverage-summary.json");
     return { floor, violations: [], totalFiles: 0 };
@@ -7685,11 +8538,11 @@ function checkPerFileCoverage(floor, dir) {
 }
 function findCoverageSummary(dir) {
   const candidates = [
-    join23(dir, "coverage", "coverage-summary.json"),
-    join23(dir, "src", "coverage", "coverage-summary.json")
+    join26(dir, "coverage", "coverage-summary.json"),
+    join26(dir, "src", "coverage", "coverage-summary.json")
   ];
   for (const p of candidates) {
-    if (existsSync26(p)) return p;
+    if (existsSync28(p)) return p;
   }
   return null;
 }
@@ -7714,7 +8567,7 @@ function printCoverageOutput(result, evaluation) {
 // src/lib/onboard-checks.ts
 function checkHarnessInitialized(dir) {
   const statePath2 = getStatePath(dir ?? process.cwd());
-  return { ok: existsSync27(statePath2) };
+  return { ok: existsSync29(statePath2) };
 }
 function checkBmadInstalled(dir) {
   return { ok: isBmadInstalled(dir) };
@@ -7722,8 +8575,8 @@ function checkBmadInstalled(dir) {
 function checkHooksRegistered(dir) {
   const __filename = fileURLToPath3(import.meta.url);
   const __dirname2 = dirname6(__filename);
-  const hooksPath = join24(__dirname2, "..", "..", "hooks", "hooks.json");
-  return { ok: existsSync27(hooksPath) };
+  const hooksPath = join27(__dirname2, "..", "..", "hooks", "hooks.json");
+  return { ok: existsSync29(hooksPath) };
 }
 function runPreconditions(dir) {
   const harnessCheck = checkHarnessInitialized(dir);
@@ -8361,8 +9214,8 @@ function getBeadsData() {
 }
 
 // src/modules/audit/dimensions.ts
-import { existsSync as existsSync28, readFileSync as readFileSync25, readdirSync as readdirSync6 } from "fs";
-import { join as join25 } from "path";
+import { existsSync as existsSync30, readdirSync as readdirSync7 } from "fs";
+import { join as join28 } from "path";
 function gap(dimension, description, suggestedFix) {
   return { dimension, description, suggestedFix };
 }
@@ -8474,15 +9327,15 @@ function checkDocumentation(projectDir) {
 function checkVerification(projectDir) {
   try {
     const gaps = [];
-    const sprintPath = join25(projectDir, "_bmad-output", "implementation-artifacts", "sprint-status.yaml");
-    if (!existsSync28(sprintPath)) return dimOk("verification", "warn", "no sprint data", [gap("verification", "No sprint-status.yaml found", "Run sprint planning to create sprint status")]);
-    const vDir = join25(projectDir, "verification");
+    const sprintPath = join28(projectDir, "_bmad-output", "implementation-artifacts", "sprint-status.yaml");
+    if (!existsSync30(sprintPath)) return dimOk("verification", "warn", "no sprint data", [gap("verification", "No sprint-status.yaml found", "Run sprint planning to create sprint status")]);
+    const vDir = join28(projectDir, "verification");
     let proofCount = 0, totalChecked = 0;
-    if (existsSync28(vDir)) {
+    if (existsSync30(vDir)) {
       for (const file of readdirSafe(vDir)) {
         if (!file.endsWith("-proof.md")) continue;
         totalChecked++;
-        const r = parseProof(join25(vDir, file));
+        const r = parseProof(join28(vDir, file));
         if (isOk(r) && r.data.passed) {
           proofCount++;
         } else {
@@ -8504,30 +9357,21 @@ function checkVerification(projectDir) {
 }
 function checkInfrastructure(projectDir) {
   try {
-    const dfPath = join25(projectDir, "Dockerfile");
-    if (!existsSync28(dfPath)) return dimOk("infrastructure", "fail", "no Dockerfile", [gap("infrastructure", "No Dockerfile found", "Create a Dockerfile for containerized deployment")]);
-    let content;
-    try {
-      content = readFileSync25(dfPath, "utf-8");
-    } catch {
-      return dimOk("infrastructure", "warn", "Dockerfile unreadable", [gap("infrastructure", "Dockerfile exists but could not be read", "Check Dockerfile permissions")]);
-    }
-    const fromLines = content.split("\n").filter((l) => /^\s*FROM\s+/i.test(l));
-    if (fromLines.length === 0) return dimOk("infrastructure", "fail", "invalid Dockerfile", [gap("infrastructure", "Dockerfile has no FROM instruction", "Add a FROM instruction with a pinned base image")]);
-    const gaps = [];
-    let hasUnpinned = false;
-    for (const line of fromLines) {
-      const ref = line.replace(/^\s*FROM\s+/i, "").split(/\s+/)[0];
-      if (ref.endsWith(":latest")) {
-        hasUnpinned = true;
-        gaps.push(gap("infrastructure", `Unpinned base image: ${ref}`, `Pin ${ref} to a specific version tag`));
-      } else if (!ref.includes(":") && !ref.includes("@")) {
-        hasUnpinned = true;
-        gaps.push(gap("infrastructure", `Unpinned base image (no tag): ${ref}`, `Pin ${ref} to a specific version tag (e.g., ${ref}:22-slim)`));
-      }
-    }
-    const status = hasUnpinned ? "warn" : "pass";
-    const metric = hasUnpinned ? `Dockerfile exists (${gaps.length} issue${gaps.length !== 1 ? "s" : ""})` : "Dockerfile valid";
+    const result = validateDockerfile(projectDir);
+    if (!result.success) {
+      const err = result.error;
+      if (err.includes("No Dockerfile")) return dimOk("infrastructure", "fail", "no Dockerfile", [gap("infrastructure", "No Dockerfile found", "Create a Dockerfile for containerized deployment")]);
+      if (err.includes("could not be read")) return dimOk("infrastructure", "warn", "Dockerfile unreadable", [gap("infrastructure", "Dockerfile exists but could not be read", "Check Dockerfile permissions")]);
+      if (err.includes("no FROM")) return dimOk("infrastructure", "fail", "invalid Dockerfile", [gap("infrastructure", "Dockerfile has no FROM instruction", "Add a FROM instruction with a pinned base image")]);
+      return dimOk("infrastructure", "fail", "validation failed", [gap("infrastructure", err, "Fix Dockerfile validation errors")]);
+    }
+    const gaps = result.data.gaps.map((g) => gap("infrastructure", g.description, g.suggestedFix));
+    for (const w of result.data.warnings) {
+      gaps.push(gap("infrastructure", w, "Provide the missing configuration file"));
+    }
+    const issueCount = gaps.length;
+    const status = issueCount > 0 ? "warn" : "pass";
+    const metric = issueCount > 0 ? `Dockerfile exists (${issueCount} issue${issueCount !== 1 ? "s" : ""})` : "Dockerfile valid";
     return dimOk("infrastructure", status, metric, gaps);
   } catch (err) {
     return dimCatch("infrastructure", err);
@@ -8535,7 +9379,7 @@ function checkInfrastructure(projectDir) {
 }
 function readdirSafe(dir) {
   try {
-    return readdirSync6(dir);
+    return readdirSync7(dir);
   } catch {
     return [];
   }
@@ -8568,8 +9412,8 @@ function formatAuditJson(result) {
 }
 
 // src/modules/audit/fix-generator.ts
-import { existsSync as existsSync29, writeFileSync as writeFileSync15, mkdirSync as mkdirSync9 } from "fs";
-import { join as join26, dirname as dirname7 } from "path";
+import { existsSync as existsSync31, writeFileSync as writeFileSync16, mkdirSync as mkdirSync9 } from "fs";
+import { join as join29, dirname as dirname7 } from "path";
 function buildStoryKey(gap2, index) {
   const safeDimension = gap2.dimension.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
   return `audit-fix-${safeDimension}-${index}`;
@@ -8601,7 +9445,7 @@ function generateFixStories(auditResult) {
     const stories = [];
     let created = 0;
     let skipped = 0;
-    const artifactsDir = join26(
+    const artifactsDir = join29(
       process.cwd(),
       "_bmad-output",
       "implementation-artifacts"
@@ -8610,8 +9454,8 @@ function generateFixStories(auditResult) {
       for (let i = 0; i < dimension.gaps.length; i++) {
         const gap2 = dimension.gaps[i];
         const key = buildStoryKey(gap2, i + 1);
-        const filePath = join26(artifactsDir, `${key}.md`);
-        if (existsSync29(filePath)) {
+        const filePath = join29(artifactsDir, `${key}.md`);
+        if (existsSync31(filePath)) {
           stories.push({
             key,
             filePath,
@@ -8624,7 +9468,7 @@ function generateFixStories(auditResult) {
         }
         const markdown = buildStoryMarkdown(gap2, key);
         mkdirSync9(dirname7(filePath), { recursive: true });
-        writeFileSync15(filePath, markdown, "utf-8");
+        writeFileSync16(filePath, markdown, "utf-8");
         stories.push({ key, filePath, gap: gap2, skipped: false });
         created++;
       }
@@ -8800,8 +9644,8 @@ function registerOnboardCommand(program) {
 }
 
 // src/commands/teardown.ts
-import { existsSync as existsSync30, unlinkSync as unlinkSync2, readFileSync as readFileSync26, writeFileSync as writeFileSync16, rmSync as rmSync2 } from "fs";
-import { join as join27 } from "path";
+import { existsSync as existsSync32, unlinkSync as unlinkSync2, readFileSync as readFileSync26, writeFileSync as writeFileSync17, rmSync as rmSync2 } from "fs";
+import { join as join30 } from "path";
 function buildDefaultResult() {
   return {
     status: "ok",
@@ -8904,16 +9748,16 @@ function registerTeardownCommand(program) {
           info("Docker stack: not running, skipping");
         }
       }
-      const composeFilePath = join27(projectDir, composeFile);
-      if (existsSync30(composeFilePath)) {
+      const composeFilePath = join30(projectDir, composeFile);
+      if (existsSync32(composeFilePath)) {
         unlinkSync2(composeFilePath);
         result.removed.push(composeFile);
         if (!isJson) {
           ok(`Removed: ${composeFile}`);
         }
       }
-      const otelConfigPath = join27(projectDir, "otel-collector-config.yaml");
-      if (existsSync30(otelConfigPath)) {
+      const otelConfigPath = join30(projectDir, "otel-collector-config.yaml");
+      if (existsSync32(otelConfigPath)) {
         unlinkSync2(otelConfigPath);
         result.removed.push("otel-collector-config.yaml");
         if (!isJson) {
@@ -8923,8 +9767,8 @@ function registerTeardownCommand(program) {
     }
     let patchesRemoved = 0;
     for (const [patchName, relativePath] of Object.entries(PATCH_TARGETS)) {
-      const filePath = join27(projectDir, "_bmad", relativePath);
-      if (!existsSync30(filePath)) {
+      const filePath = join30(projectDir, "_bmad", relativePath);
+      if (!existsSync32(filePath)) {
         continue;
       }
       try {
@@ -8943,9 +9787,9 @@ function registerTeardownCommand(program) {
         info("BMAD patches: none found");
       }
     }
-    if (state.otlp?.enabled && state.stack === "nodejs") {
-      const pkgPath = join27(projectDir, "package.json");
-      if (existsSync30(pkgPath)) {
+    if (state.otlp?.enabled && (state.stacks?.includes("nodejs") ?? state.stack === "nodejs")) {
+      const pkgPath = join30(projectDir, "package.json");
+      if (existsSync32(pkgPath)) {
         try {
           const raw = readFileSync26(pkgPath, "utf-8");
           const pkg = JSON.parse(raw);
@@ -8961,7 +9805,7 @@ function registerTeardownCommand(program) {
               for (const key of keysToRemove) {
                 delete scripts[key];
               }
-              writeFileSync16(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+              writeFileSync17(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
               result.otlp_cleaned = true;
               if (!isJson) {
                 ok("OTLP: removed instrumented scripts from package.json");
@@ -8987,8 +9831,8 @@ function registerTeardownCommand(program) {
         }
       }
     }
-    const harnessDir = join27(projectDir, ".harness");
-    if (existsSync30(harnessDir)) {
+    const harnessDir = join30(projectDir, ".harness");
+    if (existsSync32(harnessDir)) {
       rmSync2(harnessDir, { recursive: true, force: true });
       result.removed.push(".harness/");
       if (!isJson) {
@@ -8996,7 +9840,7 @@ function registerTeardownCommand(program) {
       }
     }
     const statePath2 = getStatePath(projectDir);
-    if (existsSync30(statePath2)) {
+    if (existsSync32(statePath2)) {
       unlinkSync2(statePath2);
       result.removed.push(".claude/codeharness.local.md");
       if (!isJson) {
@@ -9740,8 +10584,8 @@ function registerQueryCommand(program) {
 }
 
 // src/commands/retro-import.ts
-import { existsSync as existsSync31, readFileSync as readFileSync27 } from "fs";
-import { join as join28 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync27 } from "fs";
+import { join as join31 } from "path";
 
 // src/lib/retro-parser.ts
 var KNOWN_TOOLS = ["showboat", "ralph", "beads", "bmad"];
@@ -9910,8 +10754,8 @@ function registerRetroImportCommand(program) {
       return;
     }
     const retroFile = `epic-${epicNum}-retrospective.md`;
-    const retroPath = join28(root, STORY_DIR3, retroFile);
-    if (!existsSync31(retroPath)) {
+    const retroPath = join31(root, STORY_DIR3, retroFile);
+    if (!existsSync33(retroPath)) {
       fail(`Retro file not found: ${retroFile}`, { json: isJson });
       process.exitCode = 1;
       return;
@@ -10299,23 +11143,23 @@ function registerVerifyEnvCommand(program) {
 }
 
 // src/commands/retry.ts
-import { join as join30 } from "path";
+import { join as join33 } from "path";
 
 // src/lib/retry-state.ts
-import { existsSync as existsSync32, readFileSync as readFileSync28, writeFileSync as writeFileSync17 } from "fs";
-import { join as join29 } from "path";
+import { existsSync as existsSync34, readFileSync as readFileSync28, writeFileSync as writeFileSync18 } from "fs";
+import { join as join32 } from "path";
 var RETRIES_FILE = ".story_retries";
 var FLAGGED_FILE = ".flagged_stories";
 var LINE_PATTERN = /^([^=]+)=(\d+)$/;
 function retriesPath(dir) {
-  return join29(dir, RETRIES_FILE);
+  return join32(dir, RETRIES_FILE);
 }
 function flaggedPath(dir) {
-  return join29(dir, FLAGGED_FILE);
+  return join32(dir, FLAGGED_FILE);
 }
 function readRetries(dir) {
   const filePath = retriesPath(dir);
-  if (!existsSync32(filePath)) {
+  if (!existsSync34(filePath)) {
     return /* @__PURE__ */ new Map();
   }
   const raw = readFileSync28(filePath, "utf-8");
@@ -10340,7 +11184,7 @@ function writeRetries(dir, retries) {
   for (const [key, count] of retries) {
     lines.push(`${key}=${count}`);
   }
-  writeFileSync17(filePath, lines.length > 0 ? lines.join("\n") + "\n" : "", "utf-8");
+  writeFileSync18(filePath, lines.length > 0 ? lines.join("\n") + "\n" : "", "utf-8");
 }
 function resetRetry(dir, storyKey) {
   if (storyKey) {
@@ -10355,7 +11199,7 @@ function resetRetry(dir, storyKey) {
 }
 function readFlaggedStories(dir) {
   const filePath = flaggedPath(dir);
-  if (!existsSync32(filePath)) {
+  if (!existsSync34(filePath)) {
     return [];
   }
   const raw = readFileSync28(filePath, "utf-8");
@@ -10363,7 +11207,7 @@ function readFlaggedStories(dir) {
 }
 function writeFlaggedStories(dir, stories) {
   const filePath = flaggedPath(dir);
-  writeFileSync17(filePath, stories.length > 0 ? stories.join("\n") + "\n" : "", "utf-8");
+  writeFileSync18(filePath, stories.length > 0 ? stories.join("\n") + "\n" : "", "utf-8");
 }
 function removeFlaggedStory(dir, key) {
   const stories = readFlaggedStories(dir);
@@ -10383,7 +11227,7 @@ function registerRetryCommand(program) {
   program.command("retry").description("Manage retry state for stories").option("--reset", "Clear retry counters and flagged stories").option("--story <key>", "Target a specific story key (used with --reset or --status)").option("--status", "Show retry status for all stories").action((_options, cmd) => {
     const opts = cmd.optsWithGlobals();
     const isJson = opts.json === true;
-    const dir = join30(process.cwd(), RALPH_SUBDIR);
+    const dir = join33(process.cwd(), RALPH_SUBDIR);
     if (opts.story && !isValidStoryKey3(opts.story)) {
       if (isJson) {
         jsonOutput({ status: "fail", message: `Invalid story key: ${opts.story}` });
@@ -10792,7 +11636,7 @@ function registerAuditCommand(program) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.23.0" : "0.0.0-dev";
+var VERSION = true ? "0.24.1" : "0.0.0-dev";
 function createProgram() {
   const program = new Command();
   program.name("codeharness").description("Makes autonomous coding agents produce software that actually works").version(VERSION).option("--json", "Output in machine-readable JSON format");
@@ -10826,5 +11670,6 @@ if (!process.env["VITEST"]) {
   program.parse(process.argv);
 }
 export {
-  createProgram
+  createProgram,
+  parseStreamLine
 };