codeharness 0.19.1 → 0.19.3

package/dist/index.js

@@ -1387,7 +1387,7 @@ function getInstallCommand(stack) {
 }
 
 // src/commands/init.ts
-var HARNESS_VERSION = true ? "0.19.1" : "0.0.0-dev";
+var HARNESS_VERSION = true ? "0.19.3" : "0.0.0-dev";
 function getProjectName(projectDir) {
   try {
     const pkgPath = join7(projectDir, "package.json");
@@ -1501,8 +1501,8 @@ function registerInitCommand(program) {
         readme: "skipped"
       }
     };
-    const statePath = getStatePath(projectDir);
-    if (existsSync7(statePath)) {
+    const statePath2 = getStatePath(projectDir);
+    if (existsSync7(statePath2)) {
       try {
         const existingState = readState(projectDir);
         const legacyObsDisabled = existingState.enforcement.observability === false;
@@ -2586,7 +2586,7 @@ function buildSpawnArgs(opts) {
   return args;
 }
 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", "14400").option("--iteration-timeout <minutes>", "Per-iteration timeout in minutes", "30").option("--live", "Show live output streaming", 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) => {
+  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("--live", "Show live output streaming", 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) => {
     const globalOpts = cmd.optsWithGlobals();
     const isJson = !!globalOpts.json;
     const outputOpts = { json: isJson };
@@ -2668,12 +2668,12 @@ function registerRunCommand(program) {
         cwd: projectDir,
         env
       });
-      const exitCode = await new Promise((resolve, reject) => {
+      const exitCode = await new Promise((resolve3, reject) => {
         child.on("error", (err) => {
           reject(err);
         });
         child.on("close", (code) => {
-          resolve(code ?? 1);
+          resolve3(code ?? 1);
         });
       });
       if (isJson) {
@@ -2730,223 +2730,330 @@ function registerRunCommand(program) {
 }
 
 // src/commands/verify.ts
-import { existsSync as existsSync14, readFileSync as readFileSync13 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
+import { join as join13 } from "path";
 
-// src/lib/verify-parser.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
-var UI_KEYWORDS = [
-  "agent-browser",
-  "screenshot",
-  "navigate",
-  "click",
-  "form",
-  "ui verification",
-  "ui acceptance"
-];
-var API_KEYWORDS = [
-  "http",
-  "api",
-  "endpoint",
-  "curl",
-  "rest",
-  "response bod"
-];
-var DB_KEYWORDS = [
-  "database",
-  "db state",
-  "db mcp",
-  "query",
-  "sql",
-  "table"
-];
-var INTEGRATION_KEYWORDS = [
-  "external system",
-  "real infrastructure",
-  "manual verification"
-];
-var ESCALATE_KEYWORDS = [
-  "physical hardware",
-  "manual human",
-  "visual inspection by human",
-  "paid external service"
-];
-function classifyVerifiability(description) {
-  const lower = description.toLowerCase();
-  for (const kw of INTEGRATION_KEYWORDS) {
-    if (lower.includes(kw)) return "integration-required";
-  }
-  return "cli-verifiable";
+// src/types/result.ts
+function ok2(data) {
+  return { success: true, data };
 }
-function classifyStrategy(description) {
-  const lower = description.toLowerCase();
-  for (const kw of ESCALATE_KEYWORDS) {
-    if (lower.includes(kw)) return "escalate";
+function fail2(error, context) {
+  if (context !== void 0) {
+    return { success: false, error, context };
   }
-  return "docker";
-}
-var VERIFICATION_TAG_PATTERN = /<!--\s*verification:\s*(cli-verifiable|integration-required)\s*-->/;
-function parseVerificationTag(text) {
-  const match = VERIFICATION_TAG_PATTERN.exec(text);
-  return match ? match[1] : null;
+  return { success: false, error };
 }
-function classifyAC(description) {
-  const lower = description.toLowerCase();
-  for (const kw of UI_KEYWORDS) {
-    if (lower.includes(kw)) return "ui";
-  }
-  for (const kw of API_KEYWORDS) {
-    if (lower.includes(kw)) return "api";
-  }
-  for (const kw of DB_KEYWORDS) {
-    if (lower.includes(kw)) return "db";
+
+// src/modules/verify/proof.ts
+import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
+function classifyEvidenceCommands(proofContent) {
+  const results = [];
+  const codeBlockPattern = /```(?:bash|shell)\n([\s\S]*?)```/g;
+  for (const match of proofContent.matchAll(codeBlockPattern)) {
+    const block = match[1].trim();
+    const lines = block.split("\n").filter((l) => l.trim().length > 0);
+    for (const line of lines) {
+      const cmd = line.trim();
+      if (!cmd) continue;
+      results.push({ command: cmd, type: classifyCommand(cmd) });
+    }
   }
-  return "general";
+  return results;
 }
-function parseStoryACs(storyFilePath) {
-  if (!existsSync11(storyFilePath)) {
-    throw new Error(
-      `Story file not found: ${storyFilePath}. Ensure the story file exists at the expected path.`
-    );
-  }
-  const content = readFileSync10(storyFilePath, "utf-8");
-  const lines = content.split("\n");
-  let acSectionStart = -1;
-  for (let i = 0; i < lines.length; i++) {
-    if (/^##\s+Acceptance\s+Criteria/i.test(lines[i])) {
-      acSectionStart = i + 1;
-      break;
-    }
+function classifyCommand(cmd) {
+  if (/docker\s+exec\b/.test(cmd)) {
+    return "docker-exec";
   }
-  if (acSectionStart === -1) {
-    warn('No "## Acceptance Criteria" section found in story file');
-    return [];
+  if (/docker\s+(ps|logs|inspect|stats|top|port)\b/.test(cmd)) {
+    return "docker-host";
   }
-  let acSectionEnd = lines.length;
-  for (let i = acSectionStart; i < lines.length; i++) {
-    if (/^##\s+/.test(lines[i]) && i !== acSectionStart - 1) {
-      acSectionEnd = i;
-      break;
-    }
+  if (/curl\b/.test(cmd) && /localhost:(9428|8428|16686)\b/.test(cmd)) {
+    return "observability";
   }
-  const acSection = lines.slice(acSectionStart, acSectionEnd).join("\n");
-  const acPattern = /^\s*(\d+)\.\s+/;
-  const acs = [];
-  const acLines = acSection.split("\n");
-  let currentId = null;
-  let currentDesc = [];
-  const flushCurrent = () => {
-    if (currentId !== null && currentDesc.length > 0) {
-      const description = currentDesc.join(" ").trim();
-      if (description) {
-        const tag = parseVerificationTag(description);
-        const verifiability = tag ?? classifyVerifiability(description);
-        const strategy = classifyStrategy(description);
-        acs.push({
-          id: currentId,
-          description,
-          type: classifyAC(description),
-          verifiability,
-          strategy
-        });
-      } else {
-        warn(`Skipping malformed AC #${currentId}: empty description`);
-      }
-    }
-  };
-  for (const line of acLines) {
-    const match = acPattern.exec(line);
-    if (match) {
-      flushCurrent();
-      currentId = match[1];
-      currentDesc = [line.replace(acPattern, "").trim()];
-    } else if (currentId !== null && line.trim()) {
-      currentDesc.push(line.trim());
-    }
+  if (/\bgrep\b/.test(cmd) && /\bsrc\//.test(cmd)) {
+    return "grep-src";
   }
-  flushCurrent();
-  return acs;
+  return "other";
 }
-
-// src/lib/verify.ts
-import { execFileSync as execFileSync5 } from "child_process";
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "fs";
-import { join as join11 } from "path";
-
-// src/lib/doc-health.ts
-import { execSync } from "child_process";
-import {
-  existsSync as existsSync12,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync11,
-  readdirSync as readdirSync2,
-  statSync,
-  unlinkSync,
-  writeFileSync as writeFileSync7
-} from "fs";
-import { join as join10, 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;
-function findModules(dir, threshold) {
-  const limit = threshold ?? DEFAULT_MODULE_THRESHOLD;
-  const root = dir;
-  const modules = [];
-  function walk(current) {
-    let entries;
-    try {
-      entries = readdirSync2(current);
-    } catch {
-      return;
-    }
-    const dirName = current.split("/").pop() ?? "";
-    if (dirName === "node_modules" || dirName === ".git" || dirName === "dist" || dirName === "coverage" || dirName.startsWith(".") && current !== root) {
-      return;
-    }
-    let sourceCount = 0;
-    const subdirs = [];
-    for (const entry of entries) {
-      const fullPath = join10(current, entry);
-      let stat;
-      try {
-        stat = statSync(fullPath);
-      } catch {
-        continue;
-      }
-      if (stat.isDirectory()) {
-        subdirs.push(fullPath);
-      } else if (stat.isFile()) {
-        const ext = getExtension(entry);
-        if (SOURCE_EXTENSIONS.has(ext) && !isTestFile(entry)) {
-          sourceCount++;
-        }
-      }
-    }
-    if (sourceCount >= limit) {
-      const rel = relative(root, current);
-      if (rel !== "") {
-        modules.push(rel);
+function checkBlackBoxEnforcement(proofContent) {
+  const commands = classifyEvidenceCommands(proofContent);
+  const grepSrcCount = commands.filter((c) => c.type === "grep-src").length;
+  const dockerExecCount = commands.filter((c) => c.type === "docker-exec").length;
+  const observabilityCount = commands.filter((c) => c.type === "observability").length;
+  const otherCount = commands.filter((c) => c.type === "other").length;
+  const totalCommands = commands.length;
+  const grepRatio = totalCommands > 0 ? grepSrcCount / totalCommands : 0;
+  const acsMissingDockerExec = [];
+  const acHeaderPattern = /^## AC ?(\d+):/gm;
+  const acMatches = [...proofContent.matchAll(acHeaderPattern)];
+  if (acMatches.length > 0) {
+    for (let i = 0; i < acMatches.length; i++) {
+      const acNum = parseInt(acMatches[i][1], 10);
+      const start = acMatches[i].index;
+      const end = i + 1 < acMatches.length ? acMatches[i + 1].index : proofContent.length;
+      const section = proofContent.slice(start, end);
+      if (section.includes("[ESCALATE]")) continue;
+      const sectionCommands = classifyEvidenceCommands(section);
+      const hasBlackBoxEvidence = sectionCommands.some(
+        (c) => c.type === "docker-exec" || c.type === "docker-host" || c.type === "observability"
+      );
+      if (!hasBlackBoxEvidence) {
+        acsMissingDockerExec.push(acNum);
       }
     }
-    for (const subdir of subdirs) {
-      walk(subdir);
-    }
   }
-  walk(root);
-  return modules;
-}
-function getExtension(filename) {
-  const dot = filename.lastIndexOf(".");
-  return dot >= 0 ? filename.slice(dot) : "";
+  const grepTooHigh = grepRatio > 0.5;
+  const missingDockerExec = acsMissingDockerExec.length > 0;
+  const hasExtractableCommands = totalCommands > 0;
+  return {
+    blackBoxPass: !hasExtractableCommands || !grepTooHigh && !missingDockerExec,
+    grepSrcCount,
+    dockerExecCount,
+    observabilityCount,
+    otherCount,
+    grepRatio,
+    acsMissingDockerExec
+  };
 }
-function isTestFile(filename) {
-  return filename.includes(".test.") || filename.includes(".spec.") || filename.includes("__tests__") || filename.startsWith("test_");
+function hasFailVerdict(section) {
+  return section.replace(/```[\s\S]*?```/g, "").replace(/`[^`]+`/g, "").includes("[FAIL]");
 }
-function isDocStale(docPath, codeDir) {
-  if (!existsSync12(docPath)) return true;
-  if (!existsSync12(codeDir)) return false;
-  const docMtime = statSync(docPath).mtime;
-  const newestCode = getNewestSourceMtime(codeDir);
+function validateProofQuality(proofPath) {
+  const emptyResult = {
+    verified: 0,
+    pending: 0,
+    escalated: 0,
+    total: 0,
+    passed: false,
+    grepSrcCount: 0,
+    dockerExecCount: 0,
+    observabilityCount: 0,
+    otherCount: 0,
+    blackBoxPass: false
+  };
+  if (!existsSync11(proofPath)) {
+    return emptyResult;
+  }
+  const content = readFileSync10(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);
+  function buildResult(base) {
+    const basePassed = base.pending === 0 && base.verified > 0;
+    return {
+      ...base,
+      passed: basePassed && bbEnforcement.blackBoxPass,
+      grepSrcCount: bbEnforcement.grepSrcCount,
+      dockerExecCount: bbEnforcement.dockerExecCount,
+      observabilityCount: bbEnforcement.observabilityCount,
+      otherCount: bbEnforcement.otherCount,
+      blackBoxPass: bbEnforcement.blackBoxPass
+    };
+  }
+  const acHeaderPattern = /^## AC ?(\d+):/gm;
+  const matches = [...content.matchAll(acHeaderPattern)];
+  const nonAcHeadingPattern = /^## (?!AC ?\d+:)/gm;
+  const nonAcHeadings = [...content.matchAll(nonAcHeadingPattern)].map((m) => m.index);
+  let verified = 0;
+  let pending = 0;
+  let escalated = 0;
+  if (matches.length > 0) {
+    for (let i = 0; i < matches.length; i++) {
+      const start = matches[i].index;
+      const nextAcEnd = i + 1 < matches.length ? matches[i + 1].index : content.length;
+      const nextNonAcHeading = nonAcHeadings.find((h) => h > start);
+      const end = nextNonAcHeading !== void 0 && nextNonAcHeading < nextAcEnd ? nextNonAcHeading : nextAcEnd;
+      const section = content.slice(start, end);
+      if (section.includes("[ESCALATE]")) {
+        escalated++;
+        continue;
+      }
+      if (hasFailVerdict(section)) {
+        pending++;
+        continue;
+      }
+      const hasEvidence = section.includes("<!-- /showboat exec -->") || section.includes("<!-- showboat image:") || /```(?:bash|shell)\n[\s\S]*?```\n+```output\n/m.test(section);
+      if (hasEvidence) {
+        verified++;
+      } else {
+        pending++;
+      }
+    }
+  } else {
+    const inlineAcPattern = /--- AC ?(\d+):/g;
+    const inlineMatches = [...content.matchAll(inlineAcPattern)];
+    const acNumbers = new Set(inlineMatches.map((m) => m[1]));
+    if (acNumbers.size === 0) {
+      const narrativeAcPattern = /=== AC ?(\d+):/g;
+      const narrativeMatches = [...content.matchAll(narrativeAcPattern)];
+      const narrativeAcNumbers = new Set(narrativeMatches.map((m) => m[1]));
+      if (narrativeAcNumbers.size === 0) {
+        const bulletAcPattern = /^- AC ?(\d+)[^:\n]*:/gm;
+        const bulletMatches = [...content.matchAll(bulletAcPattern)];
+        const bulletAcNumbers = new Set(bulletMatches.map((m) => m[1]));
+        if (bulletAcNumbers.size === 0) {
+          return buildResult({ verified: 0, pending: 0, escalated: 0, total: 0 });
+        }
+        let bVerified = 0;
+        let bPending = 0;
+        let bEscalated = 0;
+        for (const acNum of bulletAcNumbers) {
+          const bulletPattern = new RegExp(`^- AC ?${acNum}[^:\\n]*:(.*)$`, "m");
+          const bulletMatch = content.match(bulletPattern);
+          if (!bulletMatch) {
+            bPending++;
+            continue;
+          }
+          const bulletText = bulletMatch[1].toLowerCase();
+          if (bulletText.includes("n/a") || bulletText.includes("escalat") || bulletText.includes("superseded")) {
+            bEscalated++;
+          } else if (bulletText.includes("fail")) {
+            bPending++;
+          } else {
+            bVerified++;
+          }
+        }
+        const hasAnyEvidence = /```output\n/m.test(content);
+        if (!hasAnyEvidence) {
+          bPending += bVerified;
+          bVerified = 0;
+        }
+        const bTotal = bVerified + bPending + bEscalated;
+        return buildResult({
+          verified: bVerified,
+          pending: bPending,
+          escalated: bEscalated,
+          total: bTotal
+        });
+      }
+      const sortedAcs = narrativeMatches.map((m) => ({ num: m[1], idx: m.index })).filter((v, i, a) => a.findIndex((x) => x.num === v.num) === i).sort((a, b) => a.idx - b.idx);
+      for (let i = 0; i < sortedAcs.length; i++) {
+        const regionStart = i > 0 ? sortedAcs[i - 1].idx : 0;
+        const regionEnd = i + 1 < sortedAcs.length ? sortedAcs[i + 1].idx : content.length;
+        const section = content.slice(regionStart, regionEnd);
+        if (section.includes("[ESCALATE]")) {
+          escalated++;
+        } else if (hasFailVerdict(section)) {
+          pending++;
+        } else if (/```output/m.test(section)) {
+          verified++;
+        } else {
+          pending++;
+        }
+      }
+      const narrativeTotal = verified + pending + escalated;
+      return buildResult({
+        verified,
+        pending,
+        escalated,
+        total: narrativeTotal
+      });
+    }
+    for (const acNum of acNumbers) {
+      const acPattern2 = new RegExp(`--- AC ?${acNum}:`, "g");
+      const acIdx = content.search(acPattern2);
+      if (acIdx === -1) {
+        pending++;
+        continue;
+      }
+      const nextAcPattern = new RegExp(`--- AC ?(?!${acNum})\\d+:`, "g");
+      nextAcPattern.lastIndex = acIdx + 1;
+      const nextMatch = nextAcPattern.exec(content);
+      const section = content.slice(acIdx, nextMatch ? nextMatch.index : content.length);
+      if (section.includes("[ESCALATE]")) {
+        escalated++;
+      } else if (hasFailVerdict(section)) {
+        pending++;
+      } else if (/```output\n/m.test(section)) {
+        verified++;
+      } else {
+        pending++;
+      }
+    }
+  }
+  const total = verified + pending + escalated;
+  return buildResult({ verified, pending, escalated, total });
+}
+
+// src/modules/verify/orchestrator.ts
+import { execFileSync as execFileSync5 } from "child_process";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync8 } from "fs";
+import { join as join11 } from "path";
+
+// src/lib/doc-health.ts
+import { execSync } from "child_process";
+import {
+  existsSync as existsSync12,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync11,
+  readdirSync as readdirSync2,
+  statSync,
+  unlinkSync,
+  writeFileSync as writeFileSync7
+} from "fs";
+import { join as join10, 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;
+function findModules(dir, threshold) {
+  const limit = threshold ?? DEFAULT_MODULE_THRESHOLD;
+  const root = dir;
+  const modules = [];
+  function walk(current) {
+    let entries;
+    try {
+      entries = readdirSync2(current);
+    } catch {
+      return;
+    }
+    const dirName = current.split("/").pop() ?? "";
+    if (dirName === "node_modules" || dirName === ".git" || dirName === "dist" || dirName === "coverage" || dirName.startsWith(".") && current !== root) {
+      return;
+    }
+    let sourceCount = 0;
+    const subdirs = [];
+    for (const entry of entries) {
+      const fullPath = join10(current, entry);
+      let stat;
+      try {
+        stat = statSync(fullPath);
+      } catch {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        subdirs.push(fullPath);
+      } else if (stat.isFile()) {
+        const ext = getExtension(entry);
+        if (SOURCE_EXTENSIONS.has(ext) && !isTestFile(entry)) {
+          sourceCount++;
+        }
+      }
+    }
+    if (sourceCount >= limit) {
+      const rel = relative(root, current);
+      if (rel !== "") {
+        modules.push(rel);
+      }
+    }
+    for (const subdir of subdirs) {
+      walk(subdir);
+    }
+  }
+  walk(root);
+  return modules;
+}
+function getExtension(filename) {
+  const dot = filename.lastIndexOf(".");
+  return dot >= 0 ? filename.slice(dot) : "";
+}
+function isTestFile(filename) {
+  return filename.includes(".test.") || filename.includes(".spec.") || filename.includes("__tests__") || filename.startsWith("test_");
+}
+function isDocStale(docPath, codeDir) {
+  if (!existsSync12(docPath)) return true;
+  if (!existsSync12(codeDir)) return false;
+  const docMtime = statSync(docPath).mtime;
+  const newestCode = getNewestSourceMtime(codeDir);
   if (newestCode === null) return false;
   return newestCode.getTime() > docMtime.getTime();
 }
@@ -3408,89 +3515,15 @@ function showboatProofTemplate(config) {
   return sections.join("\n");
 }
 
-// src/lib/verify.ts
-function classifyEvidenceCommands(proofContent) {
-  const results = [];
-  const codeBlockPattern = /```(?:bash|shell)\n([\s\S]*?)```/g;
-  for (const match of proofContent.matchAll(codeBlockPattern)) {
-    const block = match[1].trim();
-    const lines = block.split("\n").filter((l) => l.trim().length > 0);
-    for (const line of lines) {
-      const cmd = line.trim();
-      if (!cmd) continue;
-      results.push({ command: cmd, type: classifyCommand(cmd) });
-    }
-  }
-  return results;
-}
-function classifyCommand(cmd) {
-  if (/docker\s+exec\b/.test(cmd)) {
-    return "docker-exec";
-  }
-  if (/docker\s+(ps|logs|inspect|stats|top|port)\b/.test(cmd)) {
-    return "docker-host";
-  }
-  if (/curl\b/.test(cmd) && /localhost:(9428|8428|16686)\b/.test(cmd)) {
-    return "observability";
+// src/modules/verify/orchestrator.ts
+function checkPreconditions(dir, storyId) {
+  const state = readState(dir);
+  const failures = [];
+  if (!state.session_flags.tests_passed) {
+    failures.push("tests_passed is false \u2014 run tests first");
   }
-  if (/\bgrep\b/.test(cmd) && /\bsrc\//.test(cmd)) {
-    return "grep-src";
-  }
-  return "other";
-}
-function checkBlackBoxEnforcement(proofContent) {
-  const commands = classifyEvidenceCommands(proofContent);
-  const grepSrcCount = commands.filter((c) => c.type === "grep-src").length;
-  const dockerExecCount = commands.filter((c) => c.type === "docker-exec").length;
-  const observabilityCount = commands.filter((c) => c.type === "observability").length;
-  const otherCount = commands.filter((c) => c.type === "other").length;
-  const totalCommands = commands.length;
-  const grepRatio = totalCommands > 0 ? grepSrcCount / totalCommands : 0;
-  const acsMissingDockerExec = [];
-  const acHeaderPattern = /^## AC ?(\d+):/gm;
-  const acMatches = [...proofContent.matchAll(acHeaderPattern)];
-  if (acMatches.length > 0) {
-    for (let i = 0; i < acMatches.length; i++) {
-      const acNum = parseInt(acMatches[i][1], 10);
-      const start = acMatches[i].index;
-      const end = i + 1 < acMatches.length ? acMatches[i + 1].index : proofContent.length;
-      const section = proofContent.slice(start, end);
-      if (section.includes("[ESCALATE]")) continue;
-      const sectionCommands = classifyEvidenceCommands(section);
-      const hasBlackBoxEvidence = sectionCommands.some(
-        (c) => c.type === "docker-exec" || c.type === "docker-host" || c.type === "observability"
-      );
-      if (!hasBlackBoxEvidence) {
-        acsMissingDockerExec.push(acNum);
-      }
-    }
-  }
-  const grepTooHigh = grepRatio > 0.5;
-  const missingDockerExec = acsMissingDockerExec.length > 0;
-  const hasExtractableCommands = totalCommands > 0;
-  return {
-    blackBoxPass: !hasExtractableCommands || !grepTooHigh && !missingDockerExec,
-    grepSrcCount,
-    dockerExecCount,
-    observabilityCount,
-    otherCount,
-    grepRatio,
-    acsMissingDockerExec
-  };
-}
-function hasFailVerdict(section) {
-  const withoutCodeBlocks = section.replace(/```[\s\S]*?```/g, "");
-  const withoutInlineCode = withoutCodeBlocks.replace(/`[^`]+`/g, "");
-  return withoutInlineCode.includes("[FAIL]");
-}
-function checkPreconditions(dir, storyId) {
-  const state = readState(dir);
-  const failures = [];
-  if (!state.session_flags.tests_passed) {
-    failures.push("tests_passed is false \u2014 run tests first");
-  }
-  if (!state.session_flags.coverage_met) {
-    failures.push("coverage_met is false \u2014 ensure coverage target is met");
+  if (!state.session_flags.coverage_met) {
+    failures.push("coverage_met is false \u2014 ensure coverage target is met");
   }
   if (storyId) {
     try {
@@ -3551,194 +3584,455 @@ function runShowboatVerify(proofPath) {
     return { passed: false, output: stdout || stderr || message };
   }
 }
-function validateProofQuality(proofPath) {
-  const emptyResult = {
-    verified: 0,
-    pending: 0,
-    escalated: 0,
-    total: 0,
-    passed: false,
-    grepSrcCount: 0,
-    dockerExecCount: 0,
-    observabilityCount: 0,
-    otherCount: 0,
-    blackBoxPass: false
-  };
-  if (!existsSync13(proofPath)) {
-    return emptyResult;
+function updateVerificationState(storyId, result, dir) {
+  const { state, body } = readStateWithBody(dir);
+  state.session_flags.verification_run = true;
+  const status = result.success ? "pass" : "fail";
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  state.verification_log.push(`${storyId}: ${status} at ${timestamp}`);
+  writeState(state, dir, body);
+}
+function closeBeadsIssue(storyId, dir) {
+  const root = dir ?? process.cwd();
+  if (!isBeadsInitialized(root)) {
+    warn("Beads not initialized \u2014 skipping issue close");
+    return;
   }
-  const content = readFileSync12(proofPath, "utf-8");
-  const bbEnforcement = checkBlackBoxEnforcement(content);
-  function buildResult(base) {
-    const basePassed = base.pending === 0 && base.verified > 0;
-    return {
-      ...base,
-      passed: basePassed && bbEnforcement.blackBoxPass,
-      grepSrcCount: bbEnforcement.grepSrcCount,
-      dockerExecCount: bbEnforcement.dockerExecCount,
-      observabilityCount: bbEnforcement.observabilityCount,
-      otherCount: bbEnforcement.otherCount,
-      blackBoxPass: bbEnforcement.blackBoxPass
-    };
+  try {
+    const issues = listIssues();
+    const issue = issues.find((i) => {
+      const desc = i.description ?? "";
+      return desc.includes(storyId);
+    });
+    if (!issue) {
+      warn(`No beads issue found for story ${storyId} \u2014 skipping issue close`);
+      return;
+    }
+    syncClose(issue.id, { closeIssue, listIssues }, root);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warn(`Failed to close beads issue: ${message}`);
   }
-  const acHeaderPattern = /^## AC ?(\d+):/gm;
-  const matches = [...content.matchAll(acHeaderPattern)];
-  let verified = 0;
-  let pending = 0;
-  let escalated = 0;
-  if (matches.length > 0) {
-    for (let i = 0; i < matches.length; i++) {
-      const start = matches[i].index;
-      const end = i + 1 < matches.length ? matches[i + 1].index : content.length;
-      const section = content.slice(start, end);
-      if (section.includes("[ESCALATE]")) {
-        escalated++;
-        continue;
-      }
-      if (hasFailVerdict(section)) {
-        pending++;
-        continue;
-      }
-      const hasEvidence = section.includes("<!-- /showboat exec -->") || section.includes("<!-- showboat image:") || /```(?:bash|shell)\n[\s\S]*?```\n+```output\n/m.test(section);
-      if (hasEvidence) {
-        verified++;
-      } else {
-        pending++;
-      }
+}
+
+// src/modules/verify/parser.ts
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
+var UI_KEYWORDS = [
+  "agent-browser",
+  "screenshot",
+  "navigate",
+  "click",
+  "form",
+  "ui verification",
+  "ui acceptance"
+];
+var API_KEYWORDS = [
+  "http",
+  "api",
+  "endpoint",
+  "curl",
+  "rest",
+  "response bod"
+];
+var DB_KEYWORDS = [
+  "database",
+  "db state",
+  "db mcp",
+  "query",
+  "sql",
+  "table"
+];
+var INTEGRATION_KEYWORDS = [
+  "external system",
+  "real infrastructure",
+  "manual verification"
+];
+var ESCALATE_KEYWORDS = [
+  "physical hardware",
+  "manual human",
+  "visual inspection by human",
+  "paid external service"
+];
+function classifyVerifiability(description) {
+  const lower = description.toLowerCase();
+  for (const kw of INTEGRATION_KEYWORDS) {
+    if (lower.includes(kw)) return "integration-required";
+  }
+  return "cli-verifiable";
+}
+function classifyStrategy(description) {
+  const lower = description.toLowerCase();
+  for (const kw of ESCALATE_KEYWORDS) {
+    if (lower.includes(kw)) return "escalate";
+  }
+  return "docker";
+}
+var VERIFICATION_TAG_PATTERN = /<!--\s*verification:\s*(cli-verifiable|integration-required)\s*-->/;
+function parseVerificationTag(text) {
+  const match = VERIFICATION_TAG_PATTERN.exec(text);
+  return match ? match[1] : null;
+}
+function classifyAC(description) {
+  const lower = description.toLowerCase();
+  for (const kw of UI_KEYWORDS) {
+    if (lower.includes(kw)) return "ui";
+  }
+  for (const kw of API_KEYWORDS) {
+    if (lower.includes(kw)) return "api";
+  }
+  for (const kw of DB_KEYWORDS) {
+    if (lower.includes(kw)) return "db";
+  }
+  return "general";
+}
+function parseStoryACs(storyFilePath) {
+  if (!existsSync14(storyFilePath)) {
+    throw new Error(
+      `Story file not found: ${storyFilePath}. Ensure the story file exists at the expected path.`
+    );
+  }
+  const content = readFileSync12(storyFilePath, "utf-8");
+  const lines = content.split("\n");
+  let acSectionStart = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (/^##\s+Acceptance\s+Criteria/i.test(lines[i])) {
+      acSectionStart = i + 1;
+      break;
     }
-  } else {
-    const inlineAcPattern = /--- AC ?(\d+):/g;
-    const inlineMatches = [...content.matchAll(inlineAcPattern)];
-    const acNumbers = new Set(inlineMatches.map((m) => m[1]));
-    if (acNumbers.size === 0) {
-      const narrativeAcPattern = /=== AC ?(\d+):/g;
-      const narrativeMatches = [...content.matchAll(narrativeAcPattern)];
-      const narrativeAcNumbers = new Set(narrativeMatches.map((m) => m[1]));
-      if (narrativeAcNumbers.size === 0) {
-        const bulletAcPattern = /^- AC ?(\d+)[^:\n]*:/gm;
-        const bulletMatches = [...content.matchAll(bulletAcPattern)];
-        const bulletAcNumbers = new Set(bulletMatches.map((m) => m[1]));
-        if (bulletAcNumbers.size === 0) {
-          return buildResult({ verified: 0, pending: 0, escalated: 0, total: 0 });
-        }
-        let bVerified = 0;
-        let bPending = 0;
-        let bEscalated = 0;
-        for (const acNum of bulletAcNumbers) {
-          const bulletPattern = new RegExp(`^- AC ?${acNum}[^:\\n]*:(.*)$`, "m");
-          const bulletMatch = content.match(bulletPattern);
-          if (!bulletMatch) {
-            bPending++;
-            continue;
-          }
-          const bulletText = bulletMatch[1].toLowerCase();
-          if (bulletText.includes("n/a") || bulletText.includes("escalat") || bulletText.includes("superseded")) {
-            bEscalated++;
-          } else if (bulletText.includes("fail")) {
-            bPending++;
-          } else {
-            bVerified++;
-          }
-        }
-        const hasAnyEvidence = /```output\n/m.test(content);
-        if (!hasAnyEvidence) {
-          bPending += bVerified;
-          bVerified = 0;
-        }
-        const bTotal = bVerified + bPending + bEscalated;
-        return buildResult({
-          verified: bVerified,
-          pending: bPending,
-          escalated: bEscalated,
-          total: bTotal
+  }
+  if (acSectionStart === -1) {
+    warn('No "## Acceptance Criteria" section found in story file');
+    return [];
+  }
+  let acSectionEnd = lines.length;
+  for (let i = acSectionStart; i < lines.length; i++) {
+    if (/^##\s+/.test(lines[i]) && i !== acSectionStart - 1) {
+      acSectionEnd = i;
+      break;
+    }
+  }
+  const acSection = lines.slice(acSectionStart, acSectionEnd).join("\n");
+  const acPattern = /^\s*(\d+)\.\s+/;
+  const acs = [];
+  const acLines = acSection.split("\n");
+  let currentId = null;
+  let currentDesc = [];
+  const flushCurrent = () => {
+    if (currentId !== null && currentDesc.length > 0) {
+      const description = currentDesc.join(" ").trim();
+      if (description) {
+        const tag = parseVerificationTag(description);
+        const verifiability = tag ?? classifyVerifiability(description);
+        const strategy = classifyStrategy(description);
+        acs.push({
+          id: currentId,
+          description,
+          type: classifyAC(description),
+          verifiability,
+          strategy
         });
+      } else {
+        warn(`Skipping malformed AC #${currentId}: empty description`);
       }
-      const sortedAcs = narrativeMatches.map((m) => ({ num: m[1], idx: m.index })).filter((v, i, a) => a.findIndex((x) => x.num === v.num) === i).sort((a, b) => a.idx - b.idx);
-      for (let i = 0; i < sortedAcs.length; i++) {
-        const { num: acNum, idx: acIdx } = sortedAcs[i];
-        const regionStart = i > 0 ? sortedAcs[i - 1].idx : 0;
-        const regionEnd = i + 1 < sortedAcs.length ? sortedAcs[i + 1].idx : content.length;
-        const section = content.slice(regionStart, regionEnd);
-        if (section.includes("[ESCALATE]")) {
-          escalated++;
-        } else if (hasFailVerdict(section)) {
-          pending++;
-        } else if (/```output/m.test(section)) {
-          verified++;
-        } else {
-          pending++;
-        }
-      }
-      const narrativeTotal = verified + pending + escalated;
-      return buildResult({
-        verified,
-        pending,
-        escalated,
-        total: narrativeTotal
-      });
     }
-    for (const acNum of acNumbers) {
-      const acPattern = new RegExp(`--- AC ?${acNum}:`, "g");
-      const acIdx = content.search(acPattern);
-      if (acIdx === -1) {
-        pending++;
-        continue;
-      }
-      const nextAcPattern = new RegExp(`--- AC ?(?!${acNum})\\d+:`, "g");
-      nextAcPattern.lastIndex = acIdx + 1;
-      const nextMatch = nextAcPattern.exec(content);
-      const section = content.slice(acIdx, nextMatch ? nextMatch.index : content.length);
-      if (section.includes("[ESCALATE]")) {
-        escalated++;
-      } else if (hasFailVerdict(section)) {
-        pending++;
-      } else if (/```output\n/m.test(section)) {
-        verified++;
-      } else {
-        pending++;
+  };
+  for (const line of acLines) {
+    const match = acPattern.exec(line);
+    if (match) {
+      flushCurrent();
+      currentId = match[1];
+      currentDesc = [line.replace(acPattern, "").trim()];
+    } else if (currentId !== null && line.trim()) {
+      currentDesc.push(line.trim());
+    }
+  }
+  flushCurrent();
+  return acs;
+}
+
+// src/modules/verify/env.ts
+import { execFileSync as execFileSync6 } from "child_process";
+import { existsSync as existsSync15, mkdirSync as mkdirSync6, readdirSync as readdirSync3, readFileSync as readFileSync13, cpSync, rmSync, statSync as statSync2 } from "fs";
+import { join as join12, basename as basename3 } from "path";
+import { createHash } from "crypto";
+var IMAGE_TAG = "codeharness-verify";
+var STORY_DIR = "_bmad-output/implementation-artifacts";
+var TEMP_PREFIX = "/tmp/codeharness-verify-";
+var STATE_KEY_DIST_HASH = "verify_env_dist_hash";
+function isValidStoryKey(storyKey) {
+  if (!storyKey || storyKey.includes("..") || storyKey.includes("/") || storyKey.includes("\\")) {
+    return false;
+  }
+  return /^[a-zA-Z0-9_-]+$/.test(storyKey);
+}
+function computeDistHash(projectDir) {
+  const distDir = join12(projectDir, "dist");
+  if (!existsSync15(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(readFileSync13(file));
+  }
+  return hash.digest("hex");
+}
+function collectFiles(dir) {
+  const results = [];
+  for (const entry of readdirSync3(dir, { withFileTypes: true })) {
+    const fullPath = join12(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...collectFiles(fullPath));
+    } else {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+function getStoredDistHash(projectDir) {
+  try {
+    const { state } = readStateWithBody(projectDir);
+    return state[STATE_KEY_DIST_HASH] ?? null;
+  } catch {
+    return null;
+  }
+}
+function storeDistHash(projectDir, hash) {
+  try {
+    const { state, body } = readStateWithBody(projectDir);
+    state[STATE_KEY_DIST_HASH] = hash;
+    writeState(state, projectDir, body);
+  } catch {
+    info("Could not persist dist hash to state file \u2014 cache will not be available until state is initialized");
+  }
+}
+function detectProjectType(projectDir) {
+  if (existsSync15(join12(projectDir, ".claude-plugin", "plugin.json"))) return "plugin";
+  const stack = detectStack(projectDir);
+  if (stack === "nodejs") return "nodejs";
+  if (stack === "python") return "python";
+  return "generic";
+}
+function buildVerifyImage(options = {}) {
+  const projectDir = options.projectDir ?? process.cwd();
+  if (!isDockerAvailable()) {
+    throw new Error("Docker is not available. Install Docker and ensure the daemon is running.");
+  }
+  const projectType = detectProjectType(projectDir);
+  const currentHash = computeDistHash(projectDir);
+  if (projectType === "generic" || projectType === "plugin") {
+  } else if (!currentHash) {
+    throw new Error("No dist/ directory found. Run your build command first (e.g., npm run build).");
+  }
+  if (currentHash) {
+    const storedHash = getStoredDistHash(projectDir);
+    if (storedHash === currentHash && dockerImageExists(IMAGE_TAG)) {
+      return { imageTag: IMAGE_TAG, imageSize: getImageSize(IMAGE_TAG), buildTimeMs: 0, cached: true };
+    }
+  }
+  const startTime = Date.now();
+  if (projectType === "nodejs") {
+    buildNodeImage(projectDir);
+  } else if (projectType === "python") {
+    buildPythonImage(projectDir);
+  } else if (projectType === "plugin") {
+    buildPluginImage(projectDir);
+  } else {
+    buildGenericImage(projectDir);
+  }
+  if (currentHash) {
+    storeDistHash(projectDir, currentHash);
+  }
+  return { imageTag: IMAGE_TAG, imageSize: getImageSize(IMAGE_TAG), buildTimeMs: Date.now() - startTime, cached: false };
+}
+function buildNodeImage(projectDir) {
+  const packOutput = execFileSync6("npm", ["pack", "--pack-destination", "/tmp"], {
+    cwd: projectDir,
+    stdio: "pipe",
+    timeout: 6e4
+  }).toString().trim();
+  const lastLine = packOutput.split("\n").pop()?.trim();
+  if (!lastLine) throw new Error("npm pack produced no output \u2014 cannot determine tarball filename.");
+  const tarballName = basename3(lastLine);
+  const tarballPath = join12("/tmp", tarballName);
+  const buildContext = join12("/tmp", `codeharness-verify-build-${Date.now()}`);
+  mkdirSync6(buildContext, { recursive: true });
+  try {
+    cpSync(tarballPath, join12(buildContext, tarballName));
+    cpSync(resolveDockerfileTemplate(projectDir), join12(buildContext, "Dockerfile"));
+    execFileSync6("docker", ["build", "-t", IMAGE_TAG, "--build-arg", `TARBALL=${tarballName}`, "."], {
+      cwd: buildContext,
+      stdio: "pipe",
+      timeout: 12e4
+    });
+  } finally {
+    rmSync(buildContext, { recursive: true, force: true });
+    rmSync(tarballPath, { force: true });
+  }
+}
+function buildPythonImage(projectDir) {
+  const distDir = join12(projectDir, "dist");
+  const distFiles = readdirSync3(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 = join12("/tmp", `codeharness-verify-build-${Date.now()}`);
+  mkdirSync6(buildContext, { recursive: true });
+  try {
+    cpSync(join12(distDir, distFile), join12(buildContext, distFile));
+    cpSync(resolveDockerfileTemplate(projectDir), join12(buildContext, "Dockerfile"));
+    execFileSync6("docker", ["build", "-t", IMAGE_TAG, "--build-arg", `TARBALL=${distFile}`, "."], {
+      cwd: buildContext,
+      stdio: "pipe",
+      timeout: 12e4
+    });
+  } finally {
+    rmSync(buildContext, { recursive: true, force: true });
+  }
+}
+function prepareVerifyWorkspace(storyKey, projectDir) {
+  const root = projectDir ?? process.cwd();
+  if (!isValidStoryKey(storyKey)) {
+    throw new Error(`Invalid story key: ${storyKey}. Keys must contain only alphanumeric characters, hyphens, and underscores.`);
+  }
+  const storyFile = join12(root, STORY_DIR, `${storyKey}.md`);
+  if (!existsSync15(storyFile)) throw new Error(`Story file not found: ${storyFile}`);
+  const workspace = `${TEMP_PREFIX}${storyKey}`;
+  if (existsSync15(workspace)) rmSync(workspace, { recursive: true, force: true });
+  mkdirSync6(workspace, { recursive: true });
+  cpSync(storyFile, join12(workspace, "story.md"));
+  const readmePath = join12(root, "README.md");
+  if (existsSync15(readmePath)) cpSync(readmePath, join12(workspace, "README.md"));
+  const docsDir = join12(root, "docs");
+  if (existsSync15(docsDir) && statSync2(docsDir).isDirectory()) {
+    cpSync(docsDir, join12(workspace, "docs"), { recursive: true });
+  }
+  mkdirSync6(join12(workspace, "verification"), { recursive: true });
+  return workspace;
+}
+function checkVerifyEnv() {
+  let imageExists = false;
+  let cliWorks = false;
+  let otelReachable = false;
+  imageExists = dockerImageExists(IMAGE_TAG);
+  if (!imageExists) return { imageExists, cliWorks, otelReachable };
+  try {
+    execFileSync6("docker", ["run", "--rm", IMAGE_TAG, "codeharness", "--help"], {
+      stdio: "pipe",
+      timeout: 3e4
+    });
+    cliWorks = true;
+  } catch {
+    cliWorks = false;
+  }
+  try {
+    execFileSync6("docker", [
+      "run",
+      "--rm",
+      "--add-host=host.docker.internal:host-gateway",
+      IMAGE_TAG,
+      "curl",
+      "-sf",
+      "--max-time",
+      "5",
+      "http://host.docker.internal:4318/v1/status"
+    ], { stdio: "pipe", timeout: 3e4 });
+    otelReachable = true;
+  } catch {
+    otelReachable = false;
+  }
+  return { imageExists, cliWorks, otelReachable };
+}
+function cleanupVerifyEnv(storyKey) {
+  if (!isValidStoryKey(storyKey)) {
+    throw new Error(`Invalid story key: ${storyKey}. Keys must contain only alphanumeric characters, hyphens, and underscores.`);
+  }
+  const workspace = `${TEMP_PREFIX}${storyKey}`;
+  const containerName = `codeharness-verify-${storyKey}`;
+  if (existsSync15(workspace)) rmSync(workspace, { recursive: true, force: true });
+  try {
+    execFileSync6("docker", ["stop", containerName], { stdio: "pipe", timeout: 15e3 });
+  } catch {
+  }
+  try {
+    execFileSync6("docker", ["rm", "-f", containerName], { stdio: "pipe", timeout: 15e3 });
+  } catch {
+  }
+}
+function buildPluginImage(projectDir) {
+  const buildContext = join12("/tmp", `codeharness-verify-build-${Date.now()}`);
+  mkdirSync6(buildContext, { recursive: true });
+  try {
+    const pluginDir = join12(projectDir, ".claude-plugin");
+    cpSync(pluginDir, join12(buildContext, ".claude-plugin"), { recursive: true });
+    for (const dir of ["commands", "hooks", "knowledge", "skills"]) {
+      const src = join12(projectDir, dir);
+      if (existsSync15(src) && statSync2(src).isDirectory()) {
+        cpSync(src, join12(buildContext, dir), { recursive: true });
       }
     }
+    cpSync(resolveDockerfileTemplate(projectDir, "generic"), join12(buildContext, "Dockerfile"));
+    execFileSync6("docker", ["build", "-t", IMAGE_TAG, "."], {
+      cwd: buildContext,
+      stdio: "pipe",
+      timeout: 12e4
+    });
+  } finally {
+    rmSync(buildContext, { recursive: true, force: true });
+  }
+}
+function buildGenericImage(projectDir) {
+  const buildContext = join12("/tmp", `codeharness-verify-build-${Date.now()}`);
+  mkdirSync6(buildContext, { recursive: true });
+  try {
+    cpSync(resolveDockerfileTemplate(projectDir, "generic"), join12(buildContext, "Dockerfile"));
+    execFileSync6("docker", ["build", "-t", IMAGE_TAG, "."], {
+      cwd: buildContext,
+      stdio: "pipe",
+      timeout: 12e4
+    });
+  } finally {
+    rmSync(buildContext, { recursive: true, force: true });
   }
-  const total = verified + pending + escalated;
-  return buildResult({ verified, pending, escalated, total });
 }
-function updateVerificationState(storyId, result, dir) {
-  const { state, body } = readStateWithBody(dir);
-  state.session_flags.verification_run = true;
-  const status = result.success ? "pass" : "fail";
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-  state.verification_log.push(`${storyId}: ${status} at ${timestamp}`);
-  writeState(state, dir, body);
+function resolveDockerfileTemplate(projectDir, variant) {
+  const filename = variant === "generic" ? "Dockerfile.verify.generic" : "Dockerfile.verify";
+  const local = join12(projectDir, "templates", filename);
+  if (existsSync15(local)) return local;
+  const pkgDir = new URL("../../", import.meta.url).pathname;
+  const pkg = join12(pkgDir, "templates", filename);
+  if (existsSync15(pkg)) return pkg;
+  throw new Error(`${filename} not found. Ensure templates/${filename} exists.`);
 }
-function closeBeadsIssue(storyId, dir) {
-  const root = dir ?? process.cwd();
-  if (!isBeadsInitialized(root)) {
-    warn("Beads not initialized \u2014 skipping issue close");
-    return;
+function dockerImageExists(tag) {
+  try {
+    execFileSync6("docker", ["image", "inspect", tag], { stdio: "pipe", timeout: 1e4 });
+    return true;
+  } catch {
+    return false;
   }
+}
+function getImageSize(tag) {
   try {
-    const issues = listIssues();
-    const issue = issues.find((i) => {
-      const desc = i.description ?? "";
-      return desc.includes(storyId);
-    });
-    if (!issue) {
-      warn(`No beads issue found for story ${storyId} \u2014 skipping issue close`);
-      return;
-    }
-    syncClose(issue.id, { closeIssue, listIssues }, root);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    warn(`Failed to close beads issue: ${message}`);
+    const output = execFileSync6("docker", ["image", "inspect", tag, "--format", "{{.Size}}"], {
+      stdio: "pipe",
+      timeout: 1e4
+    }).toString().trim();
+    const bytes = parseInt(output, 10);
+    if (isNaN(bytes)) return output;
+    if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)}GB`;
+    if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(1)}MB`;
+    if (bytes >= 1e3) return `${(bytes / 1e3).toFixed(1)}KB`;
+    return `${bytes}B`;
+  } catch {
+    return "unknown";
   }
 }
 
 // src/commands/verify.ts
-var STORY_DIR = "_bmad-output/implementation-artifacts";
+var STORY_DIR2 = "_bmad-output/implementation-artifacts";
 function isValidStoryId(storyId) {
-  if (!storyId || storyId.includes("..") || storyId.includes("/") || storyId.includes("\\")) {
-    return false;
-  }
+  if (!storyId || storyId.includes("..") || storyId.includes("/") || storyId.includes("\\")) return false;
   return /^[a-zA-Z0-9_-]+$/.test(storyId);
 }
 function registerVerifyCommand(program) {
@@ -3771,8 +4065,8 @@ function verifyRetro(opts, isJson, root) {
     return;
   }
   const retroFile = `epic-${epicNum}-retrospective.md`;
-  const retroPath = join12(root, STORY_DIR, retroFile);
-  if (!existsSync14(retroPath)) {
+  const retroPath = join13(root, STORY_DIR2, retroFile);
+  if (!existsSync16(retroPath)) {
     if (isJson) {
       jsonOutput({ status: "fail", epic: epicNum, retroFile, message: `${retroFile} not found` });
     } else {
@@ -3789,7 +4083,7 @@ function verifyRetro(opts, isJson, root) {
     warn(`Failed to update sprint status: ${message}`);
   }
   if (isJson) {
-    jsonOutput({ status: "ok", epic: epicNum, retroFile: join12(STORY_DIR, retroFile) });
+    jsonOutput({ status: "ok", epic: epicNum, retroFile: join13(STORY_DIR2, retroFile) });
   } else {
     ok(`Epic ${epicNum} retrospective: marked done`);
   }
@@ -3800,8 +4094,8 @@ function verifyStory(storyId, isJson, root) {
     process.exitCode = 1;
     return;
   }
-  const readmePath = join12(root, "README.md");
-  if (!existsSync14(readmePath)) {
+  const readmePath = join13(root, "README.md");
+  if (!existsSync16(readmePath)) {
     if (isJson) {
       jsonOutput({ status: "fail", message: "No README.md found \u2014 verification requires user documentation" });
     } else {
@@ -3810,8 +4104,8 @@ function verifyStory(storyId, isJson, root) {
     process.exitCode = 1;
     return;
   }
-  const storyFilePath = join12(root, STORY_DIR, `${storyId}.md`);
-  if (!existsSync14(storyFilePath)) {
+  const storyFilePath = join13(root, STORY_DIR2, `${storyId}.md`);
+  if (!existsSync16(storyFilePath)) {
     fail(`Story file not found: ${storyFilePath}`, { json: isJson });
     process.exitCode = 1;
     return;
@@ -3851,8 +4145,8 @@ function verifyStory(storyId, isJson, root) {
     return;
   }
   const storyTitle = extractStoryTitle(storyFilePath);
-  const expectedProofPath = join12(root, "verification", `${storyId}-proof.md`);
-  const proofPath = existsSync14(expectedProofPath) ? expectedProofPath : createProofDocument(storyId, storyTitle, acs, root);
+  const expectedProofPath = join13(root, "verification", `${storyId}-proof.md`);
+  const proofPath = existsSync16(expectedProofPath) ? expectedProofPath : createProofDocument(storyId, storyTitle, acs, root);
   const proofQuality = validateProofQuality(proofPath);
   if (!proofQuality.passed) {
     if (isJson) {
@@ -3946,7 +4240,7 @@ function verifyStory(storyId, isJson, root) {
 }
 function extractStoryTitle(filePath) {
   try {
-    const content = readFileSync13(filePath, "utf-8");
+    const content = readFileSync14(filePath, "utf-8");
     const match = /^#\s+(.+)$/m.exec(content);
     return match ? match[1] : "Unknown Story";
   } catch {
@@ -3955,14 +4249,14 @@ function extractStoryTitle(filePath) {
 }
 
 // src/lib/onboard-checks.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join14, dirname as dirname4 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { join as join15, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/coverage.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync14 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync15 } from "fs";
+import { join as join14 } from "path";
 function detectCoverageTool(dir) {
   const baseDir = dir ?? process.cwd();
   const stateHint = getStateToolHint(baseDir);
@@ -3985,16 +4279,16 @@ function getStateToolHint(dir) {
   }
 }
 function detectNodeCoverageTool(dir, stateHint) {
-  const hasVitestConfig = existsSync15(join13(dir, "vitest.config.ts")) || existsSync15(join13(dir, "vitest.config.js"));
-  const pkgPath = join13(dir, "package.json");
+  const hasVitestConfig = existsSync17(join14(dir, "vitest.config.ts")) || existsSync17(join14(dir, "vitest.config.js"));
+  const pkgPath = join14(dir, "package.json");
   let hasVitestCoverageV8 = false;
   let hasVitestCoverageIstanbul = false;
   let hasC8 = false;
   let hasJest = false;
   let pkgScripts = {};
-  if (existsSync15(pkgPath)) {
+  if (existsSync17(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync14(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync15(pkgPath, "utf-8"));
       const allDeps = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
       hasVitestCoverageV8 = "@vitest/coverage-v8" in allDeps;
       hasVitestCoverageIstanbul = "@vitest/coverage-istanbul" in allDeps;
@@ -4047,10 +4341,10 @@ function getNodeTestCommand(scripts, runner) {
   return "npm test";
 }
 function detectPythonCoverageTool(dir) {
-  const reqPath = join13(dir, "requirements.txt");
-  if (existsSync15(reqPath)) {
+  const reqPath = join14(dir, "requirements.txt");
+  if (existsSync17(reqPath)) {
     try {
-      const content = readFileSync14(reqPath, "utf-8");
+      const content = readFileSync15(reqPath, "utf-8");
       if (content.includes("pytest-cov") || content.includes("coverage")) {
         return {
           tool: "coverage.py",
@@ -4061,10 +4355,10 @@ function detectPythonCoverageTool(dir) {
     } catch {
     }
   }
-  const pyprojectPath = join13(dir, "pyproject.toml");
-  if (existsSync15(pyprojectPath)) {
+  const pyprojectPath = join14(dir, "pyproject.toml");
+  if (existsSync17(pyprojectPath)) {
     try {
-      const content = readFileSync14(pyprojectPath, "utf-8");
+      const content = readFileSync15(pyprojectPath, "utf-8");
       if (content.includes("pytest-cov") || content.includes("coverage")) {
         return {
           tool: "coverage.py",
@@ -4146,7 +4440,7 @@ function parseVitestCoverage(dir) {
     return 0;
   }
   try {
-    const report = JSON.parse(readFileSync14(reportPath, "utf-8"));
+    const report = JSON.parse(readFileSync15(reportPath, "utf-8"));
     return report.total?.statements?.pct ?? 0;
   } catch {
     warn("Failed to parse coverage report");
@@ -4154,13 +4448,13 @@ function parseVitestCoverage(dir) {
   }
 }
 function parsePythonCoverage(dir) {
-  const reportPath = join13(dir, "coverage.json");
-  if (!existsSync15(reportPath)) {
+  const reportPath = join14(dir, "coverage.json");
+  if (!existsSync17(reportPath)) {
     warn("Coverage report not found at coverage.json");
     return 0;
   }
   try {
-    const report = JSON.parse(readFileSync14(reportPath, "utf-8"));
+    const report = JSON.parse(readFileSync15(reportPath, "utf-8"));
     return report.totals?.percent_covered ?? 0;
   } catch {
     warn("Failed to parse coverage report");
@@ -4261,7 +4555,7 @@ function checkPerFileCoverage(floor, dir) {
   }
   let report;
   try {
-    report = JSON.parse(readFileSync14(reportPath, "utf-8"));
+    report = JSON.parse(readFileSync15(reportPath, "utf-8"));
   } catch {
     warn("Failed to parse coverage-summary.json");
     return { floor, violations: [], totalFiles: 0 };
@@ -4291,11 +4585,11 @@ function checkPerFileCoverage(floor, dir) {
 }
 function findCoverageSummary(dir) {
   const candidates = [
-    join13(dir, "coverage", "coverage-summary.json"),
-    join13(dir, "src", "coverage", "coverage-summary.json")
+    join14(dir, "coverage", "coverage-summary.json"),
+    join14(dir, "src", "coverage", "coverage-summary.json")
   ];
   for (const p of candidates) {
-    if (existsSync15(p)) return p;
+    if (existsSync17(p)) return p;
   }
   return null;
 }
@@ -4319,8 +4613,8 @@ function printCoverageOutput(result, evaluation) {
 
 // src/lib/onboard-checks.ts
 function checkHarnessInitialized(dir) {
-  const statePath = getStatePath(dir ?? process.cwd());
-  return { ok: existsSync16(statePath) };
+  const statePath2 = getStatePath(dir ?? process.cwd());
+  return { ok: existsSync18(statePath2) };
 }
 function checkBmadInstalled(dir) {
   return { ok: isBmadInstalled(dir) };
@@ -4328,8 +4622,8 @@ function checkBmadInstalled(dir) {
 function checkHooksRegistered(dir) {
   const __filename = fileURLToPath3(import.meta.url);
   const __dirname2 = dirname4(__filename);
-  const hooksPath = join14(__dirname2, "..", "..", "hooks", "hooks.json");
-  return { ok: existsSync16(hooksPath) };
+  const hooksPath = join15(__dirname2, "..", "..", "hooks", "hooks.json");
+  return { ok: existsSync18(hooksPath) };
 }
 function runPreconditions(dir) {
   const harnessCheck = checkHarnessInitialized(dir);
@@ -4369,8 +4663,8 @@ function findVerificationGaps(dir) {
   for (const [key, status] of Object.entries(statuses)) {
     if (status !== "done") continue;
     if (!STORY_KEY_PATTERN2.test(key)) continue;
-    const proofPath = join14(root, "verification", `${key}-proof.md`);
-    if (!existsSync16(proofPath)) {
+    const proofPath = join15(root, "verification", `${key}-proof.md`);
+    if (!existsSync18(proofPath)) {
       unverified.push(key);
     }
   }
@@ -4497,6 +4791,768 @@ function filterTrackedGaps(stories, beadsFns) {
   return { untracked, trackedCount };
 }
 
+// src/modules/sprint/state.ts
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync9, renameSync, existsSync as existsSync20 } from "fs";
+import { join as join17 } from "path";
+
+// src/modules/sprint/migration.ts
+import { readFileSync as readFileSync16, existsSync as existsSync19 } from "fs";
+import { join as join16 } from "path";
+var OLD_FILES = {
+  storyRetries: "ralph/.story_retries",
+  flaggedStories: "ralph/.flagged_stories",
+  ralphStatus: "ralph/status.json",
+  sprintStatusYaml: "_bmad-output/implementation-artifacts/sprint-status.yaml",
+  sessionIssues: "_bmad-output/implementation-artifacts/.session-issues.md"
+};
+function resolve(relative3) {
+  return join16(process.cwd(), relative3);
+}
+function readIfExists(relative3) {
+  const p = resolve(relative3);
+  if (!existsSync19(p)) return null;
+  try {
+    return readFileSync16(p, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function emptyStory() {
+  return {
+    status: "backlog",
+    attempts: 0,
+    lastAttempt: null,
+    lastError: null,
+    proofPath: null,
+    acResults: null
+  };
+}
+function upsertStory(stories, key, patch) {
+  stories[key] = { ...stories[key] ?? emptyStory(), ...patch };
+}
+function parseStoryRetries(content, stories) {
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(/\s+/);
+    if (parts.length < 2) continue;
+    const count = parseInt(parts[1], 10);
+    if (!isNaN(count)) upsertStory(stories, parts[0], { attempts: count });
+  }
+}
+function parseFlaggedStories(content, stories) {
+  for (const line of content.split("\n")) {
+    const key = line.trim();
+    if (key) upsertStory(stories, key, { status: "blocked" });
+  }
+}
+function mapYamlStatus(value) {
+  const mapping = {
+    done: "done",
+    backlog: "backlog",
+    verifying: "verifying",
+    "in-progress": "in-progress",
+    "ready-for-dev": "ready",
+    blocked: "blocked",
+    failed: "failed",
+    review: "review",
+    ready: "ready"
+  };
+  return mapping[value.trim().toLowerCase()] ?? null;
+}
+function parseSprintStatusYaml(content, stories) {
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const match = trimmed.match(/^([a-zA-Z0-9_-]+):\s*(.+)$/);
+    if (!match) continue;
+    const key = match[1];
+    if (key === "development_status" || key.startsWith("epic-")) continue;
+    const status = mapYamlStatus(match[2]);
+    if (status) upsertStory(stories, key, { status });
+  }
+}
+function parseRalphStatus(content) {
+  try {
+    const data = JSON.parse(content);
+    return {
+      active: data.status === "running",
+      startedAt: null,
+      iteration: data.loop_count ?? 0,
+      cost: 0,
+      completed: [],
+      failed: []
+    };
+  } catch {
+    return null;
+  }
+}
+function parseSessionIssues(content) {
+  const items = [];
+  let currentStory = "";
+  let itemId = 0;
+  for (const line of content.split("\n")) {
+    const headerMatch = line.match(/^###\s+([a-zA-Z0-9_-]+)\s*[—-]/);
+    if (headerMatch) {
+      currentStory = headerMatch[1];
+      continue;
+    }
+    const bulletMatch = line.match(/^-\s+(.+)/);
+    if (bulletMatch && currentStory) {
+      itemId++;
+      items.push({
+        id: `migrated-${itemId}`,
+        story: currentStory,
+        description: bulletMatch[1],
+        source: "retro",
+        resolved: false
+      });
+    }
+  }
+  return items;
+}
+function migrateFromOldFormat() {
+  const hasAnyOldFile = Object.values(OLD_FILES).some((rel) => existsSync19(resolve(rel)));
+  if (!hasAnyOldFile) return fail2("No old format files found for migration");
+  try {
+    const stories = {};
+    let run = defaultState().run;
+    let actionItems = [];
+    const yamlContent = readIfExists(OLD_FILES.sprintStatusYaml);
+    if (yamlContent) parseSprintStatusYaml(yamlContent, stories);
+    const retriesContent = readIfExists(OLD_FILES.storyRetries);
+    if (retriesContent) parseStoryRetries(retriesContent, stories);
+    const flaggedContent = readIfExists(OLD_FILES.flaggedStories);
+    if (flaggedContent) parseFlaggedStories(flaggedContent, stories);
+    const statusContent = readIfExists(OLD_FILES.ralphStatus);
+    if (statusContent) {
+      const parsed = parseRalphStatus(statusContent);
+      if (parsed) run = parsed;
+    }
+    const issuesContent = readIfExists(OLD_FILES.sessionIssues);
+    if (issuesContent) actionItems = parseSessionIssues(issuesContent);
+    const sprint = computeSprintCounts(stories);
+    const migrated = {
+      version: 1,
+      sprint,
+      stories,
+      run,
+      actionItems
+    };
+    const writeResult = writeStateAtomic(migrated);
+    if (!writeResult.success) return fail2(writeResult.error);
+    return ok2(migrated);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return fail2(`Migration failed: ${msg}`);
+  }
+}
+
+// src/modules/sprint/state.ts
+function projectRoot() {
+  return process.cwd();
+}
+function statePath() {
+  return join17(projectRoot(), "sprint-state.json");
+}
+function tmpPath() {
+  return join17(projectRoot(), ".sprint-state.json.tmp");
+}
+function defaultState() {
+  return {
+    version: 1,
+    sprint: {
+      total: 0,
+      done: 0,
+      failed: 0,
+      blocked: 0,
+      inProgress: null
+    },
+    stories: {},
+    run: {
+      active: false,
+      startedAt: null,
+      iteration: 0,
+      cost: 0,
+      completed: [],
+      failed: []
+    },
+    actionItems: []
+  };
+}
+function writeStateAtomic(state) {
+  try {
+    const data = JSON.stringify(state, null, 2) + "\n";
+    const tmp = tmpPath();
+    const final = statePath();
+    writeFileSync9(tmp, data, "utf-8");
+    renameSync(tmp, final);
+    return ok2(void 0);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return fail2(`Failed to write sprint state: ${msg}`);
+  }
+}
+function getSprintState() {
+  const fp = statePath();
+  if (existsSync20(fp)) {
+    try {
+      const raw = readFileSync17(fp, "utf-8");
+      const parsed = JSON.parse(raw);
+      return ok2(parsed);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return fail2(`Failed to read sprint state: ${msg}`);
+    }
+  }
+  const migrationResult = migrateFromOldFormat();
+  if (migrationResult.success) {
+    return migrationResult;
+  }
+  return ok2(defaultState());
+}
+function computeSprintCounts(stories) {
+  let total = 0;
+  let done = 0;
+  let failed = 0;
+  let blocked = 0;
+  let inProgress = null;
+  for (const [key, story] of Object.entries(stories)) {
+    total++;
+    if (story.status === "done") done++;
+    else if (story.status === "failed") failed++;
+    else if (story.status === "blocked") blocked++;
+    else if (story.status === "in-progress") inProgress = key;
+  }
+  return { total, done, failed, blocked, inProgress };
+}
+
+// src/modules/sprint/selector.ts
+var MAX_STORY_ATTEMPTS = 10;
+
+// src/modules/sprint/drill-down.ts
+var MAX_ATTEMPTS = MAX_STORY_ATTEMPTS;
+function epicPrefix(key) {
+  const dashIdx = key.indexOf("-");
+  if (dashIdx === -1) return key;
+  return key.slice(0, dashIdx);
+}
+function buildAcDetails(story) {
+  if (!story.acResults) return [];
+  return story.acResults.map((ac) => {
+    const detail = { id: ac.id, verdict: ac.verdict };
+    if (ac.verdict === "fail" && story.lastError) {
+      return { ...detail, reason: story.lastError };
+    }
+    return detail;
+  });
+}
+function buildAttemptHistory(story) {
+  const records = [];
+  if (story.attempts === 0) return records;
+  for (let i = 1; i < story.attempts; i++) {
+    records.push({
+      number: i,
+      outcome: "details unavailable"
+    });
+  }
+  const lastOutcome = story.status === "done" ? "passed" : story.status === "failed" ? "verify failed" : story.status === "blocked" ? "blocked" : story.status;
+  const lastRecord = {
+    number: story.attempts,
+    outcome: lastOutcome,
+    ...story.lastAttempt ? { timestamp: story.lastAttempt } : {}
+  };
+  if (story.acResults) {
+    const failingAc = story.acResults.find((ac) => ac.verdict === "fail");
+    if (failingAc) {
+      records.push({ ...lastRecord, failingAc: failingAc.id });
+      return records;
+    }
+  }
+  records.push(lastRecord);
+  return records;
+}
+function buildProofSummary(story) {
+  if (!story.proofPath) return null;
+  let passCount = 0;
+  let failCount = 0;
+  let escalateCount = 0;
+  let pendingCount = 0;
+  if (story.acResults) {
+    for (const ac of story.acResults) {
+      if (ac.verdict === "pass") passCount++;
+      else if (ac.verdict === "fail") failCount++;
+      else if (ac.verdict === "escalate") escalateCount++;
+      else if (ac.verdict === "pending") pendingCount++;
+    }
+  }
+  return { path: story.proofPath, passCount, failCount, escalateCount, pendingCount };
+}
+function getStoryDrillDown(state, key) {
+  try {
+    const story = state.stories[key];
+    if (!story) {
+      return fail2(`Story '${key}' not found in sprint state`);
+    }
+    const epic = epicPrefix(key);
+    const acDetails = buildAcDetails(story);
+    const attemptHistory = buildAttemptHistory(story);
+    const proofSummary = buildProofSummary(story);
+    return ok2({
+      key,
+      status: story.status,
+      epic,
+      attempts: story.attempts,
+      maxAttempts: MAX_ATTEMPTS,
+      lastAttempt: story.lastAttempt,
+      acDetails,
+      attemptHistory,
+      proofSummary
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return fail2(`Failed to get story drill-down: ${msg}`);
+  }
+}
+
+// src/modules/sprint/reporter.ts
+var MAX_ATTEMPTS2 = MAX_STORY_ATTEMPTS;
+function formatDuration(ms) {
+  const clamped = Math.max(0, ms);
+  const totalMinutes = Math.floor(clamped / 6e4);
+  const hours = Math.floor(totalMinutes / 60);
+  const minutes = totalMinutes % 60;
+  if (hours > 0) return `${hours}h${minutes}m`;
+  return `${minutes}m`;
+}
+function computeEpicProgress(stories) {
+  const epicGroups = /* @__PURE__ */ new Map();
+  for (const [key, story] of Object.entries(stories)) {
+    const prefix = epicPrefix(key);
+    const group = epicGroups.get(prefix) ?? { total: 0, done: 0 };
+    group.total++;
+    if (story.status === "done") group.done++;
+    epicGroups.set(prefix, group);
+  }
+  let epicsTotal = 0;
+  let epicsDone = 0;
+  for (const group of epicGroups.values()) {
+    epicsTotal++;
+    if (group.total > 0 && group.done === group.total) epicsDone++;
+  }
+  return { epicsTotal, epicsDone };
+}
+function buildFailedDetails(stories) {
+  const details = [];
+  for (const [key, story] of Object.entries(stories)) {
+    if (story.status !== "failed") continue;
+    let acNumber = null;
+    if (story.acResults) {
+      for (const ac of story.acResults) {
+        if (ac.verdict === "fail") {
+          const num = parseInt(ac.id.replace(/\D/g, ""), 10);
+          if (!isNaN(num)) {
+            acNumber = num;
+            break;
+          }
+        }
+      }
+    }
+    details.push({
+      key,
+      acNumber,
+      errorLine: story.lastError ?? "unknown error",
+      attempts: story.attempts,
+      maxAttempts: MAX_ATTEMPTS2
+    });
+  }
+  return details;
+}
+function buildActionItemsLabeled(state) {
+  const runStories = /* @__PURE__ */ new Set([
+    ...state.run.completed,
+    ...state.run.failed
+  ]);
+  return state.actionItems.map((item) => {
+    const isNew = item.source === "verification" && runStories.has(item.story);
+    return { item, label: isNew ? "NEW" : "CARRIED" };
+  });
+}
+function buildRunSummary(state, now) {
+  if (!state.run.startedAt) return null;
+  const startedAt = new Date(state.run.startedAt);
+  const elapsed = now.getTime() - startedAt.getTime();
+  const blocked = [];
+  const skipped = [];
+  for (const [key, story] of Object.entries(state.stories)) {
+    if (story.status === "blocked") {
+      blocked.push(key);
+      if (story.attempts >= MAX_ATTEMPTS2) {
+        skipped.push(key);
+      }
+    }
+  }
+  return {
+    duration: formatDuration(elapsed),
+    cost: state.run.cost,
+    iterations: state.run.iteration,
+    completed: [...state.run.completed],
+    failed: [...state.run.failed],
+    blocked,
+    skipped
+  };
+}
+function generateReport(state, now) {
+  try {
+    const effectiveNow = now ?? /* @__PURE__ */ new Date();
+    const stories = state.stories;
+    let total = 0;
+    let done = 0;
+    let failed = 0;
+    let blocked = 0;
+    const storyStatuses = [];
+    for (const [key, story] of Object.entries(stories)) {
+      total++;
+      if (story.status === "done") done++;
+      else if (story.status === "failed") failed++;
+      else if (story.status === "blocked") blocked++;
+      storyStatuses.push({ key, status: story.status });
+    }
+    const sprintPercent = total > 0 ? Math.round(done / total * 100) : 0;
+    const { epicsTotal, epicsDone } = computeEpicProgress(stories);
+    const runSummary = buildRunSummary(state, effectiveNow);
+    const activeRun = state.run.active ? runSummary : null;
+    const lastRun = !state.run.active ? runSummary : null;
+    const failedDetails = buildFailedDetails(stories);
+    const actionItemsLabeled = buildActionItemsLabeled(state);
+    return ok2({
+      total,
+      done,
+      failed,
+      blocked,
+      inProgress: state.sprint.inProgress,
+      storyStatuses,
+      epicsTotal,
+      epicsDone,
+      sprintPercent,
+      activeRun,
+      lastRun,
+      failedDetails,
+      actionItemsLabeled
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return fail2(`Failed to generate report: ${msg}`);
+  }
+}
+
+// src/modules/sprint/timeout.ts
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync10, existsSync as existsSync21, mkdirSync as mkdirSync7 } from "fs";
+import { execSync as execSync3 } from "child_process";
+import { join as join18 } from "path";
+var GIT_TIMEOUT_MS = 5e3;
+var DEFAULT_MAX_LINES = 100;
+function captureGitDiff() {
+  try {
+    const unstaged = execSync3("git diff --stat", {
+      timeout: GIT_TIMEOUT_MS,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const staged = execSync3("git diff --cached --stat", {
+      timeout: GIT_TIMEOUT_MS,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const parts = [];
+    if (unstaged) parts.push("Unstaged:\n" + unstaged);
+    if (staged) parts.push("Staged:\n" + staged);
+    if (parts.length === 0) {
+      return ok2("No changes detected");
+    }
+    return ok2(parts.join("\n\n"));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return fail2(`Failed to capture git diff: ${msg}`);
+  }
+}
+function captureStateDelta(beforePath, afterPath) {
+  try {
+    if (!existsSync21(beforePath)) {
+      return fail2(`State snapshot not found: ${beforePath}`);
+    }
+    if (!existsSync21(afterPath)) {
+      return fail2(`Current state file not found: ${afterPath}`);
+    }
+    const beforeRaw = readFileSync18(beforePath, "utf-8");
+    const afterRaw = readFileSync18(afterPath, "utf-8");
+    const before = JSON.parse(beforeRaw);
+    const after = JSON.parse(afterRaw);
+    const beforeStories = before.stories ?? {};
+    const afterStories = after.stories ?? {};
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(beforeStories), ...Object.keys(afterStories)]);
+    const changes = [];
+    for (const key of allKeys) {
+      const beforeStatus = beforeStories[key]?.status ?? "(absent)";
+      const afterStatus = afterStories[key]?.status ?? "(absent)";
+      if (beforeStatus !== afterStatus) {
+        changes.push(`${key}: ${beforeStatus} \u2192 ${afterStatus}`);
+      }
+    }
+    if (changes.length === 0) {
+      return ok2("No state changes");
+    }
+    return ok2(changes.join("\n"));
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return fail2(`Failed to capture state delta: ${msg}`);
+  }
+}
+function capturePartialStderr(outputFile, maxLines = DEFAULT_MAX_LINES) {
+  try {
+    if (!existsSync21(outputFile)) {
+      return fail2(`Output file not found: ${outputFile}`);
+    }
+    const content = readFileSync18(outputFile, "utf-8");
+    const lines = content.split("\n");
+    if (lines.length > 0 && lines[lines.length - 1] === "") {
+      lines.pop();
+    }
+    const lastLines = lines.slice(-maxLines).join("\n");
+    return ok2(lastLines);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return fail2(`Failed to capture partial stderr: ${msg}`);
+  }
+}
+function formatReport(capture) {
+  const lines = [
+    `# Timeout Report: Iteration ${capture.iteration}`,
+    "",
+    `- **Story:** ${capture.storyKey}`,
+    `- **Duration:** ${capture.durationMinutes} minutes (timeout)`,
+    `- **Timestamp:** ${capture.timestamp}`,
+    "",
+    "## Git Changes",
+    "",
+    capture.gitDiff,
+    "",
+    "## State Delta",
+    "",
+    capture.stateDelta,
+    "",
+    "## Partial Output (last 100 lines)",
+    "",
+    "```",
+    capture.partialStderr,
+    "```",
+    ""
+  ];
+  return lines.join("\n");
+}
+function captureTimeoutReport(opts) {
+  try {
+    if (opts.iteration < 1 || !Number.isInteger(opts.iteration)) {
+      return fail2(`Invalid iteration number: ${opts.iteration}`);
+    }
+    if (opts.durationMinutes < 0) {
+      return fail2(`Invalid duration: ${opts.durationMinutes}`);
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const gitResult = captureGitDiff();
+    const gitDiff = gitResult.success ? gitResult.data : `(unavailable: ${gitResult.error})`;
+    const statePath2 = join18(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);
+    const partialStderr = stderrResult.success ? stderrResult.data : `(unavailable: ${stderrResult.error})`;
+    const capture = {
+      storyKey: opts.storyKey,
+      iteration: opts.iteration,
+      durationMinutes: opts.durationMinutes,
+      gitDiff,
+      stateDelta,
+      partialStderr,
+      timestamp
+    };
+    const reportDir = join18(process.cwd(), "ralph", "logs");
+    const safeStoryKey = opts.storyKey.replace(/[^a-zA-Z0-9._-]/g, "_");
+    const reportFileName = `timeout-report-${opts.iteration}-${safeStoryKey}.md`;
+    const reportPath = join18(reportDir, reportFileName);
+    if (!existsSync21(reportDir)) {
+      mkdirSync7(reportDir, { recursive: true });
+    }
+    const reportContent = formatReport(capture);
+    writeFileSync10(reportPath, reportContent, "utf-8");
+    return ok2({
+      filePath: reportPath,
+      capture
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return fail2(`Failed to capture timeout report: ${msg}`);
+  }
+}
+
+// src/modules/sprint/feedback.ts
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync22 } from "fs";
+import { join as join19 } from "path";
+
+// src/modules/sprint/validator.ts
+import { readFileSync as readFileSync20, existsSync as existsSync23 } from "fs";
+var VALID_STATUSES = /* @__PURE__ */ new Set([
+  "backlog",
+  "ready",
+  "in-progress",
+  "review",
+  "verifying",
+  "done",
+  "failed",
+  "blocked"
+]);
+var STALE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
+function parseSprintStatusKeys(content) {
+  try {
+    const keys = [];
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const match = line.match(/^([a-zA-Z0-9][a-zA-Z0-9._-]*):$/);
+      if (match) {
+        keys.push(match[1]);
+      }
+    }
+    return ok2(keys);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return fail2(`Failed to parse sprint-status.yaml: ${msg}`);
+  }
+}
+function parseStateFile(statePath2) {
+  try {
+    if (!existsSync23(statePath2)) {
+      return fail2(`State file not found: ${statePath2}`);
+    }
+    const raw = readFileSync20(statePath2, "utf-8");
+    const parsed = JSON.parse(raw);
+    return ok2(parsed);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return fail2(`Failed to parse state file: ${msg}`);
+  }
+}
+function validateStateConsistency(statePath2, sprintStatusPath) {
+  try {
+    const stateResult = parseStateFile(statePath2);
+    if (!stateResult.success) {
+      return fail2(stateResult.error);
+    }
+    const state = stateResult.data;
+    if (!existsSync23(sprintStatusPath)) {
+      return fail2(`Sprint status file not found: ${sprintStatusPath}`);
+    }
+    const statusContent = readFileSync20(sprintStatusPath, "utf-8");
+    const keysResult = parseSprintStatusKeys(statusContent);
+    if (!keysResult.success) {
+      return fail2(keysResult.error);
+    }
+    const expectedKeys = keysResult.data;
+    const issues = [];
+    const missingKeys = [];
+    for (const key of expectedKeys) {
+      if (!(key in state.stories)) {
+        missingKeys.push(key);
+        issues.push({
+          storyKey: key,
+          field: "entry",
+          message: `Story "${key}" in sprint-status.yaml has no entry in sprint-state.json`
+        });
+      }
+    }
+    const actualStoryCount = Object.keys(state.stories).length;
+    if (state.sprint.total !== actualStoryCount) {
+      issues.push({
+        storyKey: "_sprint",
+        field: "sprint.total",
+        message: `sprint.total is ${state.sprint.total} but state has ${actualStoryCount} stories`
+      });
+    }
+    for (const key of Object.keys(state.stories)) {
+      if (!expectedKeys.includes(key)) {
+        issues.push({
+          storyKey: key,
+          field: "entry",
+          message: `Story "${key}" in sprint-state.json has no entry in sprint-status.yaml`
+        });
+      }
+    }
+    for (const [key, story] of Object.entries(state.stories)) {
+      if (!VALID_STATUSES.has(story.status)) {
+        issues.push({
+          storyKey: key,
+          field: "status",
+          message: `Invalid status "${story.status}" (expected one of: ${[...VALID_STATUSES].join(", ")})`
+        });
+      }
+      if (typeof story.attempts !== "number" || !Number.isInteger(story.attempts) || story.attempts < 0) {
+        issues.push({
+          storyKey: key,
+          field: "attempts",
+          message: `Invalid attempts value "${story.attempts}" (must be non-negative integer)`
+        });
+      }
+      if (story.lastError !== null && story.lastAttempt !== null) {
+        const attemptTime = new Date(story.lastAttempt).getTime();
+        const now = Date.now();
+        if (!isNaN(attemptTime) && now - attemptTime > STALE_THRESHOLD_MS) {
+          issues.push({
+            storyKey: key,
+            field: "lastError",
+            message: `Stale lastError: lastAttempt was "${story.lastAttempt}" (>24h ago)`
+          });
+        }
+      }
+    }
+    const allKeys = /* @__PURE__ */ new Set([...expectedKeys, ...Object.keys(state.stories)]);
+    const totalStories = allKeys.size;
+    const invalidCount = new Set(issues.map((i) => i.storyKey)).size;
+    const validCount = totalStories - invalidCount;
+    return ok2({
+      totalStories,
+      validCount,
+      invalidCount,
+      missingKeys,
+      issues
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return fail2(`Validation failed: ${msg}`);
+  }
+}
+
+// src/modules/sprint/index.ts
+function generateReport2() {
+  const stateResult = getSprintState();
+  if (!stateResult.success) {
+    return fail2(stateResult.error);
+  }
+  return generateReport(stateResult.data);
+}
+function getStoryDrillDown2(key) {
+  const stateResult = getSprintState();
+  if (!stateResult.success) {
+    return fail2(stateResult.error);
+  }
+  return getStoryDrillDown(stateResult.data, key);
+}
+function captureTimeoutReport2(opts) {
+  return captureTimeoutReport(opts);
+}
+function validateStateConsistency2(statePath2, sprintStatusPath) {
+  return validateStateConsistency(statePath2, sprintStatusPath);
+}
+
 // src/commands/status.ts
 function buildScopedEndpoints(endpoints, serviceName) {
   const encoded = encodeURIComponent(serviceName);
@@ -4513,9 +5569,13 @@ var DEFAULT_ENDPOINTS = {
   otel_http: "http://localhost:4318"
 };
 function registerStatusCommand(program) {
-  program.command("status").description("Show current harness status and health").option("--check-docker", "Check Docker stack health").option("--check", "Run health checks with pass/fail exit code").action(async (options, cmd) => {
+  program.command("status").description("Show current harness status and health").option("--check-docker", "Check Docker stack health").option("--check", "Run health checks with pass/fail exit code").option("--story <id>", "Show detailed status for a specific story").action(async (options, cmd) => {
     const opts = cmd.optsWithGlobals();
     const isJson = opts.json === true;
+    if (options.story) {
+      handleStoryDrillDown(options.story, isJson);
+      return;
+    }
     if (options.checkDocker) {
       await handleDockerCheck(isJson);
       return;
@@ -4547,6 +5607,7 @@ function handleFullStatus(isJson) {
     handleFullStatusJson(state);
     return;
   }
+  printSprintState();
   console.log(`Harness: codeharness v${state.harness_version}`);
   console.log(`Stack: ${state.stack ?? "unknown"}`);
   if (state.app_type) {
@@ -4683,10 +5744,12 @@ function handleFullStatusJson(state) {
   const scoped_endpoints = serviceName ? buildScopedEndpoints(endpoints, serviceName) : void 0;
   const beads = getBeadsData();
   const onboarding = getOnboardingProgressData();
+  const sprint = getSprintReportData();
   jsonOutput({
     version: state.harness_version,
     stack: state.stack,
     ...state.app_type ? { app_type: state.app_type } : {},
+    ...sprint ? { sprint } : {},
     enforcement: state.enforcement,
     docker,
     endpoints,
@@ -4878,6 +5941,116 @@ async function handleDockerCheck(isJson) {
     }
   }
 }
+function handleStoryDrillDown(storyId, isJson) {
+  const result = getStoryDrillDown2(storyId);
+  if (!result.success) {
+    if (isJson) {
+      jsonOutput({ status: "fail", message: result.error });
+    } else {
+      fail(result.error);
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const d = result.data;
+  if (isJson) {
+    jsonOutput({
+      key: d.key,
+      status: d.status,
+      epic: d.epic,
+      attempts: d.attempts,
+      maxAttempts: d.maxAttempts,
+      lastAttempt: d.lastAttempt,
+      acResults: d.acDetails,
+      attemptHistory: d.attemptHistory,
+      proof: d.proofSummary
+    });
+    return;
+  }
+  console.log(`Story: ${d.key}`);
+  console.log(`Status: ${d.status} (attempt ${d.attempts}/${d.maxAttempts})`);
+  console.log(`Epic: ${d.epic}`);
+  console.log(`Last attempt: ${d.lastAttempt ?? "none"}`);
+  console.log("");
+  console.log("-- AC Results -------------------------------------------------------");
+  if (d.acDetails.length === 0) {
+    console.log("No AC results recorded");
+  } else {
+    for (const ac of d.acDetails) {
+      const tag = ac.verdict.toUpperCase();
+      console.log(`${ac.id}: [${tag}]`);
+      if (ac.verdict === "fail") {
+        if (ac.command) console.log(`  Command:  ${ac.command}`);
+        if (ac.expected) console.log(`  Expected: ${ac.expected}`);
+        if (ac.actual) console.log(`  Actual:   ${ac.actual}`);
+        if (ac.reason) console.log(`  Reason:   ${ac.reason}`);
+        if (ac.suggestedFix) console.log(`  Suggest:  ${ac.suggestedFix}`);
+      }
+    }
+  }
+  if (d.attemptHistory.length > 0) {
+    console.log("");
+    console.log("-- History ----------------------------------------------------------");
+    for (const attempt of d.attemptHistory) {
+      const acPart = attempt.failingAc ? ` (${attempt.failingAc})` : "";
+      console.log(`Attempt ${attempt.number}: ${attempt.outcome}${acPart}`);
+    }
+  }
+  if (d.proofSummary) {
+    console.log("");
+    const p = d.proofSummary;
+    const total = p.passCount + p.failCount + p.escalateCount + p.pendingCount;
+    console.log(
+      `Proof: ${p.path} (${p.passCount}/${total} pass, ${p.failCount} fail, ${p.escalateCount} escalate)`
+    );
+  }
+}
+function printSprintState() {
+  const reportResult = generateReport2();
+  if (!reportResult.success) {
+    console.log("Sprint state: unavailable");
+    return;
+  }
+  const r = reportResult.data;
+  console.log(`\u2500\u2500 Project State \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+  console.log(`Sprint: ${r.done}/${r.total} done (${r.sprintPercent}%) | ${r.epicsDone}/${r.epicsTotal} epics complete`);
+  if (r.activeRun) {
+    console.log("");
+    console.log(`\u2500\u2500 Active Run \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    const currentStory = r.inProgress ?? "none";
+    console.log(`Status: running (iteration ${r.activeRun.iterations}, ${r.activeRun.duration} elapsed)`);
+    console.log(`Current: ${currentStory}`);
+    console.log(`Budget: $${r.activeRun.cost.toFixed(2)} spent`);
+  } else if (r.lastRun) {
+    console.log("");
+    console.log(`\u2500\u2500 Last Run Summary \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    console.log(`Duration: ${r.lastRun.duration} | Cost: $${r.lastRun.cost.toFixed(2)} | Iterations: ${r.lastRun.iterations}`);
+    console.log(`Completed:  ${r.lastRun.completed.length} stories${r.lastRun.completed.length > 0 ? ` (${r.lastRun.completed.join(", ")})` : ""}`);
+    if (r.failedDetails.length > 0) {
+      console.log(`Failed:     ${r.failedDetails.length} stor${r.failedDetails.length === 1 ? "y" : "ies"}`);
+      for (const fd of r.failedDetails) {
+        const acPart = fd.acNumber !== null ? `AC ${fd.acNumber}` : "unknown AC";
+        console.log(`  \u2514 ${fd.key}: ${acPart} \u2014 ${fd.errorLine} (attempt ${fd.attempts}/${fd.maxAttempts})`);
+      }
+    }
+    if (r.lastRun.blocked.length > 0) {
+      console.log(`Blocked:    ${r.lastRun.blocked.length} stories (retry-exhausted)`);
+    }
+  }
+  if (r.actionItemsLabeled.length > 0) {
+    console.log("");
+    console.log(`\u2500\u2500 Action Items \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`);
+    for (const la of r.actionItemsLabeled) {
+      console.log(`  [${la.label}] ${la.item.story}: ${la.item.description}`);
+    }
+  }
+  console.log("");
+}
+function getSprintReportData() {
+  const reportResult = generateReport2();
+  if (!reportResult.success) return null;
+  return reportResult.data;
+}
 function printBeadsSummary() {
   if (!isBeadsInitialized()) {
     console.log("Beads: not initialized");
@@ -4944,16 +6117,16 @@ function getBeadsData() {
 }
 
 // src/commands/onboard.ts
-import { join as join18 } from "path";
+import { join as join23 } from "path";
 
 // src/lib/scanner.ts
 import {
-  existsSync as existsSync17,
-  readdirSync as readdirSync3,
-  readFileSync as readFileSync15,
-  statSync as statSync2
+  existsSync as existsSync24,
+  readdirSync as readdirSync4,
+  readFileSync as readFileSync21,
+  statSync as statSync3
 } from "fs";
-import { join as join15, relative as relative2 } from "path";
+import { join as join20, relative as relative2 } from "path";
 var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".js", ".py"]);
 var DEFAULT_MIN_MODULE_SIZE = 3;
 function getExtension2(filename) {
@@ -4971,17 +6144,17 @@ function countSourceFiles(dir) {
   function walk(current) {
     let entries;
     try {
-      entries = readdirSync3(current);
+      entries = readdirSync4(current);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (isSkippedDir(entry)) continue;
       if (entry.startsWith(".") && current !== dir) continue;
-      const fullPath = join15(current, entry);
+      const fullPath = join20(current, entry);
       let stat;
       try {
-        stat = statSync2(fullPath);
+        stat = statSync3(fullPath);
       } catch {
         continue;
       }
@@ -5001,22 +6174,22 @@ function countSourceFiles(dir) {
   return count;
 }
 function countModuleFiles(modulePath, rootDir) {
-  const fullModulePath = join15(rootDir, modulePath);
+  const fullModulePath = join20(rootDir, modulePath);
   let sourceFiles = 0;
   let testFiles = 0;
   function walk(current) {
     let entries;
     try {
-      entries = readdirSync3(current);
+      entries = readdirSync4(current);
     } catch {
       return;
     }
     for (const entry of entries) {
       if (isSkippedDir(entry)) continue;
-      const fullPath = join15(current, entry);
+      const fullPath = join20(current, entry);
       let stat;
       try {
-        stat = statSync2(fullPath);
+        stat = statSync3(fullPath);
       } catch {
         continue;
       }
@@ -5038,8 +6211,8 @@ function countModuleFiles(modulePath, rootDir) {
   return { sourceFiles, testFiles };
 }
 function detectArtifacts(dir) {
-  const bmadPath = join15(dir, "_bmad");
-  const hasBmad = existsSync17(bmadPath);
+  const bmadPath = join20(dir, "_bmad");
+  const hasBmad = existsSync24(bmadPath);
   return {
     hasBmad,
     bmadPath: hasBmad ? relative2(dir, bmadPath) || "_bmad" : null
@@ -5121,10 +6294,10 @@ function readPerFileCoverage(dir, format) {
   return null;
 }
 function readVitestPerFileCoverage(dir) {
-  const reportPath = join15(dir, "coverage", "coverage-summary.json");
-  if (!existsSync17(reportPath)) return null;
+  const reportPath = join20(dir, "coverage", "coverage-summary.json");
+  if (!existsSync24(reportPath)) return null;
   try {
-    const report = JSON.parse(readFileSync15(reportPath, "utf-8"));
+    const report = JSON.parse(readFileSync21(reportPath, "utf-8"));
     const result = /* @__PURE__ */ new Map();
     for (const [key, value] of Object.entries(report)) {
       if (key === "total") continue;
@@ -5136,10 +6309,10 @@ function readVitestPerFileCoverage(dir) {
   }
 }
 function readPythonPerFileCoverage(dir) {
-  const reportPath = join15(dir, "coverage.json");
-  if (!existsSync17(reportPath)) return null;
+  const reportPath = join20(dir, "coverage.json");
+  if (!existsSync24(reportPath)) return null;
   try {
-    const report = JSON.parse(readFileSync15(reportPath, "utf-8"));
+    const report = JSON.parse(readFileSync21(reportPath, "utf-8"));
     if (!report.files) return null;
     const result = /* @__PURE__ */ new Map();
     for (const [key, value] of Object.entries(report.files)) {
@@ -5155,13 +6328,13 @@ function auditDocumentation(dir) {
   const root = dir ?? process.cwd();
   const documents = [];
   for (const docName of AUDIT_DOCUMENTS) {
-    const docPath = join15(root, docName);
-    if (!existsSync17(docPath)) {
+    const docPath = join20(root, docName);
+    if (!existsSync24(docPath)) {
       documents.push({ name: docName, grade: "missing", path: null });
       continue;
     }
-    const srcDir = join15(root, "src");
-    const codeDir = existsSync17(srcDir) ? srcDir : root;
+    const srcDir = join20(root, "src");
+    const codeDir = existsSync24(srcDir) ? srcDir : root;
     const stale = isDocStale(docPath, codeDir);
     documents.push({
       name: docName,
@@ -5169,10 +6342,10 @@ function auditDocumentation(dir) {
       path: docName
     });
   }
-  const docsDir = join15(root, "docs");
-  if (existsSync17(docsDir)) {
+  const docsDir = join20(root, "docs");
+  if (existsSync24(docsDir)) {
     try {
-      const stat = statSync2(docsDir);
+      const stat = statSync3(docsDir);
       if (stat.isDirectory()) {
         documents.push({ name: "docs/", grade: "present", path: "docs/" });
       }
@@ -5182,10 +6355,10 @@ function auditDocumentation(dir) {
   } else {
     documents.push({ name: "docs/", grade: "missing", path: null });
   }
-  const indexPath = join15(root, "docs", "index.md");
-  if (existsSync17(indexPath)) {
-    const srcDir = join15(root, "src");
-    const indexCodeDir = existsSync17(srcDir) ? srcDir : root;
+  const indexPath = join20(root, "docs", "index.md");
+  if (existsSync24(indexPath)) {
+    const srcDir = join20(root, "src");
+    const indexCodeDir = existsSync24(srcDir) ? srcDir : root;
     const indexStale = isDocStale(indexPath, indexCodeDir);
     documents.push({
       name: "docs/index.md",
@@ -5202,8 +6375,8 @@ function auditDocumentation(dir) {
 
 // src/lib/epic-generator.ts
 import { createInterface } from "readline";
-import { existsSync as existsSync18, mkdirSync as mkdirSync6, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname5, join as join16 } from "path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync8, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname6, join as join21 } from "path";
 var PRIORITY_BY_TYPE = {
   observability: 1,
   coverage: 2,
@@ -5241,8 +6414,8 @@ function generateOnboardingEpic(scan, coverage, audit, rootDir) {
     storyNum++;
   }
   for (const mod of scan.modules) {
-    const agentsPath = join16(root, mod.path, "AGENTS.md");
-    if (!existsSync18(agentsPath)) {
+    const agentsPath = join21(root, mod.path, "AGENTS.md");
+    if (!existsSync25(agentsPath)) {
       stories.push({
         key: `0.${storyNum}`,
         title: `Create ${mod.path}/AGENTS.md`,
@@ -5308,7 +6481,7 @@ function generateOnboardingEpic(scan, coverage, audit, rootDir) {
   };
 }
 function writeOnboardingEpic(epic, outputPath) {
-  mkdirSync6(dirname5(outputPath), { recursive: true });
+  mkdirSync8(dirname6(outputPath), { recursive: true });
   const lines = [];
   lines.push(`# ${epic.title}`);
   lines.push("");
@@ -5344,14 +6517,14 @@ function writeOnboardingEpic(epic, outputPath) {
   lines.push("");
   lines.push("Review and approve before execution.");
   lines.push("");
-  writeFileSync9(outputPath, lines.join("\n"), "utf-8");
+  writeFileSync12(outputPath, lines.join("\n"), "utf-8");
 }
 function formatEpicSummary(epic) {
   const { totalStories, coverageStories, docStories, verificationStories, observabilityStories } = epic.summary;
   return `Onboarding plan: ${totalStories} stories (${coverageStories} coverage, ${docStories} documentation, ${verificationStories} verification, ${observabilityStories} observability)`;
 }
 function promptApproval() {
-  return new Promise((resolve) => {
+  return new Promise((resolve3) => {
     let answered = false;
     const rl = createInterface({
       input: process.stdin,
@@ -5360,14 +6533,14 @@ function promptApproval() {
     rl.on("close", () => {
       if (!answered) {
         answered = true;
-        resolve(false);
+        resolve3(false);
       }
     });
     rl.question("Review the onboarding plan. Approve? [Y/n] ", (answer) => {
       answered = true;
       rl.close();
       const trimmed = answer.trim().toLowerCase();
-      resolve(trimmed === "" || trimmed === "y");
+      resolve3(trimmed === "" || trimmed === "y");
     });
   });
 }
@@ -5440,29 +6613,29 @@ function getGapIdFromTitle(title) {
 }
 
 // src/lib/scan-cache.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync7, readFileSync as readFileSync16, writeFileSync as writeFileSync10 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync9, readFileSync as readFileSync22, writeFileSync as writeFileSync13 } from "fs";
+import { join as join22 } from "path";
 var CACHE_DIR = ".harness";
 var CACHE_FILE = "last-onboard-scan.json";
 var DEFAULT_MAX_AGE_MS = 864e5;
 function saveScanCache(entry, dir) {
   try {
     const root = dir ?? process.cwd();
-    const cacheDir = join17(root, CACHE_DIR);
-    mkdirSync7(cacheDir, { recursive: true });
-    const cachePath = join17(cacheDir, CACHE_FILE);
-    writeFileSync10(cachePath, JSON.stringify(entry, null, 2), "utf-8");
+    const cacheDir = join22(root, CACHE_DIR);
+    mkdirSync9(cacheDir, { recursive: true });
+    const cachePath = join22(cacheDir, CACHE_FILE);
+    writeFileSync13(cachePath, JSON.stringify(entry, null, 2), "utf-8");
   } catch {
   }
 }
 function loadScanCache(dir) {
   const root = dir ?? process.cwd();
-  const cachePath = join17(root, CACHE_DIR, CACHE_FILE);
-  if (!existsSync19(cachePath)) {
+  const cachePath = join22(root, CACHE_DIR, CACHE_FILE);
+  if (!existsSync26(cachePath)) {
     return null;
   }
   try {
-    const raw = readFileSync16(cachePath, "utf-8");
+    const raw = readFileSync22(cachePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5635,7 +6808,7 @@ function registerOnboardCommand(program) {
     }
     coverage = lastCoverageResult ?? runCoverageAnalysis(scan);
     audit = lastAuditResult ?? runAudit();
-    const epicPath = join18(process.cwd(), "ralph", "onboarding-epic.md");
+    const epicPath = join23(process.cwd(), "ralph", "onboarding-epic.md");
     const epic = generateOnboardingEpic(scan, coverage, audit);
     mergeExtendedGaps(epic);
     if (!isFull) {
@@ -5708,7 +6881,7 @@ function registerOnboardCommand(program) {
       coverage,
       audit
     });
-    const epicPath = join18(process.cwd(), "ralph", "onboarding-epic.md");
+    const epicPath = join23(process.cwd(), "ralph", "onboarding-epic.md");
     const epic = generateOnboardingEpic(scan, coverage, audit);
     mergeExtendedGaps(epic);
     if (!isFull) {
@@ -5816,8 +6989,8 @@ function printEpicOutput(epic) {
 }
 
 // src/commands/teardown.ts
-import { existsSync as existsSync20, unlinkSync as unlinkSync2, readFileSync as readFileSync17, writeFileSync as writeFileSync11, rmSync } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync27, unlinkSync as unlinkSync2, readFileSync as readFileSync23, writeFileSync as writeFileSync14, rmSync as rmSync2 } from "fs";
+import { join as join24 } from "path";
 function buildDefaultResult() {
   return {
     status: "ok",
@@ -5920,16 +7093,16 @@ function registerTeardownCommand(program) {
           info("Docker stack: not running, skipping");
         }
       }
-      const composeFilePath = join19(projectDir, composeFile);
-      if (existsSync20(composeFilePath)) {
+      const composeFilePath = join24(projectDir, composeFile);
+      if (existsSync27(composeFilePath)) {
         unlinkSync2(composeFilePath);
         result.removed.push(composeFile);
         if (!isJson) {
           ok(`Removed: ${composeFile}`);
         }
       }
-      const otelConfigPath = join19(projectDir, "otel-collector-config.yaml");
-      if (existsSync20(otelConfigPath)) {
+      const otelConfigPath = join24(projectDir, "otel-collector-config.yaml");
+      if (existsSync27(otelConfigPath)) {
         unlinkSync2(otelConfigPath);
         result.removed.push("otel-collector-config.yaml");
         if (!isJson) {
@@ -5939,8 +7112,8 @@ function registerTeardownCommand(program) {
     }
     let patchesRemoved = 0;
     for (const [patchName, relativePath] of Object.entries(PATCH_TARGETS)) {
-      const filePath = join19(projectDir, "_bmad", relativePath);
-      if (!existsSync20(filePath)) {
+      const filePath = join24(projectDir, "_bmad", relativePath);
+      if (!existsSync27(filePath)) {
         continue;
       }
       try {
@@ -5960,10 +7133,10 @@ function registerTeardownCommand(program) {
       }
     }
     if (state.otlp?.enabled && state.stack === "nodejs") {
-      const pkgPath = join19(projectDir, "package.json");
-      if (existsSync20(pkgPath)) {
+      const pkgPath = join24(projectDir, "package.json");
+      if (existsSync27(pkgPath)) {
         try {
-          const raw = readFileSync17(pkgPath, "utf-8");
+          const raw = readFileSync23(pkgPath, "utf-8");
           const pkg = JSON.parse(raw);
           const scripts = pkg["scripts"];
           if (scripts) {
@@ -5977,7 +7150,7 @@ function registerTeardownCommand(program) {
               for (const key of keysToRemove) {
                 delete scripts[key];
               }
-              writeFileSync11(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+              writeFileSync14(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
               result.otlp_cleaned = true;
               if (!isJson) {
                 ok("OTLP: removed instrumented scripts from package.json");
@@ -6003,17 +7176,17 @@ function registerTeardownCommand(program) {
         }
       }
     }
-    const harnessDir = join19(projectDir, ".harness");
-    if (existsSync20(harnessDir)) {
-      rmSync(harnessDir, { recursive: true, force: true });
+    const harnessDir = join24(projectDir, ".harness");
+    if (existsSync27(harnessDir)) {
+      rmSync2(harnessDir, { recursive: true, force: true });
       result.removed.push(".harness/");
       if (!isJson) {
         ok("Removed: .harness/");
       }
     }
-    const statePath = getStatePath(projectDir);
-    if (existsSync20(statePath)) {
-      unlinkSync2(statePath);
+    const statePath2 = getStatePath(projectDir);
+    if (existsSync27(statePath2)) {
+      unlinkSync2(statePath2);
       result.removed.push(".claude/codeharness.local.md");
       if (!isJson) {
         ok("Removed: .claude/codeharness.local.md");
@@ -6756,8 +7929,8 @@ function registerQueryCommand(program) {
 }
 
 // src/commands/retro-import.ts
-import { existsSync as existsSync21, readFileSync as readFileSync18 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync28, readFileSync as readFileSync24 } from "fs";
+import { join as join25 } from "path";
 
 // src/lib/retro-parser.ts
 var KNOWN_TOOLS = ["showboat", "ralph", "beads", "bmad"];
@@ -6814,7 +7987,7 @@ function derivePriority(item) {
 }
 
 // src/lib/github.ts
-import { execFileSync as execFileSync6 } from "child_process";
+import { execFileSync as execFileSync7 } from "child_process";
 var GitHubError = class extends Error {
   constructor(command, originalMessage) {
     super(`GitHub CLI failed: ${originalMessage}. Command: ${command}`);
@@ -6825,7 +7998,7 @@ var GitHubError = class extends Error {
 };
 function isGhAvailable() {
   try {
-    execFileSync6("which", ["gh"], { stdio: "pipe", timeout: 5e3 });
+    execFileSync7("which", ["gh"], { stdio: "pipe", timeout: 5e3 });
     return true;
   } catch {
     return false;
@@ -6839,7 +8012,7 @@ function ghIssueCreate(repo, title, body, labels) {
   args.push("--json", "number,url");
   const cmdStr = `gh ${args.join(" ")}`;
   try {
-    const output = execFileSync6("gh", args, {
+    const output = execFileSync7("gh", args, {
       stdio: "pipe",
       timeout: 3e4
     });
@@ -6854,7 +8027,7 @@ function ghIssueSearch(repo, query) {
   const args = ["issue", "list", "--repo", repo, "--search", query, "--state", "all", "--json", "number,title,body,url,labels"];
   const cmdStr = `gh ${args.join(" ")}`;
   try {
-    const output = execFileSync6("gh", args, {
+    const output = execFileSync7("gh", args, {
       stdio: "pipe",
       timeout: 3e4
     });
@@ -6876,7 +8049,7 @@ function findExistingGhIssue(repo, gapId) {
 }
 function getRepoFromRemote() {
   try {
-    const output = execFileSync6("git", ["remote", "get-url", "origin"], {
+    const output = execFileSync7("git", ["remote", "get-url", "origin"], {
       stdio: "pipe",
       timeout: 5e3
     });
@@ -6896,7 +8069,7 @@ function parseRepoFromUrl(url) {
 function ensureLabels(repo, labels) {
   for (const label of labels) {
     try {
-      execFileSync6("gh", ["label", "create", label, "--repo", repo], {
+      execFileSync7("gh", ["label", "create", label, "--repo", repo], {
         stdio: "pipe",
         timeout: 1e4
       });
@@ -6906,7 +8079,7 @@ function ensureLabels(repo, labels) {
 }
 
 // src/commands/retro-import.ts
-var STORY_DIR2 = "_bmad-output/implementation-artifacts";
+var STORY_DIR3 = "_bmad-output/implementation-artifacts";
 var MAX_TITLE_LENGTH = 120;
 function classificationToString(c) {
   if (c.type === "tool") {
@@ -6926,15 +8099,15 @@ function registerRetroImportCommand(program) {
       return;
     }
     const retroFile = `epic-${epicNum}-retrospective.md`;
-    const retroPath = join20(root, STORY_DIR2, retroFile);
-    if (!existsSync21(retroPath)) {
+    const retroPath = join25(root, STORY_DIR3, retroFile);
+    if (!existsSync28(retroPath)) {
       fail(`Retro file not found: ${retroFile}`, { json: isJson });
       process.exitCode = 1;
       return;
     }
     let content;
     try {
-      content = readFileSync18(retroPath, "utf-8");
+      content = readFileSync24(retroPath, "utf-8");
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       fail(`Failed to read retro file: ${message}`, { json: isJson });
@@ -7200,292 +8373,6 @@ function registerGithubImportCommand(program) {
   });
 }
 
-// src/lib/verify-env.ts
-import { execFileSync as execFileSync7 } from "child_process";
-import { existsSync as existsSync22, mkdirSync as mkdirSync8, readdirSync as readdirSync4, readFileSync as readFileSync19, cpSync, rmSync as rmSync2, statSync as statSync3 } from "fs";
-import { join as join21, basename as basename3 } from "path";
-import { createHash } from "crypto";
-var IMAGE_TAG = "codeharness-verify";
-var STORY_DIR3 = "_bmad-output/implementation-artifacts";
-var TEMP_PREFIX = "/tmp/codeharness-verify-";
-var STATE_KEY_DIST_HASH = "verify_env_dist_hash";
-function isValidStoryKey(storyKey) {
-  if (!storyKey || storyKey.includes("..") || storyKey.includes("/") || storyKey.includes("\\")) {
-    return false;
-  }
-  return /^[a-zA-Z0-9_-]+$/.test(storyKey);
-}
-function computeDistHash(projectDir) {
-  const distDir = join21(projectDir, "dist");
-  if (!existsSync22(distDir)) {
-    return null;
-  }
-  const hash = createHash("sha256");
-  const files = collectFiles(distDir).sort();
-  for (const file of files) {
-    const content = readFileSync19(file);
-    hash.update(file.slice(distDir.length));
-    hash.update(content);
-  }
-  return hash.digest("hex");
-}
-function collectFiles(dir) {
-  const results = [];
-  const entries = readdirSync4(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = join21(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...collectFiles(fullPath));
-    } else {
-      results.push(fullPath);
-    }
-  }
-  return results;
-}
-function getStoredDistHash(projectDir) {
-  try {
-    const { state } = readStateWithBody(projectDir);
-    const raw = state;
-    return raw[STATE_KEY_DIST_HASH] ?? null;
-  } catch {
-    return null;
-  }
-}
-function storeDistHash(projectDir, hash) {
-  try {
-    const { state, body } = readStateWithBody(projectDir);
-    const raw = state;
-    raw[STATE_KEY_DIST_HASH] = hash;
-    writeState(state, projectDir, body);
-  } catch {
-    info("Could not persist dist hash to state file \u2014 cache will not be available until state is initialized");
-  }
-}
-function buildVerifyImage(options = {}) {
-  const projectDir = options.projectDir ?? process.cwd();
-  if (!isDockerAvailable()) {
-    throw new Error("Docker is not available. Install Docker and ensure the daemon is running.");
-  }
-  const stack = detectStack(projectDir);
-  if (!stack) {
-    throw new Error("Cannot detect project stack. Ensure package.json (Node.js) or requirements.txt/pyproject.toml (Python) exists.");
-  }
-  const currentHash = computeDistHash(projectDir);
-  if (!currentHash) {
-    throw new Error("No dist/ directory found. Run your build command first (e.g., npm run build).");
-  }
-  const storedHash = getStoredDistHash(projectDir);
-  if (storedHash === currentHash) {
-    if (dockerImageExists(IMAGE_TAG)) {
-      const imageSize2 = getImageSize(IMAGE_TAG);
-      return { imageTag: IMAGE_TAG, imageSize: imageSize2, buildTimeMs: 0, cached: true };
-    }
-  }
-  const startTime = Date.now();
-  if (stack === "nodejs") {
-    buildNodeImage(projectDir);
-  } else if (stack === "python") {
-    buildPythonImage(projectDir);
-  } else {
-    throw new Error(`Unsupported stack for verify-env: ${stack}`);
-  }
-  const buildTimeMs = Date.now() - startTime;
-  storeDistHash(projectDir, currentHash);
-  const imageSize = getImageSize(IMAGE_TAG);
-  return { imageTag: IMAGE_TAG, imageSize, buildTimeMs, cached: false };
-}
-function buildNodeImage(projectDir) {
-  const packOutput = execFileSync7("npm", ["pack", "--pack-destination", "/tmp"], {
-    cwd: projectDir,
-    stdio: "pipe",
-    timeout: 6e4
-  }).toString().trim();
-  const lastLine = packOutput.split("\n").pop()?.trim();
-  if (!lastLine) {
-    throw new Error("npm pack produced no output \u2014 cannot determine tarball filename.");
-  }
-  const tarballName = basename3(lastLine);
-  const tarballPath = join21("/tmp", tarballName);
-  const buildContext = join21("/tmp", `codeharness-verify-build-${Date.now()}`);
-  mkdirSync8(buildContext, { recursive: true });
-  try {
-    cpSync(tarballPath, join21(buildContext, tarballName));
-    const dockerfileSrc = resolveDockerfileTemplate(projectDir);
-    cpSync(dockerfileSrc, join21(buildContext, "Dockerfile"));
-    execFileSync7("docker", [
-      "build",
-      "-t",
-      IMAGE_TAG,
-      "--build-arg",
-      `TARBALL=${tarballName}`,
-      "."
-    ], {
-      cwd: buildContext,
-      stdio: "pipe",
-      timeout: 12e4
-    });
-  } finally {
-    rmSync2(buildContext, { recursive: true, force: true });
-    rmSync2(tarballPath, { force: true });
-  }
-}
-function buildPythonImage(projectDir) {
-  const distDir = join21(projectDir, "dist");
-  const distFiles = readdirSync4(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()}`);
-  mkdirSync8(buildContext, { recursive: true });
-  try {
-    cpSync(join21(distDir, distFile), join21(buildContext, distFile));
-    const dockerfileSrc = resolveDockerfileTemplate(projectDir);
-    cpSync(dockerfileSrc, join21(buildContext, "Dockerfile"));
-    execFileSync7("docker", [
-      "build",
-      "-t",
-      IMAGE_TAG,
-      "--build-arg",
-      `TARBALL=${distFile}`,
-      "."
-    ], {
-      cwd: buildContext,
-      stdio: "pipe",
-      timeout: 12e4
-    });
-  } finally {
-    rmSync2(buildContext, { recursive: true, force: true });
-  }
-}
-function prepareVerifyWorkspace(storyKey, projectDir) {
-  const root = projectDir ?? process.cwd();
-  if (!isValidStoryKey(storyKey)) {
-    throw new Error(`Invalid story key: ${storyKey}. Keys must contain only alphanumeric characters, hyphens, and underscores.`);
-  }
-  const storyFile = join21(root, STORY_DIR3, `${storyKey}.md`);
-  if (!existsSync22(storyFile)) {
-    throw new Error(`Story file not found: ${storyFile}`);
-  }
-  const workspace = `${TEMP_PREFIX}${storyKey}`;
-  if (existsSync22(workspace)) {
-    rmSync2(workspace, { recursive: true, force: true });
-  }
-  mkdirSync8(workspace, { recursive: true });
-  cpSync(storyFile, join21(workspace, "story.md"));
-  const readmePath = join21(root, "README.md");
-  if (existsSync22(readmePath)) {
-    cpSync(readmePath, join21(workspace, "README.md"));
-  }
-  const docsDir = join21(root, "docs");
-  if (existsSync22(docsDir) && statSync3(docsDir).isDirectory()) {
-    cpSync(docsDir, join21(workspace, "docs"), { recursive: true });
-  }
-  mkdirSync8(join21(workspace, "verification"), { recursive: true });
-  return workspace;
-}
-function checkVerifyEnv() {
-  const result = {
-    imageExists: false,
-    cliWorks: false,
-    otelReachable: false
-  };
-  result.imageExists = dockerImageExists(IMAGE_TAG);
-  if (!result.imageExists) {
-    return result;
-  }
-  try {
-    execFileSync7("docker", ["run", "--rm", IMAGE_TAG, "codeharness", "--help"], {
-      stdio: "pipe",
-      timeout: 3e4
-    });
-    result.cliWorks = true;
-  } catch {
-    result.cliWorks = false;
-  }
-  try {
-    execFileSync7("docker", [
-      "run",
-      "--rm",
-      "--add-host=host.docker.internal:host-gateway",
-      IMAGE_TAG,
-      "curl",
-      "-sf",
-      "--max-time",
-      "5",
-      "http://host.docker.internal:4318/v1/status"
-    ], {
-      stdio: "pipe",
-      timeout: 3e4
-    });
-    result.otelReachable = true;
-  } catch {
-    result.otelReachable = false;
-  }
-  return result;
-}
-function cleanupVerifyEnv(storyKey) {
-  if (!isValidStoryKey(storyKey)) {
-    throw new Error(`Invalid story key: ${storyKey}. Keys must contain only alphanumeric characters, hyphens, and underscores.`);
-  }
-  const workspace = `${TEMP_PREFIX}${storyKey}`;
-  const containerName = `codeharness-verify-${storyKey}`;
-  if (existsSync22(workspace)) {
-    rmSync2(workspace, { recursive: true, force: true });
-  }
-  try {
-    execFileSync7("docker", ["stop", containerName], {
-      stdio: "pipe",
-      timeout: 15e3
-    });
-  } catch {
-  }
-  try {
-    execFileSync7("docker", ["rm", "-f", containerName], {
-      stdio: "pipe",
-      timeout: 15e3
-    });
-  } catch {
-  }
-}
-function resolveDockerfileTemplate(projectDir) {
-  const local = join21(projectDir, "templates", "Dockerfile.verify");
-  if (existsSync22(local)) return local;
-  const pkgDir = new URL("../../", import.meta.url).pathname;
-  const pkg = join21(pkgDir, "templates", "Dockerfile.verify");
-  if (existsSync22(pkg)) return pkg;
-  throw new Error("Dockerfile.verify not found. Ensure templates/Dockerfile.verify exists in the project or installed package.");
-}
-function dockerImageExists(tag) {
-  try {
-    execFileSync7("docker", ["image", "inspect", tag], {
-      stdio: "pipe",
-      timeout: 1e4
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getImageSize(tag) {
-  try {
-    const output = execFileSync7("docker", ["image", "inspect", tag, "--format", "{{.Size}}"], {
-      stdio: "pipe",
-      timeout: 1e4
-    }).toString().trim();
-    const bytes = parseInt(output, 10);
-    if (isNaN(bytes)) return output;
-    if (bytes >= 1e9) return `${(bytes / 1e9).toFixed(1)}GB`;
-    if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(1)}MB`;
-    if (bytes >= 1e3) return `${(bytes / 1e3).toFixed(1)}KB`;
-    return `${bytes}B`;
-  } catch {
-    return "unknown";
-  }
-}
-
 // src/commands/verify-env.ts
 function registerVerifyEnvCommand(program) {
   const verifyEnv = program.command("verify-env").description("Manage verification environment (Docker image + clean workspace)");
@@ -7601,26 +8488,26 @@ function registerVerifyEnvCommand(program) {
 }
 
 // src/commands/retry.ts
-import { join as join23 } from "path";
+import { join as join27 } from "path";
 
 // src/lib/retry-state.ts
-import { existsSync as existsSync23, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
-import { join as join22 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync25, writeFileSync as writeFileSync15 } from "fs";
+import { join as join26 } from "path";
 var RETRIES_FILE = ".story_retries";
 var FLAGGED_FILE = ".flagged_stories";
 var LINE_PATTERN = /^([^=]+)=(\d+)$/;
 function retriesPath(dir) {
-  return join22(dir, RETRIES_FILE);
+  return join26(dir, RETRIES_FILE);
 }
 function flaggedPath(dir) {
-  return join22(dir, FLAGGED_FILE);
+  return join26(dir, FLAGGED_FILE);
 }
 function readRetries(dir) {
   const filePath = retriesPath(dir);
-  if (!existsSync23(filePath)) {
+  if (!existsSync29(filePath)) {
     return /* @__PURE__ */ new Map();
   }
-  const raw = readFileSync20(filePath, "utf-8");
+  const raw = readFileSync25(filePath, "utf-8");
   const result = /* @__PURE__ */ new Map();
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -7642,7 +8529,7 @@ function writeRetries(dir, retries) {
   for (const [key, count] of retries) {
     lines.push(`${key}=${count}`);
   }
-  writeFileSync12(filePath, lines.length > 0 ? lines.join("\n") + "\n" : "", "utf-8");
+  writeFileSync15(filePath, lines.length > 0 ? lines.join("\n") + "\n" : "", "utf-8");
 }
 function resetRetry(dir, storyKey) {
   if (storyKey) {
@@ -7657,15 +8544,15 @@ function resetRetry(dir, storyKey) {
 }
 function readFlaggedStories(dir) {
   const filePath = flaggedPath(dir);
-  if (!existsSync23(filePath)) {
+  if (!existsSync29(filePath)) {
     return [];
   }
-  const raw = readFileSync20(filePath, "utf-8");
+  const raw = readFileSync25(filePath, "utf-8");
   return raw.split("\n").map((l) => l.trim()).filter((l) => l !== "");
 }
 function writeFlaggedStories(dir, stories) {
   const filePath = flaggedPath(dir);
-  writeFileSync12(filePath, stories.length > 0 ? stories.join("\n") + "\n" : "", "utf-8");
+  writeFileSync15(filePath, stories.length > 0 ? stories.join("\n") + "\n" : "", "utf-8");
 }
 function removeFlaggedStory(dir, key) {
   const stories = readFlaggedStories(dir);
@@ -7685,7 +8572,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 = join23(process.cwd(), RALPH_SUBDIR);
+    const dir = join27(process.cwd(), RALPH_SUBDIR);
     if (opts.story && !isValidStoryKey3(opts.story)) {
       if (isJson) {
         jsonOutput({ status: "fail", message: `Invalid story key: ${opts.story}` });
@@ -7758,8 +8645,101 @@ function handleStatus(dir, isJson, filterStory) {
   }
 }
 
+// src/commands/timeout-report.ts
+function registerTimeoutReportCommand(program) {
+  program.command("timeout-report").description("Capture diagnostic data from a timed-out iteration").requiredOption("--story <key>", "Story key").requiredOption("--iteration <n>", "Iteration number").requiredOption("--duration <minutes>", "Timeout duration in minutes").requiredOption("--output-file <path>", "Path to iteration output log").requiredOption("--state-snapshot <path>", "Path to pre-iteration state snapshot").action((options, cmd) => {
+    const opts = cmd.optsWithGlobals();
+    const isJson = opts.json === true;
+    const iteration = parseInt(options.iteration, 10);
+    const duration = parseInt(options.duration, 10);
+    if (isNaN(iteration) || isNaN(duration)) {
+      if (isJson) {
+        jsonOutput({ status: "fail", message: "iteration and duration must be numbers" });
+      } else {
+        fail("iteration and duration must be numbers");
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const result = captureTimeoutReport2({
+      storyKey: options.story,
+      iteration,
+      durationMinutes: duration,
+      outputFile: options.outputFile,
+      stateSnapshotPath: options.stateSnapshot
+    });
+    if (!result.success) {
+      if (isJson) {
+        jsonOutput({ status: "fail", message: result.error });
+      } else {
+        fail(result.error);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    if (isJson) {
+      jsonOutput({
+        status: "ok",
+        reportPath: result.data.filePath,
+        storyKey: result.data.capture.storyKey,
+        iteration: result.data.capture.iteration
+      });
+    } else {
+      ok(`Timeout report written: ${result.data.filePath}`);
+    }
+  });
+}
+
+// src/commands/validate-state.ts
+import { resolve as resolve2 } from "path";
+function registerValidateStateCommand(program) {
+  program.command("validate-state").description("Validate sprint-state.json consistency against sprint-status.yaml").option("--state <path>", "Path to sprint-state.json", "sprint-state.json").option("--sprint-status <path>", "Path to sprint-status.yaml", "sprint-status.yaml").action((options, cmd) => {
+    const opts = cmd.optsWithGlobals();
+    const isJson = opts.json === true;
+    const statePath2 = resolve2(process.cwd(), options.state);
+    const sprintStatusPath = resolve2(process.cwd(), options.sprintStatus);
+    const result = validateStateConsistency2(statePath2, sprintStatusPath);
+    if (!result.success) {
+      if (isJson) {
+        jsonOutput({ status: "fail", message: result.error });
+      } else {
+        fail(result.error);
+      }
+      process.exitCode = 1;
+      return;
+    }
+    const report = result.data;
+    if (isJson) {
+      jsonOutput({
+        status: report.invalidCount === 0 ? "ok" : "fail",
+        totalStories: report.totalStories,
+        validCount: report.validCount,
+        invalidCount: report.invalidCount,
+        missingKeys: report.missingKeys,
+        issues: report.issues
+      });
+    } else {
+      console.log(`Total stories: ${report.totalStories}`);
+      console.log(`Valid: ${report.validCount}`);
+      console.log(`Invalid: ${report.invalidCount}`);
+      if (report.missingKeys.length > 0) {
+        console.log(`Missing keys: ${report.missingKeys.join(", ")}`);
+      }
+      for (const issue of report.issues) {
+        console.log(`  [${issue.storyKey}] ${issue.field}: ${issue.message}`);
+      }
+      if (report.invalidCount === 0) {
+        ok("All stories valid");
+      } else {
+        fail(`${report.invalidCount} story/stories have issues`);
+      }
+    }
+    process.exitCode = report.invalidCount === 0 ? 0 : 1;
+  });
+}
+
 // src/index.ts
-var VERSION = true ? "0.19.1" : "0.0.0-dev";
+var VERSION = true ? "0.19.3" : "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");
@@ -7780,6 +8760,8 @@ function createProgram() {
   registerGithubImportCommand(program);
   registerVerifyEnvCommand(program);
   registerRetryCommand(program);
+  registerTimeoutReportCommand(program);
+  registerValidateStateCommand(program);
   return program;
 }
 if (!process.env["VITEST"]) {