@glrs-dev/cli 2.4.0 → 2.6.0

package/dist/node_modules/@glrs-dev/autopilot/dist/chunk-2X3CWH47.js

@@ -0,0 +1,3288 @@
+import {
+  resolveModel
+} from "./chunk-S34HOCZ4.js";
+import {
+  childLogger,
+  createAutopilotLogger
+} from "./chunk-2ZQ6SBV3.js";
+import {
+  detectSpecPhases,
+  filterUncheckedSpecPhases,
+  hasSpec,
+  parseSpecItems,
+  parseSpecState,
+  readSpecConstraints,
+  readSpecGoal,
+  validateMainSpec,
+  validatePhaseSpec
+} from "./chunk-GXXCEGDD.js";
+
+// src/loop-session.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+import pino from "pino";
+
+// src/loop.ts
+import { execFile as execFileCb3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join4 } from "path";
+
+// src/status.ts
+import * as fs from "fs/promises";
+import { mkdirSync, existsSync } from "fs";
+import { dirname } from "path";
+function formatElapsed(ms) {
+  const totalSeconds = Math.floor(ms / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+  if (minutes > 0) return `${minutes}m ${seconds}s`;
+  return `${seconds}s`;
+}
+function formatCost(usd, estimated) {
+  if (usd === 0) return "pending";
+  const base = `$${usd.toFixed(3)}`;
+  return estimated ? `~${base} est` : base;
+}
+function composeStatusMessage(state, now) {
+  const elapsed = formatElapsed(now - state.startedAt);
+  const cost = formatCost(state.cumulativeCostUsd, state.costIsEstimated);
+  const iterNote = state.iterationsCompleted === 0 ? "iteration 1 in flight" : `${state.iterationsCompleted} iteration${state.iterationsCompleted === 1 ? "" : "s"} complete`;
+  let planNote = "";
+  if (state.phaseCount !== void 0 && state.phasesCompleted !== void 0 && state.mainCheckboxesTotal !== void 0 && state.mainCheckboxesCompleted !== void 0) {
+    planNote = `, phase ${state.phasesCompleted}/${state.phaseCount}, ${state.mainCheckboxesCompleted}/${state.mainCheckboxesTotal} boxes`;
+  }
+  let laneNote = "";
+  if (state.lanes && Object.keys(state.lanes).length > 0) {
+    const laneIds = Object.keys(state.lanes).sort();
+    const parts = laneIds.map((id) => {
+      const l = state.lanes[id];
+      const tool = l.lastTool ? ` ${l.lastTool}` : "";
+      return `${id}: ${l.phaseFile} iter ${l.iteration}${tool}`;
+    });
+    laneNote = `, lanes: [${parts.join(", ")}]`;
+  }
+  if (state.lastIterationErrored) {
+    return `working (${iterNote}, ${elapsed} elapsed, ${cost} used${planNote}${laneNote}) \u2014 last iteration errored`;
+  }
+  return `working (${iterNote}, ${elapsed} elapsed, ${cost} used${planNote}${laneNote})`;
+}
+async function writeStatusFile(filePath, state, nowMs) {
+  const snapshot = {
+    ...state,
+    elapsedMs: nowMs - state.startedAt,
+    writtenAt: new Date(nowMs).toISOString()
+  };
+  const json = JSON.stringify(snapshot, null, 2) + "\n";
+  const tmp = `${filePath}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 10)}`;
+  const parent = dirname(filePath);
+  if (!existsSync(parent)) {
+    mkdirSync(parent, { recursive: true });
+  }
+  await fs.writeFile(tmp, json, "utf8");
+  await fs.rename(tmp, filePath);
+}
+function createStatusHeartbeat(opts) {
+  const now = opts._deps?.now ?? (() => Date.now());
+  const setIntervalFn = opts._deps?.setInterval ?? setInterval;
+  const clearIntervalFn = opts._deps?.clearInterval ?? clearInterval;
+  const state = {
+    startedAt: now(),
+    iterationsCompleted: 0,
+    cumulativeCostUsd: 0,
+    lastIterationProgress: false,
+    lastIterationErrored: false
+  };
+  let timerId = null;
+  const tick = () => {
+    if (opts.pollCost) {
+      opts.pollCost().then((cost) => {
+        if (cost > 0) state.cumulativeCostUsd = cost;
+      }).catch(() => {
+      });
+    }
+    const message = composeStatusMessage(state, now());
+    opts.logger.info(
+      {
+        elapsedMs: now() - state.startedAt,
+        iterationsCompleted: state.iterationsCompleted,
+        cumulativeCostUsd: state.cumulativeCostUsd,
+        lastIterationProgress: state.lastIterationProgress,
+        lastIterationErrored: state.lastIterationErrored
+      },
+      message
+    );
+    if (opts.statusFilePath) {
+      writeStatusFile(opts.statusFilePath, state, now()).catch(() => {
+      });
+    }
+  };
+  return {
+    start() {
+      if (timerId !== null) return;
+      timerId = setIntervalFn(tick, opts.intervalMs);
+    },
+    stop() {
+      if (timerId === null) return;
+      clearIntervalFn(timerId);
+      timerId = null;
+    },
+    update(patch) {
+      Object.assign(state, patch);
+    },
+    getState() {
+      return { ...state };
+    }
+  };
+}
+
+// src/plan-parser.ts
+import * as fs2 from "fs";
+import * as path from "path";
+var DEGRADED = {
+  type: "single",
+  totalItems: 0,
+  checkedItems: 0,
+  phaseCount: 0,
+  phasesCompleted: 0,
+  phases: []
+};
+function countCheckboxes(content) {
+  let total = 0;
+  let checked = 0;
+  const checkboxRe = /^[ \t]*-\s+\[([ xX])\]/gm;
+  let match;
+  while ((match = checkboxRe.exec(content)) !== null) {
+    total++;
+    if (match[1] !== " ") {
+      checked++;
+    }
+  }
+  return { total, checked };
+}
+function parseSingleFile(filePath) {
+  const content = fs2.readFileSync(filePath, "utf8");
+  return countCheckboxes(content);
+}
+function detectPhaseFiles(dir) {
+  const entries = fs2.readdirSync(dir);
+  return entries.filter((f) => f.endsWith(".md") && f !== "main.md" && f !== "scope.md" && f !== "scope-seed.md").sort((a, b) => {
+    const na = parseInt(a.replace(/[^0-9]/g, ""), 10);
+    const nb = parseInt(b.replace(/[^0-9]/g, ""), 10);
+    return na - nb;
+  });
+}
+function parseMultiFile(dir) {
+  const mainPath = path.join(dir, "main.md");
+  const mainContent = fs2.readFileSync(mainPath, "utf8");
+  const mainCounts = countCheckboxes(mainContent);
+  const phaseFiles = detectPhaseFiles(dir);
+  const phases = [];
+  let phasesCompleted = 0;
+  for (const phaseFile of phaseFiles) {
+    const phasePath = path.join(dir, phaseFile);
+    const { total, checked } = parseSingleFile(phasePath);
+    phases.push({ file: phaseFile, totalItems: total, checkedItems: checked });
+    if (total > 0 && checked === total) {
+      phasesCompleted++;
+    }
+  }
+  return {
+    type: "multi",
+    totalItems: mainCounts.total,
+    checkedItems: mainCounts.checked,
+    phaseCount: phaseFiles.length,
+    phasesCompleted,
+    phases
+  };
+}
+function parsePlanState(planPath) {
+  try {
+    const stat = fs2.statSync(planPath);
+    if (stat.isDirectory() && hasSpec(planPath)) {
+      return parseSpecState(planPath);
+    }
+    if (stat.isDirectory()) {
+      const mainPath = path.join(planPath, "main.md");
+      if (fs2.existsSync(mainPath)) {
+        return parseMultiFile(planPath);
+      }
+      return { ...DEGRADED, type: "multi" };
+    }
+    const { total, checked } = parseSingleFile(planPath);
+    return {
+      type: "single",
+      totalItems: total,
+      checkedItems: checked,
+      phaseCount: 0,
+      phasesCompleted: 0,
+      phases: []
+    };
+  } catch {
+    return { ...DEGRADED };
+  }
+}
+function extractPlanStateFence(content) {
+  const fenceRe = /^```plan-state\r?\n([\s\S]*?)^```/m;
+  const match = fenceRe.exec(content);
+  return match ? match[1] : null;
+}
+function parseItems(content) {
+  try {
+    const fence = extractPlanStateFence(content);
+    if (!fence) return [];
+    const items = [];
+    const itemBlocks = fence.split(/(?=^- \[[ xX]\])/m).filter((b) => b.trim());
+    for (const block of itemBlocks) {
+      const lines = block.split("\n");
+      const firstLine = lines[0];
+      const headerMatch = /^- \[([ xX])\]\s+id:\s*(.+)$/.exec(firstLine.trim());
+      if (!headerMatch) continue;
+      const checked = headerMatch[1] !== " ";
+      const id = headerMatch[2].trim();
+      let intent = "";
+      let verify = "";
+      const files = [];
+      const tests = [];
+      let i = 1;
+      while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (trimmed.startsWith("intent:")) {
+          intent = trimmed.slice("intent:".length).trim();
+          i++;
+        } else if (trimmed === "files:") {
+          i++;
+          while (i < lines.length) {
+            const fileLine = lines[i];
+            const fileMatch = /^\s{4}-\s+(.+)$/.exec(fileLine);
+            if (!fileMatch) break;
+            const rawPath = fileMatch[1].trim();
+            const isNew = rawPath.includes("(NEW)");
+            const cleanPath = rawPath.replace(/\s*\(NEW\)\s*/, "").trim();
+            i++;
+            let change = "";
+            if (i < lines.length) {
+              const changeLine = lines[i];
+              const changeMatch = /^\s{6}Change:\s*(.+)$/.exec(changeLine);
+              if (changeMatch) {
+                change = changeMatch[1].trim();
+                i++;
+              }
+            }
+            files.push({ path: cleanPath, isNew, change });
+          }
+        } else if (trimmed === "tests:") {
+          i++;
+          while (i < lines.length) {
+            const testLine = lines[i];
+            const testMatch = /^\s{4}-\s+(.+)$/.exec(testLine);
+            if (!testMatch) break;
+            tests.push(testMatch[1].trim());
+            i++;
+          }
+        } else if (trimmed.startsWith("verify:")) {
+          verify = trimmed.slice("verify:".length).trim();
+          i++;
+        } else {
+          i++;
+        }
+      }
+      items.push({ id, intent, files, tests, verify, checked });
+    }
+    return items;
+  } catch {
+    return [];
+  }
+}
+
+// src/scope-validator.ts
+import { execFile as execFileCb } from "child_process";
+import { promisify } from "util";
+var execFileDefault = promisify(execFileCb);
+function validateScope(expected, actual) {
+  const expectedSet = new Set(expected.filter((p) => p && p.trim()));
+  const actualSet = new Set(actual.filter((p) => p && p.trim()));
+  const extra = [];
+  for (const f of actualSet) {
+    if (!expectedSet.has(f)) extra.push(f);
+  }
+  const missing = [];
+  for (const f of expectedSet) {
+    if (!actualSet.has(f)) missing.push(f);
+  }
+  extra.sort();
+  missing.sort();
+  return { extra, missing };
+}
+async function getChangedFiles(cwd, baseRef, opts = {}) {
+  const execFile4 = opts._deps?.execFile ?? execFileDefault;
+  try {
+    const { stdout } = await execFile4(
+      "git",
+      ["diff", "--name-only", baseRef],
+      { cwd }
+    );
+    const text = typeof stdout === "string" ? stdout : String(stdout ?? "");
+    return text.trim().split("\n").map((s) => s.trim()).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+// src/config.ts
+var MAX_ITERATIONS = 50;
+var STRUGGLE_THRESHOLD = 3;
+var TIMEOUT_MS = 4 * 60 * 60 * 1e3;
+var STALL_MS_BY_TIER = {
+  deep: 30 * 60 * 1e3,
+  mid: 15 * 60 * 1e3,
+  "mid-execute": 10 * 60 * 1e3,
+  "autopilot-execute": 10 * 60 * 1e3,
+  fast: 5 * 60 * 1e3
+};
+var STALL_MS = STALL_MS_BY_TIER.deep;
+var MAX_ITERATIONS_PER_PHASE_BY_TIER = {
+  deep: 5,
+  mid: 8,
+  "mid-execute": 10,
+  "autopilot-execute": 10,
+  fast: 10
+};
+var MAX_ITERATIONS_PER_ITEM = 5;
+var KILL_SWITCH_PATH = ".agent/autopilot-disable";
+var SENTINEL_TAG = "<autopilot-done>";
+var STATUS_INTERVAL_MS = (() => {
+  const env = process.env["GLRS_AUTOPILOT_STATUS_INTERVAL_MS"];
+  if (!env) return 5 * 60 * 1e3;
+  const n = Number.parseInt(env, 10);
+  if (Number.isNaN(n) || n < 1e3 || n > 60 * 60 * 1e3) return 5 * 60 * 1e3;
+  return n;
+})();
+
+// src/sentinel.ts
+function detectSentinel(text) {
+  if (!text.includes(SENTINEL_TAG)) {
+    return false;
+  }
+  const withoutFences = text.replace(/```[\s\S]*?```/g, "");
+  const withoutInline = withoutFences.replace(/`[^`\n]*`/g, "");
+  return withoutInline.includes(SENTINEL_TAG);
+}
+
+// src/struggle.ts
+import * as fs3 from "fs";
+import * as path2 from "path";
+var StruggleDetector = class {
+  _consecutiveStalls = 0;
+  _threshold;
+  constructor(threshold) {
+    this._threshold = threshold;
+  }
+  /** Number of consecutive stall iterations recorded so far. */
+  get consecutiveStalls() {
+    return this._consecutiveStalls;
+  }
+  /**
+   * Record the result of one iteration.
+   * @param madeProgress - true if the agent made filesystem changes this iteration.
+   */
+  record(madeProgress) {
+    if (madeProgress) {
+      this._consecutiveStalls = 0;
+    } else {
+      this._consecutiveStalls++;
+    }
+  }
+  /**
+   * Returns true if the agent has stalled for `threshold` consecutive
+   * iterations without making progress.
+   */
+  isStruggling() {
+    return this._consecutiveStalls >= this._threshold;
+  }
+};
+function checkKillSwitch(cwd) {
+  const killSwitchFile = path2.join(cwd, KILL_SWITCH_PATH);
+  return fs3.existsSync(killSwitchFile);
+}
+
+// src/lib/slack-formatter.ts
+var EVENT_LABELS = {
+  iteration_complete: "\u2705 Iteration Complete",
+  phase_complete: "\u{1F3C1} Phase Complete",
+  run_complete: "\u{1F389} Run Complete",
+  error: "\u274C Error",
+  struggle: "\u26A0\uFE0F Struggle Detected",
+  stall: "\u23F8\uFE0F Stall Detected"
+};
+function formatSlackMessage(event) {
+  const label = EVENT_LABELS[event.event] ?? event.event;
+  const fields = [
+    { type: "mrkdwn", text: `*Iteration:* ${event.iteration}` }
+  ];
+  if (event.costUsd !== void 0 && event.costUsd > 0) {
+    fields.push({ type: "mrkdwn", text: `*Cost so far:* $${event.costUsd.toFixed(3)}` });
+  }
+  if (event.filesChanged !== void 0 && event.filesChanged > 0) {
+    fields.push({ type: "mrkdwn", text: `*Files changed:* ${event.filesChanged}` });
+  }
+  if (event.phaseFile) {
+    fields.push({ type: "mrkdwn", text: `*Phase:* ${event.phaseFile}` });
+  }
+  if (event.commitSubject) {
+    fields.push({ type: "mrkdwn", text: `*Last commit:* ${event.commitSubject}` });
+  }
+  if (event.errorMessage) {
+    fields.push({ type: "mrkdwn", text: `*Error:* ${event.errorMessage}` });
+  }
+  const blocks = [
+    {
+      type: "header",
+      text: { type: "plain_text", text: label, emoji: true }
+    }
+  ];
+  if (fields.length > 0) {
+    blocks.push({
+      type: "section",
+      fields
+    });
+  }
+  blocks.push({
+    type: "context",
+    elements: [
+      {
+        type: "mrkdwn",
+        text: `${event.message} \xB7 ${event.timestamp}`
+      }
+    ]
+  });
+  return { blocks };
+}
+
+// src/lib/webhook-notifier.ts
+function isSlackWebhookUrl(url) {
+  return url.includes("hooks.slack.com/");
+}
+async function notifyWebhook(url, event, allowedEvents) {
+  if (allowedEvents && !allowedEvents.includes(event.event)) {
+    return;
+  }
+  try {
+    const body = isSlackWebhookUrl(url) ? JSON.stringify(formatSlackMessage(event)) : JSON.stringify(event);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body
+    });
+    if (!response.ok) {
+      console.warn(
+        `\u26A0 Webhook POST to ${url} returned ${response.status} ${response.statusText}`
+      );
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(`\u26A0 Webhook notification failed (non-fatal): ${msg}`);
+  }
+}
+
+// src/lib/model-pricing.ts
+var MODEL_PRICING = {
+  // Claude 3 Opus
+  "claude-3-opus": { input: 15, output: 75 },
+  "claude-opus": { input: 15, output: 75 },
+  // Claude 3.5 Sonnet (more specific than "sonnet" — check first)
+  "claude-3-5-sonnet": { input: 3, output: 15 },
+  "claude-3.5-sonnet": { input: 3, output: 15 },
+  // Claude 3.7 Sonnet
+  "claude-3-7-sonnet": { input: 3, output: 15 },
+  "claude-3.7-sonnet": { input: 3, output: 15 },
+  // Claude 3 Sonnet (generic)
+  "claude-3-sonnet": { input: 3, output: 15 },
+  "claude-sonnet": { input: 3, output: 15 },
+  // Claude 3.5 Haiku (more specific than "haiku" — check first)
+  "claude-3-5-haiku": { input: 0.8, output: 4 },
+  "claude-3.5-haiku": { input: 0.8, output: 4 },
+  // Claude 3 Haiku (generic)
+  "claude-3-haiku": { input: 0.25, output: 1.25 },
+  "claude-haiku": { input: 0.25, output: 1.25 },
+  // Amazon Nova models (approximate)
+  "amazon.nova-pro": { input: 0.8, output: 3.2 },
+  "amazon.nova-lite": { input: 0.06, output: 0.24 },
+  "amazon.nova-micro": { input: 0.035, output: 0.14 }
+  // GLM-5 and Kimi: TBD — return 0 via unknown-model fallback
+};
+function estimateCost(modelId, tokens) {
+  const pricing = findPricing(modelId);
+  if (!pricing) return 0;
+  return (tokens.input * pricing.input + tokens.output * pricing.output) / 1e6;
+}
+function findPricing(modelId) {
+  const lower = modelId.toLowerCase();
+  for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
+    if (lower.includes(key.toLowerCase())) {
+      return pricing;
+    }
+  }
+  return void 0;
+}
+
+// src/lib/error-classifier.ts
+var TRANSIENT_PATTERNS = [
+  // Network
+  "etimedout",
+  "econnreset",
+  "eai_again",
+  "socket hang up",
+  "network",
+  "fetch failed",
+  // Rate limits
+  "429",
+  "too many requests",
+  "rate limit",
+  "throttling",
+  "throttled",
+  // Server-side
+  "500",
+  "502",
+  "503",
+  "504",
+  "internal server error",
+  "service unavailable",
+  "bad gateway",
+  "gateway timeout"
+];
+var CREDENTIAL_EXPIRED_PATTERNS = [
+  /expiredtoken/i,
+  /invalididentitytoken/i,
+  /tokenrefreshrequired/i,
+  /expired.*token/i,
+  /token.*expired/i,
+  /credentials?.*expired/i,
+  /expired.*credentials?/i,
+  /sso.*expired/i,
+  /session.*expired/i
+];
+function classifyError(message) {
+  if (typeof message !== "string" || message.length === 0) {
+    return "permanent";
+  }
+  const lower = message.toLowerCase();
+  for (const re of CREDENTIAL_EXPIRED_PATTERNS) {
+    if (re.test(message)) {
+      return "credential-expired";
+    }
+  }
+  for (const pattern of TRANSIENT_PATTERNS) {
+    if (lower.includes(pattern)) {
+      return "transient";
+    }
+  }
+  return "permanent";
+}
+
+// src/lib/credential-refresh.ts
+import { execFile as execFileCb2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFile = promisify2(execFileCb2);
+function detectProvider(modelName) {
+  if (typeof modelName !== "string" || modelName.length === 0) {
+    return "unknown";
+  }
+  const lower = modelName.toLowerCase();
+  if (lower.startsWith("bedrock/") || lower.startsWith("amazon-bedrock/") || lower.startsWith("aws/")) {
+    return "aws";
+  }
+  if (lower.startsWith("azure/") || lower.includes(".azure.")) {
+    return "azure";
+  }
+  return "unknown";
+}
+
+// src/checkpoint.ts
+import * as fs4 from "fs";
+import * as path3 from "path";
+var CHECKPOINT_REL_PATH = path3.join(".agent", "autopilot-checkpoint.json");
+function checkpointPath(cwd) {
+  return path3.join(cwd, CHECKPOINT_REL_PATH);
+}
+function writeCheckpoint(cwd, state, deps) {
+  const _writeFileSync = deps?.writeFileSync ?? ((p, content) => fs4.writeFileSync(p, content, "utf8"));
+  const _renameSync = deps?.renameSync ?? fs4.renameSync;
+  const _mkdirSync = deps?.mkdirSync ?? ((p, opts) => fs4.mkdirSync(p, opts));
+  const target = checkpointPath(cwd);
+  const dir = path3.dirname(target);
+  try {
+    _mkdirSync(dir, { recursive: true });
+  } catch {
+    return;
+  }
+  const tmp = `${target}.tmp.${process.pid}.${Math.random().toString(36).slice(2, 10)}`;
+  try {
+    _writeFileSync(tmp, JSON.stringify(state, null, 2) + "\n");
+    _renameSync(tmp, target);
+  } catch {
+    try {
+      fs4.unlinkSync(tmp);
+    } catch {
+    }
+  }
+}
+function readCheckpoint(cwd, deps) {
+  const _readFileSync = deps?.readFileSync ?? ((p) => fs4.readFileSync(p, "utf8"));
+  const target = checkpointPath(cwd);
+  let raw;
+  try {
+    raw = _readFileSync(target);
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const obj = parsed;
+  if (typeof obj["planPath"] !== "string") return null;
+  if (!Array.isArray(obj["completedPhases"])) return null;
+  if (!obj["completedPhases"].every((p) => typeof p === "string")) return null;
+  if (typeof obj["totalCostUsd"] !== "number") return null;
+  if (typeof obj["totalIterations"] !== "number") return null;
+  if (typeof obj["timestamp"] !== "string") return null;
+  return {
+    planPath: obj["planPath"],
+    completedPhases: obj["completedPhases"],
+    totalCostUsd: obj["totalCostUsd"],
+    totalIterations: obj["totalIterations"],
+    timestamp: obj["timestamp"]
+  };
+}
+function deleteCheckpoint(cwd, deps) {
+  const _unlinkSync = deps?.unlinkSync ?? fs4.unlinkSync;
+  const _existsSync = deps?.existsSync ?? fs4.existsSync;
+  const target = checkpointPath(cwd);
+  try {
+    if (_existsSync(target)) {
+      _unlinkSync(target);
+    }
+  } catch {
+  }
+}
+
+// src/loop.ts
+var TRANSIENT_RETRY_MAX_ATTEMPTS = 3;
+var TRANSIENT_RETRY_BASE_MS = 1e3;
+var TRANSIENT_RETRY_MAX_MS = 3e4;
+var execFile2 = promisify3(execFileCb3);
+function buildFullPrompt(userPrompt) {
+  const candidates = [
+    join4(import.meta.dir, "prompt-template.md"),
+    join4(import.meta.dir, "..", "..", "src", "autopilot", "prompt-template.md")
+  ];
+  let template = "";
+  for (const candidate of candidates) {
+    try {
+      const raw = readFileSync3(candidate, "utf8");
+      template = raw.replace(/^---\n[\s\S]*?\n---\n/, "");
+      break;
+    } catch {
+    }
+  }
+  const withArgs = template.replace("$ARGUMENTS", userPrompt);
+  return withArgs || userPrompt;
+}
+async function checkProgress(cwd, baseRef) {
+  try {
+    const { stdout } = await execFile2("git", ["diff", "--stat", baseRef], { cwd });
+    return stdout.trim().length > 0;
+  } catch {
+    return true;
+  }
+}
+async function captureWorkingTreeSnapshot(cwd) {
+  try {
+    const { stdout } = await execFile2("git", ["status", "--porcelain"], { cwd });
+    return stdout.trim();
+  } catch {
+    return "";
+  }
+}
+async function getHeadSha(cwd) {
+  try {
+    const { stdout } = await execFile2("git", ["rev-parse", "HEAD"], { cwd });
+    return stdout.trim();
+  } catch {
+    return "HEAD";
+  }
+}
+async function amendCommitWithPrefix(cwd, prefix) {
+  try {
+    const { stdout: subject } = await execFile2("git", ["log", "-1", "--pretty=%s"], { cwd });
+    const currentSubject = subject.trim();
+    if (!currentSubject || currentSubject.startsWith(prefix)) {
+      return false;
+    }
+    const newSubject = `${prefix} ${currentSubject}`;
+    await execFile2("git", ["commit", "--amend", "-m", newSubject], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runRalphLoop(opts) {
+  process.env["GLRS_AUTOPILOT_HEADLESS"] = "1";
+  const maxIterations = opts.maxIterations ?? MAX_ITERATIONS;
+  const timeoutMs = opts.timeoutMs ?? TIMEOUT_MS;
+  const tier = opts.agentName === "autopilot-fast" ? "autopilot-execute" : "deep";
+  const cfgObj = opts.config;
+  const cfgStallMs = cfgObj?.stall_timeout;
+  const stallMs = opts.stallMs ?? cfgStallMs ?? STALL_MS_BY_TIER[tier];
+  const struggleThreshold = opts.struggleThreshold ?? STRUGGLE_THRESHOLD;
+  const autoCommit = cfgObj?.auto_commit ?? true;
+  const commitPrefix = cfgObj?.commit_prefix;
+  const cfgNotifyUrl = cfgObj?.notify_url;
+  const cfgNotifyEvents = cfgObj?.notify_events;
+  const resolvedNotifyUrl = opts.notifyUrl ?? cfgNotifyUrl;
+  const resolvedNotifyEvents = cfgNotifyEvents;
+  const finalNotifyEvents = opts.notifyEvents ?? resolvedNotifyEvents;
+  if (!opts.adapter) {
+    throw new Error("runRalphLoop: adapter is required");
+  }
+  const adapter = opts.adapter;
+  const fullPrompt = buildFullPrompt(opts.prompt);
+  const struggle = new StruggleDetector(struggleThreshold);
+  const startTime = Date.now();
+  const notify = (event) => {
+    if (resolvedNotifyUrl) {
+      notifyWebhook(resolvedNotifyUrl, event, finalNotifyEvents).catch(() => {
+      });
+    }
+  };
+  const autopilotLog = opts.logger ?? createAutopilotLogger({ cwd: opts.cwd });
+  const laneSuffix = opts.laneId ? `.lane.${opts.laneId}` : "";
+  const log = childLogger(autopilotLog.root, `autopilot.loop${laneSuffix}`);
+  const toolLog = childLogger(autopilotLog.root, `autopilot.tool${laneSuffix}`);
+  const streamLog = childLogger(autopilotLog.root, `autopilot.stream${laneSuffix}`);
+  const statusLog = childLogger(autopilotLog.root, `autopilot.status${laneSuffix}`);
+  const lanePrefix = opts.laneId ? `[${opts.laneId}] ` : "";
+  const emitter = opts.emitter;
+  let thinkingChars = 0;
+  let thinkingStartTime = 0;
+  let thinkingToolCalls = 0;
+  let modelName = "unknown";
+  try {
+    const configHome = process.env["XDG_CONFIG_HOME"] ?? join4(process.env["HOME"] ?? "", ".config");
+    const configPath = join4(configHome, "opencode", "opencode.json");
+    const raw = readFileSync3(configPath, "utf8");
+    const config = JSON.parse(raw);
+    const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+    for (const entry of plugins) {
+      if (Array.isArray(entry) && entry.length >= 2) {
+        const opts2 = entry[1];
+        const models = opts2?.models;
+        if (models) {
+          const modelArr = models[tier] ?? (tier === "autopilot-execute" ? models["mid-execute"] ?? models["mid"] : models["deep"]);
+          if (Array.isArray(modelArr) && modelArr[0]) {
+            modelName = modelArr[0];
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  const agentLabel = opts.agentName === "autopilot-fast" ? "fast executor" : "deep";
+  log.info(`${lanePrefix}Autopilot loop \u2014 ${agentLabel} (${modelName})`);
+  log.info(`${lanePrefix}Prompt: ${opts.prompt.length > 80 ? opts.prompt.slice(0, 80) + "\u2026" : opts.prompt}`);
+  log.info(`${lanePrefix}Max iterations: ${maxIterations}, timeout: ${(timeoutMs / 36e5).toFixed(1)}h`);
+  let heartbeat = null;
+  if (autopilotLog.logFilePath) {
+    log.info({ file: autopilotLog.logFilePath }, `Logging to ${autopilotLog.logFilePath}`);
+  }
+  log.info({ cwd: opts.cwd, maxIterations, timeoutMs }, `Starting agent (${adapter.name})`);
+  const handle = await adapter.start({ cwd: opts.cwd, agents: opts.agentOverrides });
+  log.info({ agentId: handle.id }, "Agent ready");
+  const abort = new AbortController();
+  const timeoutHandle = setTimeout(() => {
+    abort.abort();
+  }, timeoutMs);
+  let signalCount = 0;
+  let interruptedSignal;
+  const onSignal = (signal) => {
+    signalCount++;
+    if (signalCount === 1) {
+      interruptedSignal = signal;
+      log.warn({ signal }, `Signal ${signal} received \u2014 graceful shutdown (commit WIP + write checkpoint)`);
+      abort.abort();
+    } else {
+      log.error({ signal, signalCount }, "Second signal \u2014 force exit");
+      process.exit(130);
+    }
+  };
+  const sigintHandler = () => onSignal("SIGINT");
+  const sigtermHandler = () => onSignal("SIGTERM");
+  process.on("SIGINT", sigintHandler);
+  process.on("SIGTERM", sigtermHandler);
+  let sessionId;
+  let handleTransferred = false;
+  const transferHandle = () => {
+    if (opts.keepAlive) {
+      handleTransferred = true;
+      return { adapter, handle };
+    }
+    return void 0;
+  };
+  try {
+    const agentName = opts.agentName ?? "autopilot-prime";
+    const tierLabel = agentName === "autopilot-fast" ? "autopilot-execute tier" : "deep tier";
+    sessionId = await adapter.createSession(handle, { agentName, model: opts.model });
+    log.info({ sessionId, agentName, tier: tierLabel }, `Session created with ${agentName} (${tierLabel})`);
+    const statusFileEnabled = opts.config?.status_file !== false;
+    heartbeat = createStatusHeartbeat({
+      logger: statusLog,
+      intervalMs: STATUS_INTERVAL_MS,
+      pollCost: async () => adapter.getSessionCost(handle, sessionId),
+      statusFilePath: statusFileEnabled ? join4(opts.cwd, ".agent", "autopilot-status.json") : void 0
+    });
+    heartbeat.start();
+    for (let iteration = 1; iteration <= maxIterations; iteration++) {
+      if (checkKillSwitch(opts.cwd)) {
+        log.warn({ iteration: iteration - 1 }, "Kill switch active \u2014 stopping");
+        notify({
+          event: "run_complete",
+          iteration: iteration - 1,
+          costUsd: heartbeat?.getState().cumulativeCostUsd,
+          message: `Kill switch active (.agent/autopilot-disable exists). Stopping after ${iteration - 1} iteration(s).`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          exitReason: "kill-switch",
+          iterations: iteration - 1,
+          message: `Kill switch active (.agent/autopilot-disable exists). Stopping after ${iteration - 1} iteration(s).`,
+          sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
+          agentHandle: transferHandle()
+        };
+      }
+      if (Date.now() - startTime >= timeoutMs) {
+        log.warn({ iteration: iteration - 1, timeoutMs }, "Total timeout exceeded");
+        notify({
+          event: "run_complete",
+          iteration: iteration - 1,
+          costUsd: heartbeat?.getState().cumulativeCostUsd,
+          message: `Total timeout (${timeoutMs}ms) exceeded after ${iteration - 1} iteration(s).`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          exitReason: "timeout",
+          iterations: iteration - 1,
+          message: `Total timeout (${timeoutMs}ms) exceeded after ${iteration - 1} iteration(s).`,
+          sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
+          agentHandle: transferHandle()
+        };
+      }
+      const headBefore = await getHeadSha(opts.cwd);
+      const snapshotBefore = await captureWorkingTreeSnapshot(opts.cwd);
+      const iterationBaseCost = heartbeat.getState().cumulativeCostUsd;
+      const iterStart = Date.now();
+      log.debug({ iteration, maxIterations }, `Iteration ${iteration}/${maxIterations} \u2014 sending prompt`);
+      log.info(`${lanePrefix}Iteration ${iteration}/${maxIterations}`);
+      emitter?.emitEvent({
+        type: "iteration:start",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        iteration,
+        maxIterations,
+        ...opts.laneId ? { laneId: opts.laneId } : {}
+      });
+      thinkingChars = 0;
+      thinkingStartTime = 0;
+      thinkingToolCalls = 0;
+      let streamDeltaCount = 0;
+      let streamCharCount = 0;
+      let lastStreamLogAt = 0;
+      let lastToolOrStreamLogAt = Date.now();
+      let lastThinkingEventAt = 0;
+      const THINKING_EVENT_INTERVAL_MS = 5e3;
+      const DEBUG_STREAM_INTERVAL_MS = 15e3;
+      const INFO_STREAM_INTERVAL_MS = 6e4;
+      const sendOnce = () => adapter.sendAndWait(handle, {
+        sessionId,
+        message: fullPrompt,
+        stallMs,
+        abortSignal: abort.signal,
+        onToolCall: (toolName, firstArg) => {
+          log.info(`${lanePrefix}tool: ${toolName}${firstArg ? " " + firstArg : ""}`);
+          thinkingToolCalls++;
+          thinkingChars = 0;
+          thinkingStartTime = 0;
+          lastToolOrStreamLogAt = Date.now();
+          lastThinkingEventAt = 0;
+          streamDeltaCount = 0;
+          streamCharCount = 0;
+          lastStreamLogAt = Date.now();
+          emitter?.emitEvent({
+            type: "tool:call",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            toolName,
+            ...firstArg ? { firstArg } : {},
+            iteration,
+            ...opts.laneId ? { laneId: opts.laneId } : {}
+          });
+        },
+        onCostUpdate: (cost, tokens) => {
+          const effectiveCost = cost > 0 ? cost : tokens.input > 0 || tokens.output > 0 ? estimateCost(modelName, tokens) : 0;
+          const isEstimated = cost === 0 && effectiveCost > 0;
+          heartbeat.update({
+            cumulativeCostUsd: iterationBaseCost + effectiveCost,
+            ...isEstimated ? { costIsEstimated: true } : {}
+          });
+          emitter?.emitEvent({
+            type: "cost:update",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            cumulativeCostUsd: iterationBaseCost + effectiveCost,
+            isEstimated,
+            iteration,
+            tokensIn: tokens.input,
+            tokensOut: tokens.output
+          });
+        },
+        onTextDelta: (charCount) => {
+          streamDeltaCount += 1;
+          streamCharCount += charCount;
+          thinkingChars += charCount;
+          const now = Date.now();
+          if (thinkingStartTime === 0) thinkingStartTime = now;
+          if (now - lastThinkingEventAt >= THINKING_EVENT_INTERVAL_MS) {
+            const elapsedSec = Math.round((now - thinkingStartTime) / 1e3);
+            emitter?.emitEvent({
+              type: "thinking",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              iteration,
+              chars: thinkingChars,
+              elapsedSec,
+              ...opts.laneId ? { laneId: opts.laneId } : {}
+            });
+            lastThinkingEventAt = now;
+          }
+          if (now - lastStreamLogAt >= DEBUG_STREAM_INTERVAL_MS) {
+            streamLog.debug(
+              { iteration, deltas: streamDeltaCount, chars: streamCharCount },
+              `streaming (${streamDeltaCount} deltas, ${streamCharCount} chars)`
+            );
+            lastStreamLogAt = now;
+          }
+          const silenceSinceLastTool = now - lastToolOrStreamLogAt;
+          if (silenceSinceLastTool >= INFO_STREAM_INTERVAL_MS) {
+            const elapsedS = Math.round((now - thinkingStartTime) / 1e3);
+            const fmtElapsed = elapsedS < 60 ? `${elapsedS}s` : `${Math.floor(elapsedS / 60)}m ${elapsedS % 60}s`;
+            log.info({ thinking: fmtElapsed }, `thinking (${fmtElapsed})`);
+            streamLog.info(
+              {
+                iteration,
+                deltas: streamDeltaCount,
+                chars: streamCharCount,
+                silenceMs: silenceSinceLastTool
+              },
+              `still streaming (${streamDeltaCount} deltas, ${streamCharCount} chars, ${Math.round(silenceSinceLastTool / 1e3)}s since last tool)`
+            );
+            lastToolOrStreamLogAt = now;
+          }
+        }
+      });
+      let result = await sendOnce();
+      if (result.kind === "error") {
+        const initialClass = classifyError(result.message);
+        if (initialClass === "transient") {
+          for (let attempt = 1; attempt < TRANSIENT_RETRY_MAX_ATTEMPTS; attempt++) {
+            const delay = Math.min(
+              TRANSIENT_RETRY_BASE_MS * Math.pow(2, attempt - 1),
+              TRANSIENT_RETRY_MAX_MS
+            );
+            log.warn(
+              { iteration, attempt, delayMs: delay, err: result.message },
+              `Transient error \u2014 retrying in ${Math.round(delay / 1e3)}s (attempt ${attempt + 1}/${TRANSIENT_RETRY_MAX_ATTEMPTS})`
+            );
+            const aborted = await new Promise((resolve) => {
+              if (abort.signal.aborted) {
+                resolve(true);
+                return;
+              }
+              const handle2 = setTimeout(() => {
+                abort.signal.removeEventListener("abort", onAbort);
+                resolve(false);
+              }, delay);
+              const onAbort = () => {
+                clearTimeout(handle2);
+                resolve(true);
+              };
+              abort.signal.addEventListener("abort", onAbort, { once: true });
+            });
+            if (aborted) break;
+            result = await sendOnce();
+            if (result.kind !== "error") break;
+            const cls = classifyError(result.message);
+            if (cls !== "transient") break;
+          }
+        }
+      }
+      const iterDurationMs = Date.now() - iterStart;
+      if (result.kind === "abort") {
+        log.warn({ iteration, iterDurationMs }, "Iteration aborted (total timeout)");
+        notify({
+          event: "run_complete",
+          iteration,
+          costUsd: heartbeat?.getState().cumulativeCostUsd,
+          message: `Aborted after ${iteration} iteration(s) (total timeout exceeded).`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          exitReason: "timeout",
+          iterations: iteration,
+          message: `Aborted after ${iteration} iteration(s) (total timeout exceeded).`,
+          sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
+          agentHandle: transferHandle()
+        };
+      }
+      if (result.kind === "stall") {
+        log.warn({ iteration, stallMs: result.stallMs }, "Iteration stalled");
+        notify({
+          event: "stall",
+          iteration,
+          costUsd: heartbeat?.getState().cumulativeCostUsd,
+          message: `Iteration ${iteration} stalled for ${result.stallMs}ms with no idle signal.`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          exitReason: "stall",
+          iterations: iteration,
+          message: `Iteration ${iteration} stalled for ${result.stallMs}ms with no idle signal.`,
+          sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
+          agentHandle: transferHandle()
+        };
+      }
+      if (result.kind === "error") {
+        const errorClass = classifyError(result.message);
+        if (errorClass === "credential-expired") {
+          const provider = detectProvider(modelName);
+          log.error(
+            { iteration, provider, err: result.message },
+            "Credentials expired \u2014 autopilot cannot continue"
+          );
+          emitter?.emitEvent({
+            type: "credential:expired",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            provider,
+            message: `Credentials expired (${provider}). Run \`gs-assume\` and then \`glrs oc autopilot --resume\`.`,
+            iteration
+          });
+          try {
+            writeCheckpoint(opts.cwd, {
+              planPath: opts.cwd,
+              completedPhases: [],
+              totalCostUsd: heartbeat?.getState().cumulativeCostUsd ?? 0,
+              totalIterations: iteration - 1,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          } catch {
+          }
+          notify({
+            event: "error",
+            iteration,
+            costUsd: heartbeat?.getState().cumulativeCostUsd,
+            errorMessage: result.message,
+            message: `Credentials expired (${provider}). Run \`gs-assume\` and then \`glrs oc autopilot --resume\`.`,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          log.error(
+            "Credentials expired. Run `gs-assume` and then `glrs oc autopilot --resume`."
+          );
+          process.exit(2);
+        }
+        log.error({ iteration, err: result.message }, "Iteration errored");
+        emitter?.emitEvent({
+          type: "error",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          message: result.message ?? "unknown error",
+          iteration
+        });
+        heartbeat.update({
+          iterationsCompleted: iteration,
+          lastIterationErrored: true
+        });
+        notify({
+          event: "error",
+          iteration,
+          costUsd: heartbeat?.getState().cumulativeCostUsd,
+          errorMessage: result.message,
+          message: `Error in iteration ${iteration}: ${result.message}`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          exitReason: "error",
+          iterations: iteration,
+          message: `Error in iteration ${iteration}: ${result.message}`,
+          sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
+          agentHandle: transferHandle()
+        };
+      }
+      if (result.kind === "question_rejected") {
+        log.warn(
+          { iteration, questionTitle: result.title },
+          `Question rejected \u2014 skipping to next iteration (iteration ${iteration})`
+        );
+        log.warn(`question rejected \u2014 skipping to next iteration`);
+      }
+      const lastMessage = await adapter.getLastResponse(handle, sessionId);
+      if (detectSentinel(lastMessage)) {
+        log.info({ iteration, iterDurationMs }, "Sentinel detected \u2014 autopilot done");
+        notify({
+          event: "run_complete",
+          iteration,
+          costUsd: heartbeat?.getState().cumulativeCostUsd,
+          message: `Agent emitted <autopilot-done> at iteration ${iteration}.`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          exitReason: "sentinel",
+          iterations: iteration,
+          message: `Agent emitted <autopilot-done> at iteration ${iteration}.`,
+          sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
+          agentHandle: transferHandle()
+        };
+      }
+      const madeProgress = await checkProgress(opts.cwd, headBefore);
+      struggle.record(madeProgress);
+      try {
+        const phaseMatch = opts.prompt.match(
+          /## Your phase \([^)]+\)\n([\s\S]*?)(?=\n##\s|$)/
+        );
+        if (phaseMatch) {
+          const phaseItems = parseItems(phaseMatch[1]);
+          const expectedFiles = /* @__PURE__ */ new Set();
+          for (const it of phaseItems) {
+            if (it.checked) continue;
+            for (const f of it.files) {
+              if (f.path) expectedFiles.add(f.path);
+            }
+          }
+          if (expectedFiles.size > 0) {
+            const changedFiles = await getChangedFiles(opts.cwd, headBefore);
+            const { extra, missing } = validateScope(
+              [...expectedFiles],
+              changedFiles
+            );
+            for (const f of extra) {
+              log.warn(
+                { scopeDrift: f, iteration },
+                `Scope drift: agent edited ${f} which is not in the plan.`
+              );
+            }
+            for (const f of missing) {
+              log.warn(
+                { incomplete: f, iteration },
+                `Incomplete: plan expects changes to ${f} but none were made.`
+              );
+            }
+          }
+        }
+      } catch (err) {
+        log.debug({ err }, "scope validation skipped");
+      }
+      let cumulativeCostUsd = 0;
+      let iterTokensIn = 0;
+      let iterTokensOut = 0;
+      if (adapter.getSessionStats) {
+        const stats = await adapter.getSessionStats(handle, sessionId);
+        cumulativeCostUsd = stats.cost;
+        iterTokensIn = stats.tokensIn;
+        iterTokensOut = stats.tokensOut;
+      } else {
+        cumulativeCostUsd = await adapter.getSessionCost(handle, sessionId);
+      }
+      if (cumulativeCostUsd > 0 || iterTokensIn > 0 || iterTokensOut > 0) {
+        emitter?.emitEvent({
+          type: "cost:update",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          cumulativeCostUsd,
+          isEstimated: false,
+          iteration,
+          tokensIn: iterTokensIn,
+          tokensOut: iterTokensOut
+        });
+      }
+      let filesChanged = 0;
+      let commitSubject = "";
+      try {
+        const { stdout: diffStat } = await execFile2("git", ["diff", "--stat", "HEAD~1", "HEAD"], { cwd: opts.cwd });
+        const match = diffStat.match(/(\d+) files? changed/);
+        if (match) filesChanged = parseInt(match[1], 10);
+      } catch {
+      }
+      const headAfter = await getHeadSha(opts.cwd);
+      if (headAfter !== headBefore) {
+        try {
+          const { stdout: logOut } = await execFile2("git", ["log", "--oneline", "-1"], { cwd: opts.cwd });
+          commitSubject = logOut.trim().replace(/^[0-9a-f]+ /, "");
+        } catch {
+        }
+        if (commitSubject && commitPrefix) {
+          amendCommitWithPrefix(opts.cwd, commitPrefix).catch(() => {
+          });
+        }
+        if (commitSubject) {
+          log.info(`${lanePrefix}commit: ${commitSubject}`);
+        }
+      }
+      const costDelta = cumulativeCostUsd - iterationBaseCost;
+      const durationMin = iterDurationMs / 6e4;
+      const fmtDur = iterDurationMs < 6e4 ? `${Math.round(iterDurationMs / 1e3)}s` : `${Math.floor(durationMin)}m ${Math.round(iterDurationMs / 1e3 % 60)}s`;
+      const reqPerMin = durationMin > 0 ? Math.round(thinkingToolCalls / durationMin) : 0;
+      log.info(
+        {
+          elapsed: fmtDur,
+          ...costDelta > 0 ? { cost: `$${costDelta.toFixed(2)}` } : {},
+          ...filesChanged > 0 ? { filesChanged } : {},
+          ...reqPerMin > 0 ? { reqPerMin } : {}
+        },
+        `Iteration ${iteration} done`
+      );
+      emitter?.emitEvent({
+        type: "iteration:done",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        iteration,
+        durationMs: iterDurationMs,
+        madeProgress,
+        ...filesChanged > 0 ? { filesChanged } : {},
+        ...commitSubject ? { commitSubject } : {},
+        ...cumulativeCostUsd > 0 ? { costUsd: cumulativeCostUsd } : {},
+        ...opts.laneId ? { laneId: opts.laneId } : {}
+      });
+      const planPathMatch = opts.prompt.match(/plans\/([^/\s]+(?:\/[^/\s]+)?)/);
+      let planProgressPatch = {};
+      if (planPathMatch) {
+        try {
+          const planPath = planPathMatch[0];
+          const planState = parsePlanState(planPath);
+          if (planState.type === "multi") {
+            planProgressPatch = {
+              phaseCount: planState.phaseCount,
+              phasesCompleted: planState.phasesCompleted,
+              mainCheckboxesTotal: planState.totalItems,
+              mainCheckboxesCompleted: planState.checkedItems
+            };
+          }
+        } catch (err) {
+          log.debug({ err }, "plan-parser error \u2014 falling back to plan-blind heartbeat");
+        }
+      }
+      heartbeat.update({
+        iterationsCompleted: iteration,
+        cumulativeCostUsd,
+        lastIterationProgress: madeProgress,
+        lastIterationErrored: false,
+        ...planProgressPatch
+      });
+      notify({
+        event: "iteration_complete",
+        iteration,
+        costUsd: cumulativeCostUsd,
+        filesChanged: filesChanged > 0 ? filesChanged : void 0,
+        commitSubject: commitSubject || void 0,
+        message: `Iteration ${iteration} complete`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      log.debug(
+        { iteration, iterDurationMs, madeProgress, cumulativeCostUsd },
+        `Iteration ${iteration} idle (${(iterDurationMs / 1e3).toFixed(1)}s, ${madeProgress ? "progress" : "no progress"})`
+      );
+      if (!madeProgress && iteration > 1 && heartbeat?.getState().lastIterationProgress) {
+        const currentSnapshot = await captureWorkingTreeSnapshot(opts.cwd);
+        if (currentSnapshot === snapshotBefore) {
+          log.info("No progress and no pending changes \u2014 treating as complete");
+          return {
+            exitReason: "sentinel",
+            iterations: iteration,
+            message: `No further progress possible at iteration ${iteration}. Treating as complete.`,
+            sessionId,
+            cumulativeCostUsd
+          };
+        }
+      }
+      if (struggle.isStruggling()) {
+        log.warn({ iteration, struggleThreshold }, "Struggle detected \u2014 stopping");
+        notify({
+          event: "struggle",
+          iteration,
+          costUsd: heartbeat?.getState().cumulativeCostUsd,
+          message: `Agent made no filesystem progress for ${struggleThreshold} consecutive iteration(s). Stopping at iteration ${iteration}.`,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return {
+          exitReason: "struggle",
+          iterations: iteration,
+          message: `Agent made no filesystem progress for ${struggleThreshold} consecutive iteration(s). Stopping at iteration ${iteration}.`,
+          sessionId,
+          cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
+          agentHandle: transferHandle()
+        };
+      }
+    }
+    log.warn({ maxIterations }, "Reached max iterations");
+    notify({
+      event: "run_complete",
+      iteration: maxIterations,
+      costUsd: heartbeat?.getState().cumulativeCostUsd,
+      message: `Reached maximum iterations (${maxIterations}). Stopping.`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      exitReason: "max-iterations",
+      iterations: maxIterations,
+      message: `Reached maximum iterations (${maxIterations}). Stopping.`,
+      sessionId,
+      cumulativeCostUsd: heartbeat?.getState().cumulativeCostUsd,
+      agentHandle: transferHandle()
+    };
+  } finally {
+    delete process.env["GLRS_AUTOPILOT_HEADLESS"];
+    clearTimeout(timeoutHandle);
+    heartbeat?.stop();
+    process.removeListener("SIGINT", sigintHandler);
+    process.removeListener("SIGTERM", sigtermHandler);
+    if (signalCount > 0) {
+      try {
+        const { stdout: porcelain } = await execFile2("git", ["status", "--porcelain"], { cwd: opts.cwd });
+        if (porcelain.trim().length > 0) {
+          if (autoCommit) {
+            log.info({ signal: interruptedSignal }, "Committing WIP before exit");
+            try {
+              await execFile2("git", ["add", "-A"], { cwd: opts.cwd });
+              const commitMsg = commitPrefix ? `${commitPrefix} [WIP] autopilot interrupted` : "[WIP] autopilot interrupted";
+              await execFile2("git", ["commit", "-m", commitMsg], { cwd: opts.cwd });
+            } catch (err) {
+              log.warn({ err: err instanceof Error ? err.message : String(err) }, "WIP commit failed (hooks may have rejected)");
+            }
+          } else {
+            log.warn(
+              { signal: interruptedSignal },
+              "Pending changes left unstaged (auto_commit: false)"
+            );
+          }
+        }
+      } catch (err) {
+        log.debug({ err }, "WIP-status check failed (non-fatal)");
+      }
+      try {
+        writeCheckpoint(opts.cwd, {
+          planPath: opts.cwd,
+          completedPhases: [],
+          totalCostUsd: heartbeat?.getState().cumulativeCostUsd ?? 0,
+          totalIterations: heartbeat?.getState().iterationsCompleted ?? 0,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch {
+      }
+    }
+    if (!handleTransferred) {
+      log.info({}, "Shutting down agent");
+      await adapter.shutdown(handle);
+    }
+    await autopilotLog.flush();
+  }
+}
+
+// src/git-safety.ts
+import { execFile as execFileCb4 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execFile3 = promisify4(execFileCb4);
+async function recordHead(cwd, deps) {
+  const exec = deps?.execGit ?? ((args, c) => execFile3("git", args, { cwd: c }));
+  try {
+    const { stdout } = await exec(["rev-parse", "HEAD"], cwd);
+    return stdout.trim();
+  } catch {
+    return "HEAD";
+  }
+}
+async function resetSoft(cwd, sha, opts) {
+  const exec = opts?.execGit ?? ((args, c) => execFile3("git", args, { cwd: c }));
+  if (!sha || sha === "HEAD") {
+    opts?.onWarn?.(`resetSoft: invalid sha "${sha}" \u2014 skipping`);
+    return false;
+  }
+  try {
+    await exec(["reset", "--soft", sha], cwd);
+    return true;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    opts?.onWarn?.(`resetSoft failed: ${msg}`);
+    return false;
+  }
+}
+
+// src/spec-writer.ts
+import * as fs5 from "fs";
+import * as path4 from "path";
+import { parse as yamlParse, stringify as yamlStringify } from "yaml";
+function atomicWriteFileSync(target, content) {
+  const dir = path4.dirname(target);
+  const tmp = path4.join(dir, `.tmp-${process.pid}-${Date.now()}`);
+  fs5.writeFileSync(tmp, content, "utf-8");
+  fs5.renameSync(tmp, target);
+}
+function markItemUnchecked(planDir, phaseFile, itemId) {
+  const phasePath = path4.join(planDir, "spec", phaseFile);
+  try {
+    const content = fs5.readFileSync(phasePath, "utf-8");
+    const raw = yamlParse(content);
+    if (typeof raw !== "object" || raw === null) return;
+    const obj = raw;
+    if (!Array.isArray(obj["items"])) return;
+    const items = obj["items"];
+    let found = false;
+    for (const item of items) {
+      if (item["id"] === itemId) {
+        item["checked"] = false;
+        found = true;
+        break;
+      }
+    }
+    if (!found) return;
+    atomicWriteFileSync(phasePath, yamlStringify(raw));
+  } catch {
+  }
+}
+function markPhaseCompleted(planDir, phaseFile) {
+  const mainPath = path4.join(planDir, "spec", "main.yaml");
+  try {
+    const content = fs5.readFileSync(mainPath, "utf-8");
+    const raw = yamlParse(content);
+    if (typeof raw !== "object" || raw === null) return;
+    const obj = raw;
+    if (!Array.isArray(obj["phases"])) return;
+    const phases = obj["phases"];
+    let found = false;
+    for (const phase of phases) {
+      if (phase["file"] === phaseFile) {
+        phase["completed"] = true;
+        found = true;
+        break;
+      }
+    }
+    if (!found) return;
+    atomicWriteFileSync(mainPath, yamlStringify(raw));
+  } catch {
+  }
+}
+
+// src/conflict-graph.ts
+function collectPhaseFiles(items) {
+  if (items.length === 0) return null;
+  const paths = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    for (const file of item.files) {
+      if (file.path) paths.add(file.path);
+    }
+  }
+  if (paths.size === 0) return null;
+  return paths;
+}
+function buildConflictGraph(phases) {
+  const phaseNames = phases.map((p) => p.file);
+  const fileSets = /* @__PURE__ */ new Map();
+  for (const p of phases) {
+    fileSets.set(p.file, collectPhaseFiles(p.items));
+  }
+  const conflicts = /* @__PURE__ */ new Map();
+  for (const name of phaseNames) {
+    conflicts.set(name, /* @__PURE__ */ new Set());
+  }
+  for (let i = 0; i < phaseNames.length; i++) {
+    for (let j = i + 1; j < phaseNames.length; j++) {
+      const a = phaseNames[i];
+      const b = phaseNames[j];
+      const setA = fileSets.get(a) ?? null;
+      const setB = fileSets.get(b) ?? null;
+      let conflict = false;
+      if (setA === null || setB === null) {
+        conflict = true;
+      } else {
+        for (const p of setA) {
+          if (setB.has(p)) {
+            conflict = true;
+            break;
+          }
+        }
+      }
+      if (conflict) {
+        conflicts.get(a).add(b);
+        conflicts.get(b).add(a);
+      }
+    }
+  }
+  return { phases: phaseNames, conflicts };
+}
+function findIndependentPhases(graph) {
+  const groups = [];
+  for (const phase of graph.phases) {
+    const conflictsWith = graph.conflicts.get(phase) ?? /* @__PURE__ */ new Set();
+    let placed = false;
+    for (const group of groups) {
+      let ok = true;
+      for (const member of group) {
+        if (conflictsWith.has(member)) {
+          ok = false;
+          break;
+        }
+      }
+      if (ok) {
+        group.push(phase);
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) {
+      groups.push([phase]);
+    }
+  }
+  return groups;
+}
+function hasParallelism(graph) {
+  return findIndependentPhases(graph).some((g) => g.length > 1);
+}
+
+// src/lane-orchestrator.ts
+function conflictsWithRunning(phase, running, graph) {
+  const conflicts = graph.conflicts.get(phase);
+  if (!conflicts) return false;
+  for (const r of running) {
+    if (r === phase) continue;
+    if (conflicts.has(r)) return true;
+  }
+  return false;
+}
+async function runLanes(opts) {
+  const laneCount = Math.max(1, opts.laneCount);
+  const queue = [...opts.phases];
+  const running = /* @__PURE__ */ new Set();
+  const results = [];
+  const skipped = [];
+  let stopScheduling = false;
+  const inFlight = [];
+  const freeLanes = [];
+  for (let i = 1; i <= laneCount; i++) {
+    freeLanes.push(`lane-${i}`);
+  }
+  const pickNext = () => {
+    for (let i = 0; i < queue.length; i++) {
+      const candidate = queue[i];
+      if (!conflictsWithRunning(candidate, running, opts.conflictGraph)) {
+        queue.splice(i, 1);
+        return candidate;
+      }
+    }
+    return null;
+  };
+  const fillLanes = () => {
+    let dispatched = 0;
+    while (!stopScheduling && freeLanes.length > 0 && queue.length > 0) {
+      const phase = pickNext();
+      if (!phase) break;
+      const laneId = freeLanes.shift();
+      running.add(phase);
+      opts.logger?.info?.(
+        { laneId, phase, lanesActive: running.size, queued: queue.length },
+        `dispatch phase ${phase} on ${laneId}`
+      );
+      const promise = opts.runPhase(phase, laneId);
+      inFlight.push({ phase, laneId, promise });
+      dispatched++;
+    }
+    return dispatched;
+  };
+  if (opts.abortSignal?.aborted) {
+    return { results: [], skipped: [...queue] };
+  }
+  const abortListener = () => {
+    stopScheduling = true;
+    opts.logger?.info?.({ remaining: queue.length }, "abort received \u2014 draining in-flight lanes");
+  };
+  opts.abortSignal?.addEventListener("abort", abortListener, { once: true });
+  try {
+    fillLanes();
+    while (inFlight.length > 0) {
+      const indexed = inFlight.map(
+        (f, idx2) => f.promise.then((r) => ({ idx: idx2, result: r }))
+      );
+      const winner = await Promise.race(indexed);
+      const { idx, result } = winner;
+      const finished = inFlight[idx];
+      inFlight.splice(idx, 1);
+      running.delete(finished.phase);
+      freeLanes.push(finished.laneId);
+      results.push(result);
+      opts.logger?.info?.(
+        {
+          laneId: finished.laneId,
+          phase: finished.phase,
+          ok: result.ok,
+          iterations: result.iterations,
+          remaining: queue.length
+        },
+        `completed phase ${finished.phase} on ${finished.laneId} (${result.ok ? "ok" : "failed"})`
+      );
+      if (result.fatal) {
+        stopScheduling = true;
+        opts.logger?.info?.(
+          { phase: finished.phase },
+          `fatal failure \u2014 stopping new dispatches`
+        );
+      }
+      if (!stopScheduling) {
+        fillLanes();
+      }
+    }
+    skipped.push(...queue);
+  } finally {
+    opts.abortSignal?.removeEventListener("abort", abortListener);
+  }
+  return { results, skipped };
+}
+
+// src/worktree.ts
+import { execFile as execFileCb5 } from "child_process";
+import { promisify as promisify5 } from "util";
+import * as path5 from "path";
+var execFileDefault2 = promisify5(execFileCb5);
+async function createWorktree(repoRoot, opts) {
+  const exec = opts._deps?.execFile ?? execFileDefault2;
+  const logger = opts.logger;
+  const stamp = Date.now();
+  const wtPath = path5.join(repoRoot, ".agent", "worktrees", `${opts.laneSlug}-${stamp}`);
+  const branch = `autopilot/${opts.laneSlug}`;
+  await exec("git", ["worktree", "add", wtPath, "-b", branch], { cwd: repoRoot });
+  let cleanedUp = false;
+  const cleanup = async () => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    try {
+      await exec("git", ["worktree", "remove", wtPath], { cwd: repoRoot });
+    } catch (err) {
+      logger?.warn?.(
+        { err: err instanceof Error ? err.message : String(err), path: wtPath },
+        `worktree cleanup failed for ${wtPath}`
+      );
+      return;
+    }
+    try {
+      await exec("git", ["branch", "-D", branch], { cwd: repoRoot });
+    } catch (err) {
+      logger?.warn?.(
+        { err: err instanceof Error ? err.message : String(err), branch },
+        `branch cleanup failed for ${branch}`
+      );
+    }
+  };
+  return { path: wtPath, branch, cleanup };
+}
+function parseConflictPaths(output) {
+  const paths = /* @__PURE__ */ new Set();
+  const re = /^CONFLICT\s*\([^)]*\):\s*Merge conflict in\s+(.+)$/gm;
+  let m;
+  while ((m = re.exec(output)) !== null) {
+    paths.add(m[1].trim());
+  }
+  return [...paths];
+}
+async function mergeWorktree(repoRoot, opts) {
+  const exec = opts._deps?.execFile ?? execFileDefault2;
+  try {
+    await exec("git", ["merge", "--no-ff", opts.branch], { cwd: repoRoot });
+    return { ok: true };
+  } catch (err) {
+    const e = err;
+    const combined = `${e.stdout ?? ""}
+${e.stderr ?? ""}`;
+    const conflicts = parseConflictPaths(combined);
+    try {
+      await exec("git", ["merge", "--abort"], { cwd: repoRoot });
+    } catch {
+    }
+    return { ok: false, conflicts };
+  }
+}
+
+// src/verify-runner.ts
+import { execFile as execFileCb6 } from "child_process";
+import { promisify as promisify6 } from "util";
+var execFileDefault3 = promisify6(execFileCb6);
+var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+function getTimeoutForProofType(proofType, customTimeoutMs) {
+  if (!proofType) return customTimeoutMs;
+  switch (proofType) {
+    case "unit_test":
+      return 30 * 1e3;
+    case "api_check":
+      return 10 * 1e3;
+    case "structural":
+    case "typecheck":
+      return 60 * 1e3;
+    case "e2e":
+      return 120 * 1e3;
+    default:
+      return customTimeoutMs;
+  }
+}
+async function runVerifyCommands(items, cwd, opts = {}) {
+  const execFile4 = opts._deps?.execFile ?? execFileDefault3;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const results = [];
+  for (const item of items) {
+    const command = item.verify?.trim();
+    if (!command) continue;
+    const itemTimeoutMs = getTimeoutForProofType(item.proof_type, timeoutMs);
+    const start = Date.now();
+    try {
+      const { stdout, stderr } = await execFile4("/bin/sh", ["-c", command], {
+        cwd,
+        signal: AbortSignal.timeout(itemTimeoutMs),
+        // Capture as much output as the command produces — verify
+        // commands are typically test runs; truncating their output
+        // would hide the failure detail we want in the next prompt.
+        maxBuffer: 10 * 1024 * 1024
+      });
+      results.push({
+        itemId: item.id,
+        command,
+        passed: true,
+        stdout: typeof stdout === "string" ? stdout : String(stdout ?? ""),
+        stderr: typeof stderr === "string" ? stderr : String(stderr ?? ""),
+        durationMs: Date.now() - start
+      });
+    } catch (err) {
+      const e = err;
+      const isTimeout = e.name === "AbortError" || e.code === "ABORT_ERR";
+      const stdout = e.stdout !== void 0 ? typeof e.stdout === "string" ? e.stdout : e.stdout.toString() : "";
+      let stderr = e.stderr !== void 0 ? typeof e.stderr === "string" ? e.stderr : e.stderr.toString() : "";
+      if (isTimeout) {
+        stderr = (stderr ? stderr + "\n" : "") + `[verify-runner] command timed out after ${Math.round(itemTimeoutMs / 1e3)}s`;
+      } else if (!stderr && e.message) {
+        stderr = e.message;
+      }
+      results.push({
+        itemId: item.id,
+        command,
+        passed: false,
+        stdout,
+        stderr,
+        durationMs: Date.now() - start
+      });
+    }
+  }
+  return results;
+}
+
+// src/hook-runner.ts
+import { execFile as execFileCb7 } from "child_process";
+import { promisify as promisify7 } from "util";
+var execFileDefault4 = promisify7(execFileCb7);
+async function runHook(cmd, cwd, timeoutMs, opts = {}) {
+  if (!cmd?.trim()) {
+    return { ok: true, output: "" };
+  }
+  const execFile4 = opts._deps?.execFile ?? execFileDefault4;
+  const timeout = opts.timeoutMs ?? timeoutMs;
+  try {
+    const { stdout, stderr } = await execFile4("/bin/sh", ["-c", cmd], {
+      cwd,
+      signal: AbortSignal.timeout(timeout),
+      maxBuffer: 10 * 1024 * 1024
+    });
+    const combinedOutput = (typeof stdout === "string" ? stdout : String(stdout ?? "")) + (typeof stderr === "string" ? stderr : String(stderr ?? ""));
+    return { ok: true, output: combinedOutput };
+  } catch (err) {
+    const e = err;
+    const isTimeout = e.name === "AbortError" || e.code === "ABORT_ERR";
+    let stderr = e.stderr !== void 0 ? typeof e.stderr === "string" ? e.stderr : e.stderr.toString() : "";
+    if (isTimeout) {
+      stderr = (stderr ? stderr + "\n" : "") + `[hook-runner] command timed out after ${Math.round(timeout / 1e3)}s`;
+    } else if (!stderr && e.message) {
+      stderr = e.message;
+    }
+    return { ok: false, output: stderr };
+  }
+}
+
+// src/plan-validator.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { parse as yamlParse2 } from "yaml";
+function detectReferencedPhaseFiles(mainContent) {
+  const found = /* @__PURE__ */ new Set();
+  const checkboxRe = /^- \[[ xX]\]\s+(?:\[)?([a-zA-Z0-9_-]+\.md)(?:\]\([^)]*\))?/gm;
+  let match;
+  while ((match = checkboxRe.exec(mainContent)) !== null) {
+    found.add(match[1]);
+  }
+  const linkRe = /\[([a-zA-Z0-9_-]+\.md)\]\(\.\//g;
+  while ((match = linkRe.exec(mainContent)) !== null) {
+    found.add(match[1]);
+  }
+  return found;
+}
+function validatePlan(planPath) {
+  const errors = [];
+  const warnings = [];
+  let stat;
+  try {
+    stat = fs6.statSync(planPath);
+  } catch {
+    errors.push({
+      code: "missing-plan",
+      message: `Plan path does not exist: ${planPath}`
+    });
+    return { errors, warnings };
+  }
+  if (!stat.isDirectory()) {
+    try {
+      const content = fs6.readFileSync(planPath, "utf-8");
+      checkItemsSoft(content, planPath, warnings);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warnings.push({
+        code: "plan-read-failed",
+        message: `Plan file unreadable: ${msg}`,
+        file: planPath
+      });
+    }
+    return { errors, warnings };
+  }
+  if (hasSpec(planPath)) {
+    const mainSpecPath = path6.join(planPath, "spec", "main.yaml");
+    try {
+      const mainContent2 = fs6.readFileSync(mainSpecPath, "utf-8");
+      const rawMain = yamlParse2(mainContent2);
+      const mainValidation = validateMainSpec(rawMain);
+      if (!mainValidation.valid) {
+        for (const msg of mainValidation.errors) {
+          errors.push({
+            code: "invalid-spec-main",
+            message: `spec/main.yaml: ${msg}`,
+            file: mainSpecPath
+          });
+        }
+        return { errors, warnings };
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      errors.push({
+        code: "invalid-spec-main",
+        message: `spec/main.yaml unreadable: ${msg}`,
+        file: mainSpecPath
+      });
+      return { errors, warnings };
+    }
+    const phaseFiles = detectSpecPhases(planPath);
+    for (const phaseFile of phaseFiles) {
+      const phasePath = path6.join(planPath, "spec", phaseFile);
+      if (!fs6.existsSync(phasePath)) {
+        errors.push({
+          code: "missing-spec-phase-file",
+          message: `Phase file referenced in spec/main.yaml does not exist: ${phaseFile}`,
+          file: phaseFile
+        });
+        continue;
+      }
+      try {
+        const phaseContent = fs6.readFileSync(phasePath, "utf-8");
+        const rawPhase = yamlParse2(phaseContent);
+        const phaseValidation = validatePhaseSpec(rawPhase);
+        if (!phaseValidation.valid) {
+          for (const msg of phaseValidation.errors) {
+            errors.push({
+              code: "invalid-spec-phase",
+              message: `spec/${phaseFile}: ${msg}`,
+              file: phaseFile
+            });
+          }
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        warnings.push({
+          code: "spec-phase-read-failed",
+          message: `spec/${phaseFile} unreadable: ${msg}`,
+          file: phaseFile
+        });
+      }
+    }
+    return { errors, warnings };
+  }
+  const mainPath = path6.join(planPath, "main.md");
+  if (!fs6.existsSync(mainPath)) {
+    errors.push({
+      code: "missing-main",
+      message: "Directory plan must contain main.md",
+      file: mainPath
+    });
+    return { errors, warnings };
+  }
+  let mainContent;
+  try {
+    mainContent = fs6.readFileSync(mainPath, "utf-8");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    errors.push({
+      code: "main-read-failed",
+      message: `main.md unreadable: ${msg}`,
+      file: mainPath
+    });
+    return { errors, warnings };
+  }
+  const referencedPhases = detectReferencedPhaseFiles(mainContent);
+  for (const phaseFile of referencedPhases) {
+    const phasePath = path6.join(planPath, phaseFile);
+    if (!fs6.existsSync(phasePath)) {
+      errors.push({
+        code: "missing-phase-file",
+        message: `Phase file referenced in main.md does not exist: ${phaseFile}`,
+        file: phaseFile
+      });
+    }
+  }
+  let phaseEntries = [];
+  try {
+    phaseEntries = fs6.readdirSync(planPath).filter(
+      (f) => f.endsWith(".md") && f !== "main.md" && f !== "scope.md" && f !== "scope-seed.md"
+    );
+  } catch {
+  }
+  for (const phaseFile of phaseEntries) {
+    const phasePath = path6.join(planPath, phaseFile);
+    let content;
+    try {
+      content = fs6.readFileSync(phasePath, "utf-8");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      warnings.push({
+        code: "phase-read-failed",
+        message: `Phase file unreadable: ${msg}`,
+        file: phaseFile
+      });
+      continue;
+    }
+    const items = parseItems(content);
+    const withIntent = items.filter((it) => it.intent && it.intent.trim());
+    if (items.length > 0 && withIntent.length === 0) {
+      errors.push({
+        code: "no-intent-in-phase",
+        message: `Phase file has items but none declare an intent: ${phaseFile}`,
+        file: phaseFile
+      });
+    }
+    checkItemsSoft(content, phaseFile, warnings);
+  }
+  return { errors, warnings };
+}
+function checkItemsSoft(content, file, warnings) {
+  const items = parseItems(content);
+  for (const item of items) {
+    if (item.files.length === 0) {
+      warnings.push({
+        code: "missing-files",
+        message: `Item ${item.id} has no files: list`,
+        file,
+        itemId: item.id
+      });
+    }
+    if (item.tests.length === 0) {
+      warnings.push({
+        code: "missing-tests",
+        message: `Item ${item.id} has no tests: list`,
+        file,
+        itemId: item.id
+      });
+    }
+    if (!item.verify || !item.verify.trim()) {
+      warnings.push({
+        code: "missing-verify",
+        message: `Item ${item.id} has no verify: command`,
+        file,
+        itemId: item.id
+      });
+    }
+  }
+}
+
+// src/phase-config.ts
+function deepMerge(...objects) {
+  const result = {};
+  for (const obj of objects) {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+      continue;
+    }
+    for (const key in obj) {
+      const srcValue = obj[key];
+      if (srcValue && typeof srcValue === "object" && !Array.isArray(srcValue) && !(srcValue instanceof Date)) {
+        const targetValue = result[key];
+        if (targetValue && typeof targetValue === "object" && !Array.isArray(targetValue) && !(targetValue instanceof Date)) {
+          result[key] = deepMerge(
+            targetValue,
+            srcValue
+          );
+        } else {
+          result[key] = srcValue;
+        }
+      } else {
+        result[key] = srcValue;
+      }
+    }
+  }
+  return result;
+}
+function resolvePhaseConfig(baseConfig, phaseName) {
+  if (!baseConfig || typeof baseConfig !== "object" || Array.isArray(baseConfig)) {
+    return {};
+  }
+  const base = baseConfig;
+  const phases = base.phases;
+  if (!phases || typeof phases !== "object") {
+    return base;
+  }
+  const phaseOverride = phases[phaseName];
+  if (!phaseOverride || typeof phaseOverride !== "object" || Array.isArray(phaseOverride)) {
+    return base;
+  }
+  return deepMerge(base, phaseOverride);
+}
+
+// src/loop-session.ts
+function extractVerifyConfig(config) {
+  const cfgObj = config;
+  const strategy = cfgObj?.verify ?? "after_phase";
+  const timeoutMs = cfgObj?.verify_timeout ?? 5 * 60 * 1e3;
+  const retryOnFailure = cfgObj?.verify_retry ?? true;
+  return { strategy, timeoutMs, retryOnFailure };
+}
+function extractHooksConfig(config) {
+  const cfgObj = config;
+  const hooks = cfgObj?.hooks;
+  return {
+    pre_phase: hooks?.pre_phase,
+    post_phase: hooks?.post_phase,
+    post_run: hooks?.post_run,
+    on_error: hooks?.on_error
+  };
+}
+function uncheckItemsInMarkdown(content, itemIds) {
+  if (itemIds.length === 0) return content;
+  let result = content;
+  for (const itemId of itemIds) {
+    const escaped = itemId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const re = new RegExp(`^(- )\\[[xX]\\](\\s+id:\\s+${escaped}\\b)`, "m");
+    result = result.replace(re, "$1[ ]$2");
+  }
+  return result;
+}
+function extractSection(content, sectionName) {
+  const re = new RegExp(
+    `^## ${sectionName}\\s*\\n([\\s\\S]*?)(?=^## |$)`,
+    "m"
+  );
+  const match = re.exec(content);
+  return match ? match[1].trim() : "";
+}
+function detectPhaseFiles2(mainContent, planDir) {
+  const found = /* @__PURE__ */ new Set();
+  const checkboxRe = /^- \[[ xX]\]\s+(?:\[)?([a-zA-Z0-9_-]+\.md)(?:\]\([^)]*\))?/gm;
+  let match;
+  while ((match = checkboxRe.exec(mainContent)) !== null) {
+    found.add(match[1]);
+  }
+  const linkRe = /\[([a-zA-Z0-9_-]+\.md)\]\(\.\//g;
+  while ((match = linkRe.exec(mainContent)) !== null) {
+    found.add(match[1]);
+  }
+  if (found.size === 0) {
+    try {
+      const entries = fs7.readdirSync(planDir);
+      for (const f of entries) {
+        if (f.endsWith(".md") && f !== "main.md" && f !== "scope.md" && f !== "scope-seed.md") {
+          found.add(f);
+        }
+      }
+    } catch {
+    }
+  }
+  return [...found].sort((a, b) => {
+    const numA = parseInt(a.replace(/[^0-9]/g, ""), 10) || 0;
+    const numB = parseInt(b.replace(/[^0-9]/g, ""), 10) || 0;
+    return numA - numB;
+  });
+}
+function filterUncheckedPhases(phaseFiles, mainContent, planDir, readFile) {
+  const checkedRe = /^- \[x\]\s+(?:\[)?([a-zA-Z0-9_-]+\.md)/gm;
+  const checked = /* @__PURE__ */ new Set();
+  let match;
+  while ((match = checkedRe.exec(mainContent)) !== null) {
+    checked.add(match[1]);
+  }
+  const hasCheckboxRefs = /^- \[[ xX]\]\s+(?:\[)?[a-zA-Z0-9_-]+\.md/m.test(mainContent);
+  if (hasCheckboxRefs) {
+    return phaseFiles.filter((f) => !checked.has(f));
+  }
+  return phaseFiles.filter((f) => {
+    try {
+      const content = readFile(path7.join(planDir, f));
+      return !isPhaseComplete(content);
+    } catch {
+      return true;
+    }
+  });
+}
+function isPhaseComplete(phaseContent) {
+  const checkboxRe = /^[ \t]*-\s+\[([ xX])\]/gm;
+  let total = 0;
+  let checked = 0;
+  let match;
+  while ((match = checkboxRe.exec(phaseContent)) !== null) {
+    total++;
+    if (match[1] !== " ") checked++;
+  }
+  return total === 0 || checked === total;
+}
+function markPhaseChecked(mainContent, phaseFile) {
+  const escaped = phaseFile.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`^(- )\\[ \\](\\s+(?:\\[)?${escaped})`, "m");
+  return mainContent.replace(re, "$1[x]$2");
+}
+var SUCCESS_REASONS = /* @__PURE__ */ new Set(["sentinel", "idle", "max-iterations"]);
+function filterUncheckedPhasesYaml(phaseFiles, planDir) {
+  return filterUncheckedSpecPhases(phaseFiles, planDir);
+}
+async function runLoopSession(opts) {
+  const _runRalphLoop = opts._deps?.runRalphLoop ?? runRalphLoop;
+  const _readFileSync = opts._deps?.readFileSync ?? ((p) => fs7.readFileSync(p, "utf8"));
+  const _writeFileSync = opts._deps?.writeFileSync ?? ((p, content) => fs7.writeFileSync(p, content, "utf8"));
+  const _runVerifyCommands = opts._deps?.runVerifyCommands ?? runVerifyCommands;
+  const emitter = opts.emitter;
+  if (!opts._deps) {
+    const report = validatePlan(opts.planPath);
+    if (report.errors.length > 0 || report.warnings.length > 0) {
+      const earlyLog = opts.logger ? opts.logger.root.child({ component: "autopilot.plan-validator" }) : null;
+      for (const w of report.warnings) {
+        if (earlyLog) {
+          earlyLog.warn(
+            {
+              code: w.code,
+              ...w.file ? { file: w.file } : {},
+              ...w.itemId ? { itemId: w.itemId } : {}
+            },
+            w.message
+          );
+        }
+      }
+      if (report.errors.length > 0) {
+        for (const e of report.errors) {
+          if (earlyLog) {
+            earlyLog.error(
+              {
+                code: e.code,
+                ...e.file ? { file: e.file } : {},
+                ...e.itemId ? { itemId: e.itemId } : {}
+              },
+              e.message
+            );
+          }
+        }
+        return {
+          exitReason: "error",
+          iterations: 0,
+          message: `Plan validation failed: ${report.errors.map((e) => e.message).join("; ")}`
+        };
+      }
+    }
+  }
+  const isDirectory = opts._deps?.isDirectory ? opts._deps.isDirectory(opts.planPath) : (() => {
+    try {
+      return fs7.statSync(opts.planPath).isDirectory();
+    } catch {
+      return false;
+    }
+  })();
+  if (!isDirectory) {
+    const prompt = `Work the plan at ${opts.planPath}. Complete all items in ## Acceptance criteria. Mark items done as they complete.`;
+    const adapterName = opts.adapter?.name;
+    const singleFileCfgObj = opts.config;
+    const models = singleFileCfgObj?.models;
+    const executionSpecifier = models?.execution;
+    const executionModel = executionSpecifier ? resolveModel(executionSpecifier, adapterName ?? "opencode") : void 0;
+    const singleFileStallMs = singleFileCfgObj?.stall_timeout ?? STALL_MS_BY_TIER[opts.fast ? "autopilot-execute" : "deep"];
+    const singleFileAdapters = opts.config?.adapters;
+    const singleFileOcAdapter = singleFileAdapters?.opencode;
+    const singleFileAgentOverrides = singleFileOcAdapter?.agents;
+    return _runRalphLoop({
+      prompt,
+      cwd: opts.cwd,
+      agentName: opts.fast ? "autopilot-fast" : void 0,
+      model: executionModel,
+      stallMs: singleFileStallMs,
+      config: opts.config,
+      agentOverrides: singleFileAgentOverrides,
+      logger: opts.logger,
+      emitter,
+      adapter: opts.adapter
+    });
+  }
+  const log = opts.logger ? opts.logger.root.child({ component: "autopilot.orchestrator" }) : pino(
+    { level: "info", timestamp: pino.stdTimeFunctions.isoTime },
+    pino.destination({ fd: 2, sync: false })
+  ).child({ component: "autopilot.orchestrator" });
+  const tier = opts.fast ? "autopilot-execute" : "deep";
+  const cfgObj = opts.config;
+  const cfgMaxIterPerPhase = cfgObj?.max_iterations_per_phase;
+  const maxIterationsPerPhase = opts.maxIterationsPerPhase ?? cfgMaxIterPerPhase ?? MAX_ITERATIONS_PER_PHASE_BY_TIER[tier];
+  const cfgStallMs = cfgObj?.stall_timeout;
+  const stallMs = cfgStallMs ?? STALL_MS_BY_TIER[tier];
+  const verifyConfig = extractVerifyConfig(opts.config);
+  const hooksConfig = extractHooksConfig(opts.config);
+  const mainMdPath = path7.join(opts.planPath, "main.md");
+  const useYamlSpec = hasSpec(opts.planPath);
+  let goal;
+  let constraints;
+  let allPhases;
+  if (useYamlSpec) {
+    goal = readSpecGoal(opts.planPath);
+    constraints = readSpecConstraints(opts.planPath);
+    allPhases = detectSpecPhases(opts.planPath);
+  } else {
+    const mainContent = _readFileSync(mainMdPath);
+    goal = extractSection(mainContent, "Goal");
+    constraints = extractSection(mainContent, "Constraints");
+    allPhases = detectPhaseFiles2(mainContent, opts.planPath);
+  }
+  const mainContentForFilter = useYamlSpec ? "" : _readFileSync(mainMdPath);
+  let uncheckedPhases = useYamlSpec ? filterUncheckedPhasesYaml(allPhases, opts.planPath) : filterUncheckedPhases(allPhases, mainContentForFilter, opts.planPath, _readFileSync);
+  let resumedFromCheckpoint = false;
+  if (opts.resume) {
+    const cp = readCheckpoint(opts.cwd);
+    if (cp) {
+      if (cp.planPath !== opts.planPath) {
+        log.warn({ expected: opts.planPath, found: cp.planPath }, "checkpoint planPath mismatch, starting fresh");
+      } else {
+        const skip = new Set(cp.completedPhases);
+        const before = uncheckedPhases.length;
+        uncheckedPhases = uncheckedPhases.filter((p) => !skip.has(p));
+        const skipped = before - uncheckedPhases.length;
+        if (skipped > 0) {
+          log.info({ skipped, remaining: uncheckedPhases.length }, "resuming from checkpoint");
+          resumedFromCheckpoint = true;
+        }
+      }
+    } else {
+      log.info("no checkpoint found, starting fresh");
+    }
+  }
+  log.info({ total: allPhases.length, remaining: uncheckedPhases.length }, "plan loaded");
+  emitter?.emitEvent({
+    type: "phase:start",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    phase: `plan loaded: ${uncheckedPhases.length}/${allPhases.length} phases remaining`,
+    laneId: "lane-1",
+    current: 0,
+    total: allPhases.length
+  });
+  if (uncheckedPhases.length === 0) {
+    log.info("all phases already complete \u2014 nothing to do");
+    emitter?.emitEvent({
+      type: "phase:done",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      phase: "all phases already complete",
+      laneId: "lane-1",
+      completed: true,
+      iterations: 0,
+      costUsd: 0
+    });
+    return {
+      exitReason: "sentinel",
+      iterations: 0,
+      message: "All phases already complete \u2014 nothing to do",
+      cumulativeCostUsd: 0
+    };
+  }
+  for (const p of uncheckedPhases) {
+    log.info({ file: p }, "phase file");
+  }
+  const phaseInputs = uncheckedPhases.map((f) => ({
+    file: f,
+    items: (() => {
+      try {
+        return parseItems(_readFileSync(path7.join(opts.planPath, f)));
+      } catch {
+        return [];
+      }
+    })()
+  }));
+  const conflictGraph = buildConflictGraph(phaseInputs);
+  const planParallel = hasParallelism(conflictGraph);
+  const requestedLanes = Math.max(1, opts.parallel ?? 1);
+  const useParallel = requestedLanes > 1 && planParallel;
+  if (uncheckedPhases.length > 1) {
+    if (useParallel) {
+      log.info(
+        { lanes: requestedLanes, phases: uncheckedPhases.length },
+        "parallelization plan: independent phases will run in worktrees"
+      );
+    } else if (requestedLanes > 1 && !planParallel) {
+      log.info(
+        { lanes: requestedLanes },
+        "parallelization plan: every phase shares a file \u2014 falling back to sequential"
+      );
+    } else {
+      log.info({ lanes: 1 }, "parallelization plan: sequential");
+    }
+  }
+  let totalCostUsd = 0;
+  let totalIterations = 0;
+  let phasesCompleted = 0;
+  const laneCosts = /* @__PURE__ */ new Map();
+  const orphanedWorktrees = [];
+  const verifyResults = [];
+  const completedPhasesAcc = [];
+  if (resumedFromCheckpoint) {
+    const cp = readCheckpoint(opts.cwd);
+    if (cp) {
+      totalCostUsd = cp.totalCostUsd;
+      totalIterations = cp.totalIterations;
+      completedPhasesAcc.push(...cp.completedPhases);
+    }
+  }
+  let lastResult = {
+    exitReason: "sentinel",
+    iterations: 0,
+    message: "No phases to execute."
+  };
+  const cfgMaxIterPerItem = opts.config?.max_iterations_per_item;
+  const maxIterationsPerItem = cfgMaxIterPerItem ?? MAX_ITERATIONS_PER_ITEM;
+  const runItemsForPhase = async (args) => {
+    const { phaseFile, phasePath, laneId, runCwd, useParallel: useParallel2 } = args;
+    const phaseContent = args.readFileSync(phasePath);
+    const allItems = useYamlSpec ? parseSpecItems(phasePath) : parseItems(phaseContent);
+    const items = allItems.filter((it) => !it.checked);
+    log.info(
+      { phase: phaseFile, total: allItems.length, unchecked: items.length, checked: allItems.length - items.length },
+      `phase items: ${items.length} unchecked of ${allItems.length} total`
+    );
+    if (items.length === 0) {
+      const prompt = `You are executing one phase of a multi-file plan. Work through every unchecked item in order. Check each box as you complete it. Commit when the phase is done.
+
+## Overall goal
+${goal}
+
+## Constraints
+${constraints}
+
+## Your phase (${phaseFile})
+${phaseContent}
+
+Do not work on items from other phases. Do not ask questions.`;
+      const adapterName = args.adapter?.name;
+      const cfgObj2 = args.config;
+      const models = cfgObj2?.models;
+      const executionSpecifier = models?.execution;
+      const executionModel = executionSpecifier ? resolveModel(executionSpecifier, adapterName ?? "opencode") : void 0;
+      return args.runRalphLoop({
+        prompt,
+        cwd: runCwd,
+        agentName: "autopilot-fast",
+        model: executionModel,
+        maxIterations: maxIterationsPerPhase,
+        ...args.stallMs ? { stallMs: args.stallMs } : {},
+        config: args.config,
+        agentOverrides: args.agentOverrides,
+        laneId: useParallel2 ? laneId : void 0,
+        logger: args.logger,
+        emitter: args.emitter,
+        adapter: args.adapter
+      });
+    }
+    const perItemCap = Math.max(
+      1,
+      Math.min(
+        maxIterationsPerItem,
+        Math.ceil(maxIterationsPerPhase / items.length)
+      )
+    );
+    let cumulativeIterations = 0;
+    let cumulativeCost = 0;
+    let lastItemResult = {
+      exitReason: "sentinel",
+      iterations: 0,
+      message: "No items to execute."
+    };
+    for (const item of items) {
+      const filesList = item.files.map((f) => `${f.path}${f.isNew ? " (CREATE)" : " (EDIT)"}`).join(", ");
+      const verify = item.verify?.trim() || "(no verify command declared)";
+      const enriched = item;
+      let enrichmentBlock = "";
+      if (enriched.mirror || enriched.context || enriched.conventions || enriched.proof) {
+        const parts = [];
+        if (typeof enriched.mirror === "string" && enriched.mirror.trim()) {
+          parts.push(`Pattern reference (read this file for the pattern to follow):
+  ${enriched.mirror}`);
+        }
+        if (typeof enriched.context === "string" && enriched.context.trim()) {
+          parts.push(`Code context:
+${enriched.context}`);
+        }
+        if (typeof enriched.conventions === "string" && enriched.conventions.trim()) {
+          parts.push(`Conventions: ${enriched.conventions}`);
+        }
+        if (typeof enriched.proof === "string" && enriched.proof.trim()) {
+          const proofType = typeof enriched.proof_type === "string" ? ` (${enriched.proof_type})` : "";
+          parts.push(`Acceptance proof${proofType}: ${enriched.proof}`);
+        }
+        enrichmentBlock = `
+## Enrichment context
+
+${parts.join("\n\n")}
+
+`;
+      }
+      const phaseConfigForItem = resolvePhaseConfig(
+        args.config,
+        phaseFile.replace(/\.(md|ya?ml)$/, "")
+      );
+      const executionStyle = phaseConfigForItem?.execution_style;
+      const isTddMode = executionStyle !== "direct";
+      let itemPrompt;
+      if (isTddMode) {
+        itemPrompt = `You are executing ONE item of a multi-item phase using TDD (test-driven development). Follow the red-green-refactor cycle strictly:
+
+1. RED: Write a failing test/proof first. Run verify to confirm it fails.
+2. GREEN: Implement the minimal code to make the test pass. Run verify to confirm it passes.
+3. REFACTOR: Clean up the code if needed, re-run verify to ensure it still passes.
+4. MARK: Mark the item checkbox and commit only after the verify command passes.
+
+Complete only this item, mark its checkbox in ${phaseFile}, commit, and stop. Do not work on other items.
+
+## Overall goal
+${goal}
+
+## Constraints
+${constraints}
+
+## Your item
+- [ ] id: ${item.id}
+  intent: ${item.intent}
+  files: ${filesList || "(none declared)"}
+  verify: ${verify}
+
+` + enrichmentBlock + `## Structured context
+
+Files you may touch (ONLY these):
+` + (item.files.length > 0 ? item.files.map((f) => `  - ${f.path} (${f.isNew ? "CREATE" : "EDIT"})`).join("\n") : "  (none declared \u2014 confine edits to the phase's natural scope)") + `
+
+Verify command (must exit 0):
+  - ${verify}
+
+TDD workflow:
+  1. Write a test that fails (RED phase)
+  2. Implement to make it pass (GREEN phase)
+  3. Refactor if needed, re-verify (REFACTOR phase)
+  4. Mark checkbox when verify passes
+
+Non-goals:
+  - Do NOT skip the RED phase \u2014 always write the test first.
+  - Do NOT modify files outside the list above.
+  - Do NOT work on items other than ${item.id}.
+
+When done: mark the checkbox for item ${item.id} in ${phaseFile} as [x], commit, and emit the autopilot-done sentinel.`;
+      } else {
+        itemPrompt = `You are executing ONE item of a multi-item phase. Complete only this item, mark its checkbox in ${phaseFile}, commit, and stop. Do not work on other items.
+
+## Overall goal
+${goal}
+
+## Constraints
+${constraints}
+
+## Your item
+- [ ] id: ${item.id}
+  intent: ${item.intent}
+  files: ${filesList || "(none declared)"}
+  verify: ${verify}
+
+` + enrichmentBlock + `## Structured context
+
+Files you may touch (ONLY these):
+` + (item.files.length > 0 ? item.files.map((f) => `  - ${f.path} (${f.isNew ? "CREATE" : "EDIT"})`).join("\n") : "  (none declared \u2014 confine edits to the phase's natural scope)") + `
+
+Verify command (must exit 0):
+  - ${verify}
+
+Non-goals:
+  - Do NOT modify files outside the list above.
+  - Do NOT work on items other than ${item.id}.
+
+When done: mark the checkbox for item ${item.id} in ${phaseFile} as [x], commit, and emit the autopilot-done sentinel.`;
+      }
+      const adapterName = args.adapter?.name;
+      const cfgObj2 = args.config;
+      const models = cfgObj2?.models;
+      const executionSpecifier = models?.execution;
+      const executionModel = executionSpecifier ? resolveModel(executionSpecifier, adapterName ?? "opencode") : void 0;
+      const itemResult = await args.runRalphLoop({
+        prompt: itemPrompt,
+        cwd: runCwd,
+        agentName: "autopilot-fast",
+        model: executionModel,
+        maxIterations: perItemCap,
+        ...args.stallMs ? { stallMs: args.stallMs } : {},
+        config: args.config,
+        agentOverrides: args.agentOverrides,
+        laneId: useParallel2 ? laneId : void 0,
+        logger: args.logger,
+        emitter: args.emitter,
+        adapter: args.adapter
+      });
+      cumulativeIterations += itemResult.iterations;
+      cumulativeCost += itemResult.cumulativeCostUsd ?? 0;
+      lastItemResult = itemResult;
+      let updatedContent;
+      try {
+        updatedContent = args.readFileSync(phasePath);
+      } catch {
+        updatedContent = phaseContent;
+      }
+      const updatedItems = parseItems(updatedContent);
+      const matched = updatedItems.find((u) => u.id === item.id);
+      if (matched && !matched.checked) {
+        log.warn(
+          { phase: phaseFile, itemId: item.id },
+          "item completed iteration without marking its checkbox"
+        );
+      }
+      if (!SUCCESS_REASONS.has(itemResult.exitReason)) {
+        return {
+          ...itemResult,
+          iterations: cumulativeIterations,
+          cumulativeCostUsd: cumulativeCost,
+          message: `Item ${item.id} failed: ${itemResult.message}`
+        };
+      }
+      if (args.verifyConfig?.strategy === "after_item" && item.verify?.trim()) {
+        const itemVerifyResult = await _runVerifyCommands([item], runCwd, {
+          timeoutMs: args.verifyConfig.timeoutMs
+        });
+        if (itemVerifyResult.length > 0 && !itemVerifyResult[0].passed) {
+          const failed = itemVerifyResult[0];
+          log.warn(
+            {
+              phase: phaseFile,
+              itemId: failed.itemId,
+              command: failed.command,
+              stderr: failed.stderr.slice(0, 500)
+            },
+            "per-item verify failed"
+          );
+          if (useYamlSpec && args.planPath) {
+            markItemUnchecked(args.planPath, phaseFile, item.id);
+            args.logger?.root.child({ component: "autopilot.per-item-verify" }).warn(
+              { phase: phaseFile, itemId: item.id },
+              "unchecked item that failed verify \u2014 will retry next iteration"
+            );
+          } else if (args.writeFileSync) {
+            const currentPhaseContent = args.readFileSync(phasePath);
+            const uncheckContent = uncheckItemsInMarkdown(currentPhaseContent, [item.id]);
+            if (uncheckContent !== currentPhaseContent) {
+              args.writeFileSync(phasePath, uncheckContent);
+              args.logger?.root.child({ component: "autopilot.per-item-verify" }).warn(
+                { phase: phaseFile, itemId: item.id },
+                "unchecked item that failed verify \u2014 will retry next iteration"
+              );
+            }
+          }
+          if (args.verifyConfig.retryOnFailure) {
+            return {
+              exitReason: "sentinel",
+              iterations: cumulativeIterations,
+              cumulativeCostUsd: cumulativeCost,
+              message: `Item ${item.id} verify failed: ${failed.stderr.split("\n")[0]}`
+            };
+          }
+        }
+      }
+    }
+    return {
+      ...lastItemResult,
+      iterations: cumulativeIterations,
+      cumulativeCostUsd: cumulativeCost,
+      message: `${items.length} items completed in ${cumulativeIterations} iterations`
+    };
+  };
+  const runPhaseInner = async (phaseFile, laneId, runCwd, retryContext) => {
+    let verifyFailureSummary;
+    const phasePath = useYamlSpec ? path7.join(opts.planPath, "spec", phaseFile) : path7.join(opts.planPath, phaseFile);
+    const phaseContent = _readFileSync(phasePath);
+    const preHeadSha = await recordHead(runCwd);
+    log.info(
+      { phase: phaseFile, lane: laneId, current: phasesCompleted + 1, total: uncheckedPhases.length },
+      "starting phase"
+    );
+    emitter?.emitEvent({
+      type: "phase:start",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      phase: phaseFile,
+      laneId,
+      current: phasesCompleted + 1,
+      total: uncheckedPhases.length
+    });
+    const phaseName = phaseFile.replace(/\.(md|ya?ml)$/, "");
+    const phaseConfig = resolvePhaseConfig(
+      opts.config,
+      phaseName
+    );
+    const phaseOcAdapter = phaseConfig.adapters?.opencode;
+    const baseAdapters = opts.config?.adapters;
+    const baseOcAdapter = baseAdapters?.opencode;
+    const phaseAgentOverrides = phaseOcAdapter?.agents ?? baseOcAdapter?.agents;
+    let result;
+    const phaseVerifyConfig = extractVerifyConfig(phaseConfig);
+    if (opts.fast) {
+      result = await runItemsForPhase({
+        phaseFile,
+        phasePath,
+        laneId,
+        runCwd,
+        runRalphLoop: _runRalphLoop,
+        readFileSync: _readFileSync,
+        writeFileSync: _writeFileSync,
+        planPath: opts.planPath,
+        useParallel,
+        stallMs,
+        logger: opts.logger,
+        emitter,
+        adapter: opts.adapter,
+        config: opts.config,
+        agentOverrides: phaseAgentOverrides,
+        verifyConfig: phaseVerifyConfig
+      });
+    } else {
+      const retrySection = retryContext ? `
+
+## Previous attempt failed
+The previous attempt at this phase failed verification. Here's what went wrong:
+${retryContext}
+
+Fix these failures before marking items as complete.
+` : "";
+      const prompt = `You are executing one phase of a multi-file plan. Work through every unchecked item in order. Check each box as you complete it. Commit when the phase is done.
+
+## Overall goal
+${goal}
+
+## Constraints
+${constraints}
+
+## Your phase (${phaseFile})
+${phaseContent}
+` + retrySection + `
+Do not work on items from other phases. Do not ask questions \u2014 pick sensible defaults and note decisions in ## Open questions.`;
+      const adapterName = opts.adapter?.name;
+      const cfgObj2 = opts.config;
+      const models = cfgObj2?.models;
+      const executionSpecifier = models?.execution;
+      const executionModel = executionSpecifier ? resolveModel(executionSpecifier, adapterName ?? "opencode") : void 0;
+      result = await _runRalphLoop({
+        prompt,
+        cwd: runCwd,
+        agentName: void 0,
+        model: executionModel,
+        maxIterations: maxIterationsPerPhase,
+        stallMs,
+        config: opts.config,
+        agentOverrides: phaseAgentOverrides,
+        laneId: useParallel ? laneId : void 0,
+        logger: opts.logger,
+        emitter,
+        adapter: opts.adapter
+      });
+    }
+    totalIterations += result.iterations;
+    const costThisPhase = result.cumulativeCostUsd ?? 0;
+    totalCostUsd += costThisPhase;
+    laneCosts.set(laneId, (laneCosts.get(laneId) ?? 0) + costThisPhase);
+    lastResult = result;
+    const updatedPhaseContent = _readFileSync(phasePath);
+    let phaseComplete = useYamlSpec ? (() => {
+      const yamlItems = parseSpecItems(phasePath);
+      const checkedCount = yamlItems.filter((i) => i.checked).length;
+      log.info(
+        { phase: phaseFile, total: yamlItems.length, checked: checkedCount },
+        `phase completion check: ${checkedCount}/${yamlItems.length} items checked`
+      );
+      return yamlItems.length > 0 && yamlItems.every((i) => i.checked);
+    })() : isPhaseComplete(updatedPhaseContent);
+    const verifyConfig2 = extractVerifyConfig(opts.config);
+    const shouldSkipVerify = verifyConfig2.strategy === "skip";
+    const isAfterItemMode = verifyConfig2.strategy === "after_item" && opts.fast;
+    if (phaseComplete && !shouldSkipVerify && !isAfterItemMode) {
+      const items = useYamlSpec ? parseSpecItems(phasePath) : parseItems(updatedPhaseContent);
+      const itemsWithVerify = items.filter((it) => it.verify?.trim());
+      if (itemsWithVerify.length > 0) {
+        log.info(
+          { phase: phaseFile, count: itemsWithVerify.length },
+          "running verify commands"
+        );
+        emitter?.emitEvent({
+          type: "verify:start",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          phase: phaseFile,
+          itemCount: itemsWithVerify.length
+        });
+        const phaseVerify = await _runVerifyCommands(itemsWithVerify, runCwd, {
+          timeoutMs: verifyConfig2.timeoutMs
+        });
+        verifyResults.push({ phaseFile, results: phaseVerify });
+        const failed = phaseVerify.filter((r) => !r.passed);
+        for (const r of phaseVerify) {
+          emitter?.emitEvent({
+            type: "verify:result",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            phase: phaseFile,
+            itemId: r.itemId,
+            command: r.command,
+            passed: r.passed,
+            ...r.stderr ? { stderr: r.stderr.slice(0, 500) } : {}
+          });
+        }
+        if (failed.length > 0) {
+          const failedItemIds = failed.map((f) => f.itemId);
+          for (const f of failed) {
+            log.warn(
+              {
+                phase: phaseFile,
+                itemId: f.itemId,
+                command: f.command,
+                stderr: f.stderr.slice(0, 500)
+              },
+              "verify command failed"
+            );
+          }
+          for (const itemId of failedItemIds) {
+            if (useYamlSpec) {
+              markItemUnchecked(opts.planPath, phaseFile, itemId);
+            } else {
+              const uncheckContent = uncheckItemsInMarkdown(updatedPhaseContent, [itemId]);
+              if (uncheckContent !== updatedPhaseContent) {
+                _writeFileSync(phasePath, uncheckContent);
+                log.warn(
+                  { phase: phaseFile, itemId },
+                  "unchecked item that failed verify \u2014 will retry next iteration"
+                );
+              }
+            }
+          }
+          phaseComplete = false;
+          verifyFailureSummary = failed.map((f) => `- \`${f.command}\` failed (item ${f.itemId}): ${f.stderr.split("\n").slice(-3).join(" ").slice(0, 200)}`).join("\n");
+        } else {
+          log.info(
+            { phase: phaseFile, passed: phaseVerify.length },
+            "all verify commands passed"
+          );
+        }
+        emitter?.emitEvent({
+          type: "verify:done",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          phase: phaseFile,
+          passed: phaseVerify.filter((r) => r.passed).length,
+          failed: failed.length
+        });
+      }
+    }
+    if (!phaseComplete && !SUCCESS_REASONS.has(result.exitReason)) {
+      log.warn({ phase: phaseFile, exitReason: result.exitReason }, "phase failed");
+      const rollbackConfig = cfgObj?.rollback_on_failure ?? "soft";
+      if (rollbackConfig !== "off" && opts.fast && preHeadSha && preHeadSha !== "HEAD") {
+        const ok = await resetSoft(runCwd, preHeadSha, {
+          onWarn: (m) => log.warn(m)
+        });
+        if (ok) {
+          log.info({ ref: preHeadSha.slice(0, 8) }, "soft-reset to pre-phase state");
+        }
+      } else if (rollbackConfig === "off" && opts.fast && preHeadSha && preHeadSha !== "HEAD") {
+        log.info({ ref: preHeadSha.slice(0, 8) }, "rollback disabled by config \u2014 keeping phase changes");
+      }
+      emitter?.emitEvent({
+        type: "phase:done",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        phase: phaseFile,
+        laneId,
+        completed: false,
+        iterations: result.iterations,
+        costUsd: costThisPhase
+      });
+      const phaseHooksConfig = extractHooksConfig(phaseConfig);
+      const effectiveOnErrorHook = phaseHooksConfig.on_error ?? hooksConfig.on_error;
+      if (effectiveOnErrorHook) {
+        runHook(effectiveOnErrorHook, runCwd, verifyConfig2.timeoutMs).catch(() => {
+        });
+      }
+      return {
+        phaseFile,
+        laneId,
+        ok: false,
+        fatal: true,
+        iterations: result.iterations,
+        costUsd: costThisPhase,
+        phaseLoopResult: result,
+        phaseComplete: false
+      };
+    }
+    if (!phaseComplete && result.exitReason === "max-iterations") {
+      log.warn(
+        { phase: phaseFile, max: maxIterationsPerPhase },
+        "phase budget exhausted \u2014 moving on"
+      );
+      const checkpointEnabled = cfgObj?.checkpoint !== false;
+      if (checkpointEnabled) {
+        writeCheckpoint(opts.cwd, {
+          planPath: opts.planPath,
+          completedPhases: [...completedPhasesAcc],
+          totalCostUsd,
+          totalIterations,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+    emitter?.emitEvent({
+      type: "phase:done",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      phase: phaseFile,
+      laneId,
+      completed: phaseComplete,
+      iterations: result.iterations,
+      costUsd: costThisPhase
+    });
+    return {
+      phaseFile,
+      laneId,
+      ok: phaseComplete,
+      fatal: false,
+      iterations: result.iterations,
+      costUsd: costThisPhase,
+      phaseLoopResult: result,
+      phaseComplete,
+      verifyFailures: verifyFailureSummary
+    };
+  };
+  const recordPhaseCompletion = async (phaseFile, result, phaseHooksConfig) => {
+    phasesCompleted++;
+    completedPhasesAcc.push(phaseFile);
+    if (useYamlSpec) {
+      markPhaseCompleted(opts.planPath, phaseFile);
+    } else {
+      const updatedMain = markPhaseChecked(_readFileSync(mainMdPath), phaseFile);
+      _writeFileSync(mainMdPath, updatedMain);
+    }
+    const checkpointEnabled = cfgObj?.checkpoint !== false;
+    if (checkpointEnabled) {
+      writeCheckpoint(opts.cwd, {
+        planPath: opts.planPath,
+        completedPhases: [...completedPhasesAcc],
+        totalCostUsd,
+        totalIterations,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    log.info(
+      {
+        phase: phaseFile,
+        completed: phasesCompleted,
+        total: uncheckedPhases.length,
+        iterations: result.iterations,
+        cost: (result.cumulativeCostUsd ?? 0).toFixed(2)
+      },
+      "phase complete"
+    );
+    const effectivePostPhaseHook = phaseHooksConfig?.post_phase ?? hooksConfig.post_phase;
+    if (effectivePostPhaseHook) {
+      const hookResult = await runHook(effectivePostPhaseHook, opts.cwd, verifyConfig.timeoutMs);
+      if (!hookResult.ok) {
+        log.warn({ phase: phaseFile, output: hookResult.output }, "post_phase hook failed");
+      }
+    }
+  };
+  if (!useParallel) {
+    for (const phaseFile of uncheckedPhases) {
+      if (opts.signal?.aborted) {
+        log.info({ completed: phasesCompleted, remaining: uncheckedPhases.length }, "abort signal received \u2014 writing checkpoint and stopping");
+        const checkpointEnabled = cfgObj?.checkpoint !== false;
+        if (checkpointEnabled) {
+          writeCheckpoint(opts.cwd, {
+            planPath: opts.planPath,
+            completedPhases: [...completedPhasesAcc],
+            totalCostUsd,
+            totalIterations,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        return {
+          exitReason: "aborted",
+          iterations: totalIterations,
+          cumulativeCostUsd: totalCostUsd,
+          message: `Aborted after ${phasesCompleted}/${uncheckedPhases.length} phases completed`
+        };
+      }
+      const phaseName = phaseFile.replace(/\.(md|ya?ml)$/, "");
+      const phaseConfig = resolvePhaseConfig(
+        opts.config,
+        phaseName
+      );
+      const phaseHooksConfig = extractHooksConfig(phaseConfig);
+      const verifyRetryConfig = extractVerifyConfig(opts.config);
+      const effectiveMaxRetries = verifyRetryConfig.retryOnFailure ? opts.maxPhaseRetries ?? (opts._deps ? 1 : 3) : 1;
+      let attempt = 0;
+      let phaseSuccess = false;
+      let lastVerifyFailures;
+      while (attempt < effectiveMaxRetries && !phaseSuccess) {
+        attempt++;
+        const isEscalation = attempt === effectiveMaxRetries && attempt > 1 && opts.fast;
+        if (attempt > 1) {
+          log.info(
+            { phase: phaseFile, attempt, escalate: isEscalation },
+            isEscalation ? "escalating to deep model for retry" : "retrying phase after verify failure"
+          );
+          emitter?.emitEvent({
+            type: "phase:start",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            phase: `${phaseFile} (${isEscalation ? "escalation" : `retry ${attempt - 1}`})`,
+            laneId: "lane-1",
+            current: phasesCompleted + 1,
+            total: uncheckedPhases.length
+          });
+        }
+        const originalFast = opts.fast;
+        if (isEscalation) {
+          opts.fast = false;
+        }
+        const effectivePrePhaseHook = phaseHooksConfig.pre_phase ?? hooksConfig.pre_phase;
+        if (effectivePrePhaseHook) {
+          const hookResult = await runHook(effectivePrePhaseHook, opts.cwd, verifyConfig.timeoutMs);
+          if (!hookResult.ok) {
+            log.warn({ phase: phaseFile, output: hookResult.output }, "pre_phase hook failed \u2014 skipping phase");
+            if (isEscalation) {
+              opts.fast = originalFast;
+            }
+            phaseSuccess = false;
+            continue;
+          }
+        }
+        const r = await runPhaseInner(phaseFile, "lane-1", opts.cwd, lastVerifyFailures);
+        if (isEscalation) {
+          opts.fast = originalFast;
+        }
+        lastVerifyFailures = r.verifyFailures;
+        if (r.phaseComplete) {
+          await recordPhaseCompletion(phaseFile, r.phaseLoopResult, phaseHooksConfig);
+          phaseSuccess = true;
+          break;
+        }
+        if (r.fatal) {
+          return {
+            ...r.phaseLoopResult,
+            iterations: totalIterations,
+            cumulativeCostUsd: totalCostUsd,
+            message: `${r.phaseLoopResult.message} (phase ${phaseFile}, ${phasesCompleted}/${uncheckedPhases.length} phases completed, total $${totalCostUsd.toFixed(2)})`
+          };
+        }
+        if (attempt >= effectiveMaxRetries) {
+          log.warn({ phase: phaseFile, attempts: attempt }, "phase exhausted retries \u2014 moving on");
+        }
+      }
+    }
+  } else {
+    const handles = /* @__PURE__ */ new Map();
+    const wtLogger = {
+      warn: (obj, msg) => log.warn(obj, msg),
+      info: (obj, msg) => log.info(obj, msg)
+    };
+    const { execFileSync } = await import("child_process");
+    const exitCleanup = () => {
+      for (const handle of handles.values()) {
+        try {
+          execFileSync("git", ["worktree", "remove", "--force", handle.path], {
+            cwd: opts.cwd,
+            stdio: "ignore"
+          });
+        } catch {
+        }
+        try {
+          execFileSync("git", ["branch", "-D", handle.branch], {
+            cwd: opts.cwd,
+            stdio: "ignore"
+          });
+        } catch {
+        }
+      }
+    };
+    process.on("exit", exitCleanup);
+    try {
+      const lanesResult = await runLanes({
+        phases: uncheckedPhases,
+        conflictGraph,
+        laneCount: requestedLanes,
+        logger: wtLogger,
+        runPhase: async (phaseFile, laneId) => {
+          const slug = phaseFile.replace(/\.md$/, "").replace(/[^a-zA-Z0-9_-]/g, "_");
+          let handle = null;
+          try {
+            handle = await createWorktree(opts.cwd, {
+              laneSlug: `${slug}-${laneId}`,
+              logger: wtLogger
+            });
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.warn({ phase: phaseFile, err: msg }, "worktree create failed \u2014 falling back to main cwd");
+          }
+          const runCwd = handle?.path ?? opts.cwd;
+          const phaseName = phaseFile.replace(/\.(md|ya?ml)$/, "");
+          const phaseConfig = resolvePhaseConfig(
+            opts.config,
+            phaseName
+          );
+          const phaseHooksConfig = extractHooksConfig(phaseConfig);
+          const effectivePrePhaseHook = phaseHooksConfig.pre_phase ?? hooksConfig.pre_phase;
+          if (effectivePrePhaseHook) {
+            const hookResult = await runHook(effectivePrePhaseHook, runCwd, verifyConfig.timeoutMs);
+            if (!hookResult.ok) {
+              log.warn({ phase: phaseFile, output: hookResult.output }, "pre_phase hook failed \u2014 skipping phase");
+              return {
+                phaseFile,
+                laneId,
+                ok: false,
+                fatal: false,
+                iterations: 0,
+                costUsd: 0,
+                phaseLoopResult: {
+                  exitReason: "error",
+                  iterations: 0,
+                  message: "pre_phase hook failed"
+                },
+                phaseComplete: false
+              };
+            }
+          }
+          const result = await runPhaseInner(phaseFile, laneId, runCwd);
+          if (handle) {
+            handles.set(phaseFile, handle);
+            if (result.phaseComplete) {
+              const merge = await mergeWorktree(opts.cwd, { branch: handle.branch });
+              if (merge.ok) {
+                await handle.cleanup().catch(() => {
+                });
+                handles.delete(phaseFile);
+              } else {
+                log.warn(
+                  { phase: phaseFile, conflicts: merge.conflicts, path: handle.path },
+                  "merge failed \u2014 worktree left on disk for manual resolution"
+                );
+                orphanedWorktrees.push(handle.path);
+                return { ...result, ok: false, fatal: true };
+              }
+            } else {
+              await handle.cleanup().catch(() => {
+              });
+              handles.delete(phaseFile);
+            }
+          }
+          return result;
+        }
+      });
+      for (const r of lanesResult.results) {
+        if (r.ok) {
+          const phaseName = r.phaseFile.replace(/\.(md|ya?ml)$/, "");
+          const phaseConfig = resolvePhaseConfig(
+            opts.config,
+            phaseName
+          );
+          const phaseHooksConfig = extractHooksConfig(phaseConfig);
+          await recordPhaseCompletion(r.phaseFile, {
+            exitReason: "sentinel",
+            iterations: r.iterations,
+            message: "completed via parallel lane",
+            cumulativeCostUsd: r.costUsd
+          }, phaseHooksConfig);
+        }
+      }
+      const fatalResult = lanesResult.results.find((r) => r.fatal);
+      if (fatalResult) {
+        return {
+          ...lastResult,
+          iterations: totalIterations,
+          cumulativeCostUsd: totalCostUsd,
+          laneCosts,
+          ...orphanedWorktrees.length > 0 ? { orphanedWorktrees } : {},
+          ...verifyResults.length > 0 ? { verifyResults } : {},
+          message: `${lastResult.message} (phase ${fatalResult.phaseFile}, ${phasesCompleted}/${uncheckedPhases.length} phases completed, total $${totalCostUsd.toFixed(2)})`
+        };
+      }
+    } finally {
+      for (const [phaseFile, handle] of handles) {
+        await handle.cleanup().catch((err) => {
+          log.warn(
+            { phase: phaseFile, err: err instanceof Error ? err.message : String(err) },
+            "worktree cleanup failed"
+          );
+        });
+      }
+      process.removeListener("exit", exitCleanup);
+    }
+  }
+  if (!useYamlSpec) {
+    const finalMainContent = _readFileSync(mainMdPath);
+    const mainHasUnchecked = /^- \[ \]\s+id:/m.test(finalMainContent);
+    if (mainHasUnchecked) {
+      log.info("starting cross-cutting items");
+      const crossCuttingPrompt = `You are executing the cross-cutting acceptance criteria from a multi-file plan's main.md. All phase files are complete. Work through every unchecked item (id: x1, x2, etc.) in main.md. Check each box as you complete it. Commit when done.
+
+## Overall goal
+${goal}
+
+## Constraints
+${constraints}
+
+## main.md
+${finalMainContent}
+
+Only work on the unchecked items in main.md's acceptance criteria. Phase items are already done. Do not ask questions.`;
+      const adapterName = opts.adapter?.name;
+      const cfgObj2 = opts.config;
+      const models = cfgObj2?.models;
+      const executionSpecifier = models?.execution;
+      const executionModel = executionSpecifier ? resolveModel(executionSpecifier, adapterName ?? "opencode") : void 0;
+      const crossAdapters = opts.config?.adapters;
+      const crossOcAdapter = crossAdapters?.opencode;
+      const crossCuttingAgentOverrides = crossOcAdapter?.agents;
+      const crossResult = await _runRalphLoop({
+        prompt: crossCuttingPrompt,
+        cwd: opts.cwd,
+        agentName: opts.fast ? "autopilot-fast" : void 0,
+        model: executionModel,
+        stallMs,
+        config: opts.config,
+        agentOverrides: crossCuttingAgentOverrides,
+        logger: opts.logger,
+        emitter,
+        adapter: opts.adapter
+      });
+      totalIterations += crossResult.iterations;
+      totalCostUsd += crossResult.cumulativeCostUsd ?? 0;
+      lastResult = crossResult;
+    }
+  }
+  log.info({ completed: phasesCompleted, total: uncheckedPhases.length, iterations: totalIterations, cost: totalCostUsd.toFixed(2) }, "all phases done");
+  if (hooksConfig.post_run) {
+    const hookResult = await runHook(hooksConfig.post_run, opts.cwd, verifyConfig.timeoutMs);
+    if (!hookResult.ok) {
+      log.warn({ output: hookResult.output }, "post_run hook failed");
+    }
+  }
+  deleteCheckpoint(opts.cwd);
+  let changesetPath;
+  const changesetEnabled = cfgObj?.changeset !== false;
+  if (changesetEnabled && !opts._deps && phasesCompleted === uncheckedPhases.length && uncheckedPhases.length > 0) {
+    try {
+      const { generateChangeset } = await import("./changeset-generator-HAHYSSUR.js");
+      const changesetOpts = {
+        packageName: cfgObj?.changeset_package,
+        bumpLevel: cfgObj?.changeset_bump
+      };
+      const cs = await generateChangeset(opts.planPath, opts.cwd, changesetOpts);
+      changesetPath = cs.path;
+      log.info(
+        { path: cs.path, bumpLevel: cs.bumpLevel },
+        "changeset generated"
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log.warn({ err: msg }, "changeset generation failed");
+    }
+  }
+  let prUrl;
+  if (!opts._deps && opts.ship && phasesCompleted === uncheckedPhases.length && uncheckedPhases.length > 0) {
+    try {
+      const { autoShip } = await import("./auto-ship-EVLBKHUZ.js");
+      const shipResult = await autoShip({
+        planPath: opts.planPath,
+        repoRoot: opts.cwd
+      });
+      prUrl = shipResult.prUrl;
+      log.info({ prUrl }, "PR opened");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log.warn({ err: msg }, "auto-ship failed \u2014 run /ship to finalize manually");
+    }
+  } else if (!opts._deps && !opts.ship && phasesCompleted === uncheckedPhases.length && uncheckedPhases.length > 0) {
+    log.info("all phases complete, run `/ship` to finalize");
+  }
+  return {
+    ...lastResult,
+    iterations: totalIterations,
+    cumulativeCostUsd: totalCostUsd,
+    // Per-lane breakdown (item 3.5) — only included when more than one
+    // lane was used so sequential runs don't see noise in the debrief.
+    ...laneCosts.size > 1 ? { laneCosts } : {},
+    // Surviving worktrees (item 3.6) — surfaced for manual cleanup.
+    ...orphanedWorktrees.length > 0 ? { orphanedWorktrees } : {},
+    // Per-phase verify results (item 4.1) — surfaced for the debrief.
+    ...verifyResults.length > 0 ? { verifyResults } : {},
+    // Changeset path (item 4.6) and PR url (item 4.7).
+    ...changesetPath ? { changesetPath } : {},
+    ...prUrl ? { prUrl } : {},
+    message: prUrl ? `${phasesCompleted}/${uncheckedPhases.length} phases completed in ${totalIterations} iterations, total $${totalCostUsd.toFixed(2)}, PR: ${prUrl}` : `${phasesCompleted}/${uncheckedPhases.length} phases completed in ${totalIterations} iterations, total $${totalCostUsd.toFixed(2)}`
+  };
+}
+
+export {
+  formatElapsed,
+  formatCost,
+  createStatusHeartbeat,
+  parsePlanState,
+  parseItems,
+  validateScope,
+  getChangedFiles,
+  MAX_ITERATIONS,
+  STRUGGLE_THRESHOLD,
+  TIMEOUT_MS,
+  STALL_MS_BY_TIER,
+  STALL_MS,
+  MAX_ITERATIONS_PER_PHASE_BY_TIER,
+  STATUS_INTERVAL_MS,
+  detectSentinel,
+  StruggleDetector,
+  checkKillSwitch,
+  writeCheckpoint,
+  readCheckpoint,
+  deleteCheckpoint,
+  runRalphLoop,
+  recordHead,
+  resetSoft,
+  markPhaseCompleted,
+  buildConflictGraph,
+  hasParallelism,
+  runLanes,
+  createWorktree,
+  mergeWorktree,
+  runVerifyCommands,
+  validatePlan,
+  runLoopSession
+};