@glrs-dev/harness-plugin-opencode 0.3.1 → 1.0.1

package/dist/cli.js

@@ -3,23 +3,64 @@ import {
   createAgents,
   validateModelOverride
 } from "./chunk-CZMAJISX.js";
+import {
+  getSessionsPath,
+  registerSession,
+  unregisterSession
+} from "./chunk-RNRCXQ65.js";
 import {
   install,
   requirePlugin
 } from "./chunk-WBBN7OVN.js";
 import "./chunk-VJUETC6A.js";
+import {
+  getPilotDir,
+  getPlanDir,
+  getPlansDir,
+  getRunDir,
+  getStateDbPath,
+  getTaskJsonlPath,
+  getWorkerJsonlPath,
+  migratePlans,
+  resolveBaseDir
+} from "./chunk-BKTFWXLG.js";
+import {
+  createRun,
+  getRun,
+  markRunFinished,
+  markRunResumed,
+  markRunRunning
+} from "./chunk-5TAMY7P6.js";
+import {
+  countByStatus,
+  getTask,
+  listTasks,
+  markAborted,
+  markBlocked,
+  markFailed,
+  markReady,
+  markRunning,
+  markSucceeded,
+  resetTasksForResume,
+  setCostUsd,
+  upsertFromPlan
+} from "./chunk-57EOY72Y.js";
+import {
+  checkCwdSafety,
+  headSha
+} from "./chunk-KB7M7JXU.js";
 
 // src/cli.ts
 import {
   binary,
-  command as command11,
-  flag as flag8,
-  option as option9,
-  optional as optional10,
-  positional as positional6,
+  command as command9,
+  flag as flag7,
+  option as option7,
+  optional as optional8,
+  positional as positional5,
   restPositionals,
-  string as string10,
-  subcommands as subcommands3,
+  string as string8,
+  subcommands as subcommands2,
   run
 } from "cmd-ts";
 
@@ -115,9 +156,9 @@ function getOpencodeConfigPath2() {
   const configHome = process.env["XDG_CONFIG_HOME"] ?? path2.join(os2.homedir(), ".config");
   return path2.join(configHome, "opencode", "opencode.json");
 }
-function cmd(command12) {
+function cmd(command10) {
   try {
-    return execSync(command12, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    return execSync(command10, { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] }).trim();
   } catch {
     return null;
   }
@@ -328,132 +369,17 @@ function planCheck(args) {
   }
 }
 
-// src/plan-paths.ts
-import { execFile } from "child_process";
-import * as fs3 from "fs/promises";
-import * as os3 from "os";
-import * as path3 from "path";
-function execFileP(file, args, opts = {}) {
-  const { cwd, timeoutMs = 5e3 } = opts;
-  return new Promise((resolve5, reject) => {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    execFile(
-      file,
-      args,
-      { signal: controller.signal, cwd, encoding: "utf8" },
-      (err, stdout) => {
-        clearTimeout(timer);
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve5(stdout ?? "");
-      }
-    );
-  });
-}
-function expandTilde(p) {
-  if (p === "~") return os3.homedir();
-  if (p.startsWith("~/")) return path3.join(os3.homedir(), p.slice(2));
-  return p;
-}
-async function getRepoFolder(worktreeDir) {
-  let stdout;
-  try {
-    stdout = await execFileP(
-      "git",
-      ["rev-parse", "--git-common-dir"],
-      { cwd: worktreeDir }
-    );
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : "unknown error running `git rev-parse --git-common-dir`";
-    throw new Error(
-      `getRepoFolder: failed to resolve git-common-dir for ${worktreeDir}: ${msg}`
-    );
-  }
-  const gitCommonDir = stdout.trim();
-  if (!gitCommonDir) {
-    throw new Error(
-      `getRepoFolder: \`git rev-parse --git-common-dir\` returned empty for ${worktreeDir}`
-    );
-  }
-  const absCommonDir = path3.isAbsolute(gitCommonDir) ? gitCommonDir : path3.resolve(worktreeDir, gitCommonDir);
-  const repoRoot = path3.dirname(absCommonDir);
-  return path3.basename(repoRoot);
-}
-async function getPlanDir(worktreeDir) {
-  const override = process.env.GLORIOUS_PLAN_DIR;
-  const base = override ? expandTilde(override) : path3.join(os3.homedir(), ".glorious", "opencode");
-  const repoFolder = await getRepoFolder(worktreeDir);
-  const planDir = path3.join(base, repoFolder, "plans");
-  await fs3.mkdir(planDir, { recursive: true });
-  return planDir;
-}
-async function migratePlans(worktreeDir, planDir) {
-  const oldDir = path3.join(worktreeDir, ".agent", "plans");
-  const marker = path3.join(oldDir, ".migrated");
-  try {
-    await fs3.stat(oldDir);
-  } catch {
-    return;
-  }
-  try {
-    await fs3.stat(marker);
-    return;
-  } catch {
-  }
-  let entries;
-  try {
-    entries = await fs3.readdir(oldDir);
-  } catch {
-    return;
-  }
-  const planFiles = entries.filter(
-    (name) => name.endsWith(".md") && !name.startsWith(".")
-  );
-  await fs3.mkdir(planDir, { recursive: true });
-  for (const name of planFiles) {
-    const src = path3.join(oldDir, name);
-    const dst = path3.join(planDir, name);
-    let dstExists = false;
-    try {
-      await fs3.stat(dst);
-      dstExists = true;
-    } catch {
-      dstExists = false;
-    }
-    if (!dstExists) {
-      await fs3.rename(src, dst);
-      continue;
-    }
-    const [srcBuf, dstBuf] = await Promise.all([
-      fs3.readFile(src),
-      fs3.readFile(dst)
-    ]);
-    if (srcBuf.equals(dstBuf)) {
-      await fs3.unlink(src);
-      continue;
-    }
-    process.stderr.write(
-      `[harness-opencode] migratePlans: conflict on ${name} \u2014 destination ${dst} exists with different content; leaving source ${src} in place. Resolve manually.
-`
-    );
-  }
-  await fs3.writeFile(marker, "");
-}
-
 // src/pilot/cli/index.ts
-import { subcommands as subcommands2 } from "cmd-ts";
+import { subcommands } from "cmd-ts";
 
 // src/pilot/cli/validate.ts
 import { command, optional, positional, string, flag } from "cmd-ts";
-import { promises as fs6 } from "fs";
-import * as path6 from "path";
-
-// src/pilot/plan/load.ts
 import { promises as fs4 } from "fs";
 import * as path4 from "path";
+
+// src/pilot/plan/load.ts
+import { promises as fs3 } from "fs";
+import * as path3 from "path";
 import { parse as parseYaml, YAMLParseError } from "yaml";
 
 // src/pilot/plan/schema.ts
@@ -496,6 +422,7 @@ var TaskSchema = z.object({
   prompt: z.string().min(1, "task prompt must be non-empty"),
   context: z.string().optional(),
   touches: TouchesSchema.default([]),
+  tolerate: TouchesSchema.default([]),
   verify: z.array(VerifyCommandSchema).default([]),
   depends_on: z.array(z.string().regex(TASK_ID_PATTERN, "depends_on entries must be valid task IDs")).default([]),
   agent: z.string().min(1).optional(),
@@ -514,9 +441,34 @@ var PlanSchema = z.object({
   branch_prefix: z.string().min(1).optional(),
   defaults: DefaultsSchema,
   milestones: z.array(MilestoneSchema).default([]),
-  setup: z.array(VerifyCommandSchema).default([]),
   tasks: z.array(TaskSchema).min(1, "plan must declare at least one task")
-}).strict();
+}).passthrough().superRefine((val, ctx) => {
+  const known = /* @__PURE__ */ new Set([
+    "name",
+    "branch_prefix",
+    "defaults",
+    "milestones",
+    "tasks"
+  ]);
+  if (typeof val !== "object" || val === null) return;
+  const v = val;
+  for (const key of Object.keys(v)) {
+    if (known.has(key)) continue;
+    if (key === "setup") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["setup"],
+        message: "The 'setup:' field was removed in the cwd-mode rollback. Run setup commands manually before 'pilot build' \u2014 see src/pilot/AGENTS.md for the new contract."
+      });
+    } else {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [key],
+        message: `Unrecognized key: ${JSON.stringify(key)}`
+      });
+    }
+  }
+});
 function parsePlan(input) {
   const result = PlanSchema.safeParse(input);
   if (result.success) {
@@ -547,10 +499,10 @@ async function loadPlan(absPath) {
   if (typeof absPath !== "string") {
     throw new TypeError(`loadPlan: expected string path, got ${typeof absPath}`);
   }
-  const resolved = path4.resolve(absPath);
+  const resolved = path3.resolve(absPath);
   let raw;
   try {
-    raw = await fs4.readFile(resolved, "utf8");
+    raw = await fs3.readFile(resolved, "utf8");
   } catch (err) {
     return {
       ok: false,
@@ -804,98 +756,6 @@ function findTouchConflicts(tasks) {
   return conflicts;
 }
 
-// src/pilot/paths.ts
-import { promises as fs5 } from "fs";
-import * as os4 from "os";
-import * as path5 from "path";
-function expandTilde2(p) {
-  if (p === "~") return os4.homedir();
-  if (p.startsWith("~/")) return path5.join(os4.homedir(), p.slice(2));
-  return p;
-}
-function resolveBaseDir() {
-  const pilotEnv = process.env.GLORIOUS_PILOT_DIR;
-  if (pilotEnv) return expandTilde2(pilotEnv);
-  const planEnv = process.env.GLORIOUS_PLAN_DIR;
-  if (planEnv) {
-    return path5.dirname(expandTilde2(planEnv));
-  }
-  return path5.join(os4.homedir(), ".glorious", "opencode");
-}
-function padWorker(n) {
-  if (!Number.isInteger(n) || n < 0) {
-    throw new RangeError(`worker index must be a non-negative integer, got ${n}`);
-  }
-  return n.toString().padStart(2, "0");
-}
-async function getPilotDir(cwd) {
-  const base = resolveBaseDir();
-  const repoFolder = await getRepoFolder(cwd);
-  const dir = path5.join(base, repoFolder, "pilot");
-  await fs5.mkdir(dir, { recursive: true });
-  return dir;
-}
-async function getPlansDir(cwd) {
-  const pilot = await getPilotDir(cwd);
-  const dir = path5.join(pilot, "plans");
-  await fs5.mkdir(dir, { recursive: true });
-  return dir;
-}
-async function getRunDir(cwd, runId) {
-  if (!isSafeRunId(runId)) {
-    throw new Error(
-      `getRunDir: runId ${JSON.stringify(runId)} is not a safe filesystem segment`
-    );
-  }
-  const pilot = await getPilotDir(cwd);
-  const dir = path5.join(pilot, "runs", runId);
-  await fs5.mkdir(dir, { recursive: true });
-  return dir;
-}
-async function getWorktreeDir(cwd, runId, n) {
-  if (!isSafeRunId(runId)) {
-    throw new Error(
-      `getWorktreeDir: runId ${JSON.stringify(runId)} is not a safe filesystem segment`
-    );
-  }
-  const pilot = await getPilotDir(cwd);
-  const parent = path5.join(pilot, "worktrees", runId);
-  await fs5.mkdir(parent, { recursive: true });
-  return path5.join(parent, padWorker(n));
-}
-async function getStateDbPath(cwd, runId) {
-  const runDir = await getRunDir(cwd, runId);
-  return path5.join(runDir, "state.db");
-}
-async function getWorkerJsonlPath(cwd, runId, n) {
-  const runDir = await getRunDir(cwd, runId);
-  const workersDir = path5.join(runDir, "workers");
-  await fs5.mkdir(workersDir, { recursive: true });
-  return path5.join(workersDir, `${padWorker(n)}.jsonl`);
-}
-async function getTaskJsonlPath(cwd, runId, taskId) {
-  if (!isSafeRunId(runId)) {
-    throw new Error(
-      `getTaskJsonlPath: runId ${JSON.stringify(runId)} is not a safe filesystem segment`
-    );
-  }
-  if (!isSafeTaskId(taskId)) {
-    throw new Error(
-      `getTaskJsonlPath: taskId ${JSON.stringify(taskId)} is not a safe filesystem segment`
-    );
-  }
-  const runDir = await getRunDir(cwd, runId);
-  const taskDir = path5.join(runDir, "tasks", taskId);
-  await fs5.mkdir(taskDir, { recursive: true });
-  return path5.join(taskDir, "session.jsonl");
-}
-function isSafeRunId(runId) {
-  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(runId);
-}
-function isSafeTaskId(taskId) {
-  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(taskId);
-}
-
 // src/pilot/cli/validate.ts
 var validateCmd = command({
   name: "validate",
@@ -982,17 +842,17 @@ async function runValidate(opts) {
 }
 async function resolvePlanPath(input) {
   if (input !== void 0 && input.length > 0) {
-    const resolved = path6.resolve(input);
-    let stat2;
+    const resolved = path4.resolve(input);
+    let stat;
     try {
-      stat2 = await fs6.stat(resolved);
+      stat = await fs4.stat(resolved);
     } catch (err) {
       throw new Error(
         `cannot stat ${JSON.stringify(resolved)}: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    if (stat2.isFile()) return resolved;
-    if (stat2.isDirectory()) return findNewestYaml(resolved);
+    if (stat.isFile()) return resolved;
+    if (stat.isDirectory()) return findNewestYaml(resolved);
     throw new Error(
       `${JSON.stringify(resolved)} is neither a file nor a directory`
     );
@@ -1003,7 +863,7 @@ async function resolvePlanPath(input) {
 async function findNewestYaml(dir) {
   let entries;
   try {
-    entries = await fs6.readdir(dir);
+    entries = await fs4.readdir(dir);
   } catch (err) {
     throw new Error(
       `cannot read directory ${JSON.stringify(dir)}: ${err instanceof Error ? err.message : String(err)}`
@@ -1017,14 +877,14 @@ async function findNewestYaml(dir) {
   }
   let newest = null;
   for (const name of yamls) {
-    const full = path6.join(dir, name);
-    let stat2;
+    const full = path4.join(dir, name);
+    let stat;
     try {
-      stat2 = await fs6.stat(full);
+      stat = await fs4.stat(full);
     } catch {
       continue;
     }
-    const mtime = stat2.mtimeMs;
+    const mtime = stat.mtimeMs;
     if (newest === null || mtime > newest.mtime) {
       newest = { name, mtime };
     }
@@ -1032,14 +892,14 @@ async function findNewestYaml(dir) {
   if (newest === null) {
     throw new Error(`no readable *.yaml files in ${JSON.stringify(dir)}`);
   }
-  return path6.join(dir, newest.name);
+  return path4.join(dir, newest.name);
 }
 
 // src/pilot/cli/plan.ts
 import { command as command2, optional as optional2, positional as positional2, string as string2, option } from "cmd-ts";
 import { spawn } from "child_process";
-import { promises as fs7 } from "fs";
-import * as path7 from "path";
+import { promises as fs5 } from "fs";
+import * as path5 from "path";
 var PLANNER_AGENT = "pilot-planner";
 var planCmd = command2({
   name: "plan",
@@ -1133,15 +993,15 @@ async function snapshotYamls(dir) {
   const out = /* @__PURE__ */ new Map();
   let entries;
   try {
-    entries = await fs7.readdir(dir);
+    entries = await fs5.readdir(dir);
   } catch {
     return out;
   }
   for (const name of entries) {
     if (!name.endsWith(".yaml") && !name.endsWith(".yml")) continue;
-    const full = path7.join(dir, name);
+    const full = path5.join(dir, name);
     try {
-      const st = await fs7.stat(full);
+      const st = await fs5.stat(full);
       out.set(full, st.mtimeMs);
     } catch {
     }
@@ -1165,18 +1025,18 @@ function pickNewestNew(before, after) {
   return { path: pool[0].path, mtimeMs: pool[0].mtimeMs };
 }
 function spawnTui(args) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     const child = spawn(args.bin, args.args, {
       cwd: args.cwd,
       stdio: "inherit"
     });
-    child.on("exit", (code) => resolve5(code ?? 1));
+    child.on("exit", (code) => resolve6(code ?? 1));
     child.on("error", (err) => {
       process.stderr.write(
         `pilot plan: failed to spawn ${args.bin}: ${err.message}
 `
       );
-      resolve5(1);
+      resolve6(1);
     });
   });
 }
@@ -1191,7 +1051,7 @@ import {
   string as string3,
   number as cmdNumber
 } from "cmd-ts";
-import * as path9 from "path";
+import * as path7 from "path";
 
 // src/pilot/plan/slug.ts
 var MAX_SLUG_LENGTH = 50;
@@ -1378,18 +1238,18 @@ function splitStatements(sql) {
 }
 
 // src/pilot/state/db.ts
-function openStateDb(path13) {
-  const db = new Database(path13, { create: true });
+function openStateDb(path11) {
+  const db = new Database(path11, { create: true });
   try {
     db.run("PRAGMA foreign_keys = ON");
-    if (path13 !== ":memory:") {
+    if (path11 !== ":memory:") {
       db.run("PRAGMA journal_mode = WAL");
       db.run("PRAGMA synchronous = NORMAL");
     }
   } catch (err) {
     db.close();
     throw new Error(
-      `openStateDb: failed to set PRAGMAs on ${JSON.stringify(path13)}: ${err instanceof Error ? err.message : String(err)}`
+      `openStateDb: failed to set PRAGMAs on ${JSON.stringify(path11)}: ${err instanceof Error ? err.message : String(err)}`
     );
   }
   let newlyApplied;
@@ -1406,180 +1266,6 @@ function openStateDb(path13) {
   };
 }
 
-// src/pilot/state/runs.ts
-import { ulid } from "ulid";
-function createRun(db, args) {
-  const id = ulid();
-  const now = args.now ?? Date.now();
-  db.run(
-    `INSERT INTO runs (id, plan_path, plan_slug, started_at, status)
-     VALUES (?, ?, ?, ?, 'pending')`,
-    [id, args.planPath, args.slug, now]
-  );
-  void args.plan;
-  return id;
-}
-function markRunRunning(db, runId) {
-  const cur = getRun(db, runId);
-  if (!cur) throw new Error(`markRunRunning: run ${JSON.stringify(runId)} not found`);
-  if (cur.status === "running") return;
-  if (cur.status !== "pending") {
-    throw new Error(
-      `markRunRunning: cannot move run ${JSON.stringify(runId)} from ${cur.status} to running`
-    );
-  }
-  db.run("UPDATE runs SET status='running' WHERE id=?", [runId]);
-}
-function markRunFinished(db, runId, status, now = Date.now()) {
-  if (status !== "completed" && status !== "aborted" && status !== "failed") {
-    throw new Error(
-      `markRunFinished: ${JSON.stringify(status)} is not a terminal status`
-    );
-  }
-  const cur = getRun(db, runId);
-  if (!cur) {
-    throw new Error(`markRunFinished: run ${JSON.stringify(runId)} not found`);
-  }
-  db.run("UPDATE runs SET status=?, finished_at=? WHERE id=?", [status, now, runId]);
-}
-function getRun(db, runId) {
-  const row = db.query("SELECT * FROM runs WHERE id=?").get(runId);
-  return row;
-}
-
-// src/pilot/state/tasks.ts
-function upsertFromPlan(db, runId, plan) {
-  const stmt = db.prepare(
-    `INSERT OR IGNORE INTO tasks (run_id, task_id, status) VALUES (?, ?, 'pending')`
-  );
-  const tx = db.transaction(() => {
-    for (const t of plan.tasks) {
-      stmt.run(runId, t.id);
-    }
-  });
-  tx();
-}
-function markReady(db, runId, taskId) {
-  requireStatus(db, runId, taskId, ["pending"], "ready");
-  db.run(
-    "UPDATE tasks SET status='ready' WHERE run_id=? AND task_id=?",
-    [runId, taskId]
-  );
-}
-function markRunning(db, args) {
-  requireStatus(db, args.runId, args.taskId, ["ready"], "running");
-  const now = args.now ?? Date.now();
-  db.run(
-    `UPDATE tasks
-     SET status='running',
-         attempts = attempts + 1,
-         session_id = ?,
-         branch = ?,
-         worktree_path = ?,
-         started_at = COALESCE(started_at, ?)
-     WHERE run_id=? AND task_id=?`,
-    [args.sessionId, args.branch, args.worktreePath, now, args.runId, args.taskId]
-  );
-}
-function markSucceeded(db, runId, taskId, now = Date.now()) {
-  requireStatus(db, runId, taskId, ["running"], "succeeded");
-  db.run(
-    `UPDATE tasks
-     SET status='succeeded', finished_at=?, last_error=NULL
-     WHERE run_id=? AND task_id=?`,
-    [now, runId, taskId]
-  );
-}
-function markFailed(db, runId, taskId, reason, now = Date.now()) {
-  requireStatus(db, runId, taskId, ["running", "ready"], "failed");
-  db.run(
-    `UPDATE tasks
-     SET status='failed', finished_at=?, last_error=?
-     WHERE run_id=? AND task_id=?`,
-    [now, reason, runId, taskId]
-  );
-}
-function markBlocked(db, runId, taskId, reason) {
-  requireStatus(db, runId, taskId, ["pending", "ready"], "blocked");
-  db.run(
-    `UPDATE tasks
-     SET status='blocked', last_error=?
-     WHERE run_id=? AND task_id=?`,
-    [reason, runId, taskId]
-  );
-}
-function markAborted(db, runId, taskId, reason, now = Date.now()) {
-  requireStatus(db, runId, taskId, ["running", "ready"], "aborted");
-  db.run(
-    `UPDATE tasks
-     SET status='aborted', finished_at=?, last_error=?
-     WHERE run_id=? AND task_id=?`,
-    [now, reason, runId, taskId]
-  );
-}
-function markPending(db, runId, taskId) {
-  const cur = getTask(db, runId, taskId);
-  if (!cur) {
-    throw new Error(
-      `markPending: task ${JSON.stringify(taskId)} not found in run ${JSON.stringify(runId)}`
-    );
-  }
-  db.run(
-    `UPDATE tasks
-     SET status='pending',
-         session_id=NULL,
-         branch=NULL,
-         worktree_path=NULL,
-         started_at=NULL,
-         finished_at=NULL,
-         last_error=NULL
-     WHERE run_id=? AND task_id=?`,
-    [runId, taskId]
-  );
-}
-function setCostUsd(db, runId, taskId, costUsd) {
-  if (!Number.isFinite(costUsd) || costUsd < 0) {
-    throw new RangeError(`setCostUsd: invalid cost ${costUsd}`);
-  }
-  db.run(
-    "UPDATE tasks SET cost_usd=? WHERE run_id=? AND task_id=?",
-    [costUsd, runId, taskId]
-  );
-}
-function getTask(db, runId, taskId) {
-  return db.query("SELECT * FROM tasks WHERE run_id=? AND task_id=?").get(runId, taskId);
-}
-function listTasks(db, runId) {
-  return db.query("SELECT * FROM tasks WHERE run_id=? ORDER BY task_id").all(runId);
-}
-function countByStatus(db, runId) {
-  const rows = db.query("SELECT status, COUNT(*) as n FROM tasks WHERE run_id=? GROUP BY status").all(runId);
-  const out = {
-    pending: 0,
-    ready: 0,
-    running: 0,
-    succeeded: 0,
-    failed: 0,
-    blocked: 0,
-    aborted: 0
-  };
-  for (const r of rows) out[r.status] = r.n;
-  return out;
-}
-function requireStatus(db, runId, taskId, expected, intended) {
-  const row = getTask(db, runId, taskId);
-  if (!row) {
-    throw new Error(
-      `task ${JSON.stringify(taskId)} not found in run ${JSON.stringify(runId)}`
-    );
-  }
-  if (!expected.includes(row.status)) {
-    throw new Error(
-      `cannot move task ${JSON.stringify(taskId)} from ${row.status} to ${intended} (expected one of: ${expected.join(", ")})`
-    );
-  }
-}
-
 // src/pilot/state/events.ts
 function appendEvent(db, args) {
   const ts = args.now ?? Date.now();
@@ -1644,9 +1330,10 @@ function tryParseJson(s) {
 }
 
 // src/pilot/opencode/server.ts
-import { execFile as execFile2 } from "child_process";
-import * as fs8 from "fs";
-import * as path8 from "path";
+import { execFile } from "child_process";
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import {
   createOpencodeServer,
   createOpencodeClient
@@ -1658,7 +1345,7 @@ async function startOpencodeServer(options = {}) {
   const port = options.port ?? DEFAULT_PORT;
   const hostname = options.hostname ?? "127.0.0.1";
   await ensureOpencodeOnPath();
-  const serverConfig = buildPilotServerConfig();
+  const serverConfig = buildPilotServerConfig(options.runContext);
   void options.cwd;
   let server;
   try {
@@ -1675,8 +1362,8 @@ async function startOpencodeServer(options = {}) {
   }
   if (options.serverLogPath) {
     try {
-      fs8.mkdirSync(path8.dirname(options.serverLogPath), { recursive: true });
-      fs8.writeFileSync(
+      fs6.mkdirSync(path6.dirname(options.serverLogPath), { recursive: true });
+      fs6.writeFileSync(
         options.serverLogPath,
         `# pilot opencode server spawn ${(/* @__PURE__ */ new Date()).toISOString()}
 # url=${server.url} hostname=${hostname} port=${port} timeoutMs=${timeoutMs}
@@ -1702,15 +1389,38 @@ async function startOpencodeServer(options = {}) {
   };
   return { url: server.url, client, shutdown };
 }
-function buildPilotServerConfig() {
+function buildPilotServerConfig(runContext) {
   const agents = createAgents();
   const pilotAgents = {};
   for (const name of ["pilot-builder", "pilot-planner"]) {
     if (name in agents) pilotAgents[name] = agents[name];
   }
-  return {
+  const config = {
     agent: pilotAgents
   };
+  if (runContext) {
+    const sessionsPath = getSessionsPath(runContext.runDir);
+    const distDir = path6.dirname(fileURLToPath2(import.meta.url));
+    const statusServerPath = path6.resolve(
+      distDir,
+      "pilot",
+      "mcp",
+      "status-server.js"
+    );
+    config.mcp = {
+      pilot_status: {
+        type: "local",
+        command: ["bun", "run", statusServerPath],
+        env: {
+          PILOT_SESSIONS_PATH: sessionsPath,
+          PILOT_STATE_DB_PATH: runContext.dbPath,
+          PILOT_RUN_ID: runContext.runId
+        },
+        enabled: true
+      }
+    };
+  }
+  return config;
 }
 function resolveTimeoutMs(explicit) {
   if (typeof explicit === "number" && explicit > 0) return explicit;
@@ -1726,10 +1436,10 @@ function resolveTimeoutMs(explicit) {
   return DEFAULT_STARTUP_TIMEOUT_MS;
 }
 async function ensureOpencodeOnPath() {
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve6, reject) => {
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 5e3);
-    execFile2(
+    execFile(
       "opencode",
       ["--version"],
       { signal: controller.signal, encoding: "utf8" },
@@ -1743,7 +1453,7 @@ async function ensureOpencodeOnPath() {
           );
           return;
         }
-        resolve5();
+        resolve6();
       }
     );
   });
@@ -1823,7 +1533,7 @@ var EventBus = class {
   waitForIdle(sessionId, options = {}) {
     const stallMs = options.stallMs ?? 60 * 60 * 1e3;
     const errorIsFatal = options.errorIsFatal ?? true;
-    return new Promise((resolve5) => {
+    return new Promise((resolve6) => {
       let settled = false;
       let stallTimer = null;
       let unsubscribe = () => {
@@ -1836,7 +1546,7 @@ var EventBus = class {
         if (stallTimer) clearTimeout(stallTimer);
         unsubscribe();
         removeAbortListener();
-        resolve5(result);
+        resolve6(result);
       };
       const armStallTimer = () => {
         if (stallTimer) clearTimeout(stallTimer);
@@ -1962,416 +1672,17 @@ function isEventLike(v) {
   return typeof o.type === "string" && typeof o.properties === "object" && o.properties !== null;
 }
 
-// src/pilot/worktree/git.ts
-import { execFile as execFile3 } from "child_process";
-function execFileP2(file, args, opts = {}) {
-  const { cwd, timeoutMs = 3e4, env } = opts;
-  return new Promise((resolve5, reject) => {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    execFile3(
-      file,
-      args,
-      {
-        signal: controller.signal,
-        cwd,
-        encoding: "utf8",
-        env,
-        // Increase maxBuffer — git diff/log output can exceed the
-        // 1MB default on large repos.
-        maxBuffer: 16 * 1024 * 1024
-      },
-      (err, stdout, stderr) => {
-        clearTimeout(timer);
-        if (err) {
-          const msg = `${err.message}${stderr ? `
-stderr:
-${stderr}` : ""}`;
-          reject(new Error(msg));
-          return;
-        }
-        resolve5({ stdout: stdout ?? "", stderr: stderr ?? "" });
-      }
-    );
-  });
-}
-function assertSafeArg(s, label) {
-  if (typeof s !== "string" || s.length === 0) {
-    throw new TypeError(`${label}: expected non-empty string, got ${JSON.stringify(s)}`);
-  }
-  if (s.includes("\0")) {
-    throw new TypeError(`${label}: contains null byte: ${JSON.stringify(s)}`);
-  }
-}
-async function headSha(repoOrWorktree) {
-  assertSafeArg(repoOrWorktree, "headSha repo");
-  const { stdout } = await execFileP2("git", [
-    "-C",
-    repoOrWorktree,
-    "rev-parse",
-    "HEAD"
-  ]);
-  return stdout.trim();
-}
-async function gitWorktreeAdd(args) {
-  assertSafeArg(args.repoPath, "repoPath");
-  assertSafeArg(args.worktreePath, "worktreePath");
-  assertSafeArg(args.commitIsh, "commitIsh");
-  const cmd2 = ["-C", args.repoPath, "worktree", "add"];
-  if (args.branch !== void 0) {
-    assertSafeArg(args.branch, "branch");
-    cmd2.push("-B", args.branch);
-  }
-  cmd2.push(args.worktreePath, args.commitIsh);
-  await execFileP2("git", cmd2);
-}
-async function gitWorktreeRemove(args) {
-  assertSafeArg(args.repoPath, "repoPath");
-  assertSafeArg(args.worktreePath, "worktreePath");
-  try {
-    await execFileP2("git", [
-      "-C",
-      args.repoPath,
-      "worktree",
-      "remove",
-      "--force",
-      args.worktreePath
-    ]);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (/is not a working tree|worktree.*does not exist/i.test(msg)) {
-      return;
-    }
-    throw err;
-  }
-}
-async function gitWorktreeList(repoPath) {
-  assertSafeArg(repoPath, "repoPath");
-  const { stdout } = await execFileP2("git", [
-    "-C",
-    repoPath,
-    "worktree",
-    "list",
-    "--porcelain"
-  ]);
-  const records = [];
-  let cur = null;
-  for (const line of stdout.split("\n")) {
-    if (line.length === 0) {
-      if (cur && cur.path) records.push(finalizeWorktreeInfo(cur));
-      cur = null;
-      continue;
-    }
-    if (cur === null) cur = {};
-    const [keyRaw, ...rest] = line.split(" ");
-    const value = rest.join(" ");
-    switch (keyRaw) {
-      case "worktree":
-        cur.path = value;
-        break;
-      case "HEAD":
-        cur.head = value;
-        break;
-      case "branch":
-        cur.branch = value.startsWith("refs/heads/") ? value.slice("refs/heads/".length) : value;
-        break;
-      case "detached":
-        cur.branch = null;
-        break;
-      case "bare":
-        cur.bare = true;
-        break;
-      default:
-        break;
-    }
-  }
-  if (cur && cur.path) records.push(finalizeWorktreeInfo(cur));
-  return records;
-}
-function finalizeWorktreeInfo(p) {
-  return {
-    path: p.path,
-    head: p.head ?? "",
-    branch: p.branch ?? null,
-    bare: p.bare ?? false
-  };
-}
-async function checkoutFreshBranch(args) {
-  assertSafeArg(args.worktree, "worktree");
-  assertSafeArg(args.branch, "branch");
-  assertSafeArg(args.base, "base");
-  await execFileP2("git", [
-    "-C",
-    args.worktree,
-    "checkout",
-    "-B",
-    args.branch,
-    args.base
-  ]);
-}
-async function cleanWorktree(worktree) {
-  assertSafeArg(worktree, "worktree");
-  await execFileP2("git", ["-C", worktree, "reset", "--hard"]);
-  await execFileP2("git", ["-C", worktree, "clean", "-fdx"]);
-}
-async function commitAll(args) {
-  assertSafeArg(args.worktree, "worktree");
-  if (typeof args.message !== "string" || args.message.length === 0) {
-    throw new TypeError("commitAll: message must be non-empty");
-  }
-  await execFileP2("git", ["-C", args.worktree, "add", "-A"]);
-  const env = { ...process.env };
-  if (args.authorName) env.GIT_AUTHOR_NAME = args.authorName;
-  if (args.authorEmail) env.GIT_AUTHOR_EMAIL = args.authorEmail;
-  if (args.authorName) env.GIT_COMMITTER_NAME = args.authorName;
-  if (args.authorEmail) env.GIT_COMMITTER_EMAIL = args.authorEmail;
-  await execFileP2("git", ["-C", args.worktree, "commit", "-m", args.message], {
-    env
-  });
-  return headSha(args.worktree);
-}
-async function diffNamesSince(worktree, sinceSha) {
-  assertSafeArg(worktree, "worktree");
-  assertSafeArg(sinceSha, "sinceSha");
-  const sets = await Promise.all([
-    runDiffNames(worktree, ["diff", "--name-only", `${sinceSha}..HEAD`]),
-    runDiffNames(worktree, ["diff", "--name-only", "--cached"]),
-    runDiffNames(worktree, ["diff", "--name-only"]),
-    runDiffNames(worktree, [
-      "ls-files",
-      "--others",
-      "--exclude-standard"
-    ])
-  ]);
-  const all = /* @__PURE__ */ new Set();
-  for (const s of sets) for (const p of s) all.add(p);
-  return [...all].sort();
-}
-async function runDiffNames(worktree, args) {
-  const { stdout } = await execFileP2("git", ["-C", worktree, ...args]);
-  return stdout.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
-}
-
-// src/pilot/worktree/pool.ts
-import { promises as fs9 } from "fs";
-var WorktreePool = class {
-  repoPath;
-  worktreeDirOf;
-  slots = /* @__PURE__ */ new Map();
-  /**
-   * Slots that were preserved on failure. No longer reachable via
-   * `acquire` — they stay here for `shutdown` (so `keepPreserved=false`
-   * can still clean them up) and `inspect` (so debug tooling sees them).
-   *
-   * When a slot is preserved and a subsequent `acquire(n)` happens, the
-   * current live slot at index `n` is MOVED here, and `slots` gets a
-   * fresh stub at `n` with a bumped `retryCounter`. This is what
-   * prevents a single failed task from poisoning every downstream task
-   * (the pre-v0.2 bug: one preserve → all subsequent `prepare` calls
-   * threw "slot N is preserved").
-   */
-  retiredSlots = [];
-  /**
-   * Per-index retry counter. Bumps every time `acquire` retires a
-   * preserved slot. Read by `prepare` to decide whether the worktree
-   * path needs a `-<counter>` suffix (for retried slots) or the bare
-   * `worktreeDirOf(n)` path (first-ever use — back-compat with the
-   * existing on-disk layout).
-   */
-  retryCounter = /* @__PURE__ */ new Map();
-  workerCount;
-  /**
-   * Set of workers currently held by an `acquire`. v0.1 only ever holds
-   * one at a time, but the structure scales to v0.3.
-   */
-  busy = /* @__PURE__ */ new Set();
-  constructor(opts) {
-    this.repoPath = opts.repoPath;
-    this.worktreeDirOf = opts.worktreeDir;
-    const requested = opts.workerCount ?? 1;
-    if (requested > 1) {
-      process.stderr.write(
-        `[pilot] WorktreePool: workerCount=${requested} requested, but v0.1 supports only 1 \u2014 clamping.
-`
-      );
-    }
-    this.workerCount = 1;
-  }
-  /**
-   * Acquire a worker slot. Returns the live slot for the given worker
-   * index, or a fresh stub if the current live slot was preserved on
-   * failure.
-   *
-   * v0.1 always uses slot 0. First call returns a fresh stub. If that
-   * slot is later `preserveOnFailure`'d, the next `acquire()` retires
-   * the preserved slot into `retiredSlots`, bumps the retry counter,
-   * and mints a new stub at index 0. The old slot stays on disk (for
-   * operator inspection) but is no longer the pool's live slot.
-   */
-  acquire() {
-    for (let n = 0; n < this.workerCount; n++) {
-      if (this.busy.has(n)) continue;
-      this.busy.add(n);
-      const existing = this.slots.get(n);
-      if (existing && existing.preserved) {
-        this.retiredSlots.push(existing);
-        this.slots.delete(n);
-        this.retryCounter.set(n, (this.retryCounter.get(n) ?? 0) + 1);
-      } else if (existing) {
-        return existing;
-      }
-      const stub = {
-        index: n,
-        path: "",
-        // filled by prepare
-        prepared: false,
-        preserved: false,
-        setupCompleted: false
-      };
-      this.slots.set(n, stub);
-      return stub;
-    }
-    throw new Error(
-      `WorktreePool.acquire: no free worker slots (workerCount=${this.workerCount}, busy=${[...this.busy].join(",")})`
-    );
-  }
-  /**
-   * Prepare a worktree for the given task. Idempotent: on first call,
-   * runs `git worktree add`; on subsequent calls, recycles the existing
-   * worktree (clean + checkout fresh branch).
-   *
-   * Returns the SHA at HEAD post-prepare. The worker records this as
-   * `sinceSha` for the post-task `enforceTouches` diff.
-   *
-   * `branchPrefix` typically = `pilot/<plan-slug>`; the actual branch
-   * is `<branchPrefix>/<taskId>`. `base` is the commit-ish the branch
-   * is created from — usually the main branch's HEAD or a specific
-   * sha if reproducibility matters.
-   *
-   * For retried slots (i.e. `retryCounter[n] > 0`), the resolved path
-   * gets a `-<counter>` suffix so retries don't collide with the
-   * preserved predecessor on disk.
-   */
-  async prepare(args) {
-    if (args.slot.preserved) {
-      throw new Error(
-        `WorktreePool.prepare: slot ${args.slot.index} is preserved (failed task awaiting cleanup); cannot reuse`
-      );
-    }
-    const branch = `${args.branchPrefix}/${args.taskId}`;
-    if (!args.slot.prepared) {
-      const basePath = await this.worktreeDirOf(args.slot.index);
-      const counter = this.retryCounter.get(args.slot.index) ?? 0;
-      const wtPath = counter > 0 ? `${basePath}-${counter}` : basePath;
-      args.slot.path = wtPath;
-      try {
-        await fs9.stat(wtPath);
-        await gitWorktreeRemove({
-          repoPath: this.repoPath,
-          worktreePath: wtPath
-        });
-        await fs9.rm(wtPath, { recursive: true, force: true });
-      } catch {
-      }
-      await gitWorktreeAdd({
-        repoPath: this.repoPath,
-        worktreePath: wtPath,
-        commitIsh: args.base,
-        branch
-      });
-      args.slot.prepared = true;
-    } else {
-      await cleanWorktree(args.slot.path);
-      await checkoutFreshBranch({
-        worktree: args.slot.path,
-        branch,
-        base: args.base
-      });
-    }
-    const sinceSha = await headSha(args.slot.path);
-    return { sinceSha, branch, path: args.slot.path };
-  }
-  /**
-   * Release a slot back to the pool — slot becomes available for
-   * `acquire` again. Call after a clean task completion (commit
-   * succeeded, no preserved state needed).
-   *
-   * Does NOT clean the worktree — the next `prepare` call will reset
-   * it. If you want eager cleanup (e.g. before a long idle), call
-   * `cleanWorktree(slot.path)` separately.
-   */
-  release(slot) {
-    if (!this.busy.has(slot.index)) {
-      throw new Error(
-        `WorktreePool.release: slot ${slot.index} is not held`
-      );
-    }
-    this.busy.delete(slot.index);
-  }
-  /**
-   * Preserve a slot's state on failure. The slot is marked preserved
-   * and removed from the busy set. Unlike pre-v0.2 behaviour, the
-   * next `acquire()` call retires this slot into `retiredSlots` and
-   * mints a fresh stub — so a single failure doesn't cascade-block
-   * the rest of the run.
-   *
-   * The CLI's `pilot worktrees prune` (Phase G6) remains the path to
-   * permanently remove preserved slots from disk.
-   */
-  preserveOnFailure(slot) {
-    slot.preserved = true;
-    this.busy.delete(slot.index);
-  }
-  /**
-   * Tear down all worktrees managed by this pool — BOTH live and
-   * retired. Called at end of `pilot build` (whether success or
-   * failure). Preserved slots are skipped when `keepPreserved` is
-   * true (the default) — those are the user's to inspect.
-   */
-  async shutdown(args = {}) {
-    const keepPreserved = args.keepPreserved ?? true;
-    const errors = [];
-    const all = [...this.slots.values(), ...this.retiredSlots];
-    for (const slot of all) {
-      if (slot.preserved && keepPreserved) continue;
-      if (!slot.prepared || slot.path === "") continue;
-      try {
-        await gitWorktreeRemove({
-          repoPath: this.repoPath,
-          worktreePath: slot.path
-        });
-      } catch (err) {
-        errors.push(err instanceof Error ? err : new Error(String(err)));
-      }
-    }
-    if (errors.length > 0) {
-      throw new Error(
-        `WorktreePool.shutdown: ${errors.length} worktree removal(s) failed:
-` + errors.map((e) => e.message).join("\n---\n")
-      );
-    }
-  }
-  /**
-   * Inspect current slots (for tests / `pilot worktrees list`). Returns
-   * live slots followed by retired slots, in insertion order within
-   * each group.
-   */
-  inspect() {
-    return [...this.slots.values(), ...this.retiredSlots];
-  }
-};
-
-// src/pilot/scheduler/ready-set.ts
-function makeScheduler(args) {
-  const { db, runId, plan } = args;
-  const planById = /* @__PURE__ */ new Map();
-  for (const t of plan.tasks) planById.set(t.id, t);
-  const dependentsOf = /* @__PURE__ */ new Map();
-  for (const t of plan.tasks) {
-    for (const dep of t.depends_on) {
-      const list = dependentsOf.get(dep);
-      if (list) list.push(t.id);
-      else dependentsOf.set(dep, [t.id]);
+// src/pilot/scheduler/ready-set.ts
+function makeScheduler(args) {
+  const { db, runId, plan } = args;
+  const planById = /* @__PURE__ */ new Map();
+  for (const t of plan.tasks) planById.set(t.id, t);
+  const dependentsOf = /* @__PURE__ */ new Map();
+  for (const t of plan.tasks) {
+    for (const dep of t.depends_on) {
+      const list = dependentsOf.get(dep);
+      if (list) list.push(t.id);
+      else dependentsOf.set(dep, [t.id]);
     }
   }
   return {
@@ -2437,6 +1748,8 @@ function depsSatisfied(db, runId, task) {
 
 // src/pilot/worker/worker.ts
 import * as fsSync from "fs";
+import { execFile as execFileCb } from "child_process";
+import { promisify as promisifyUtil } from "util";
 
 // src/pilot/opencode/prompts.ts
 function kickoffPrompt(task, ctx) {
@@ -2491,6 +1804,18 @@ function kickoffPrompt(task, ctx) {
       );
     }
   }
+  sections.push(``, `## Progress updates`, ``);
+  sections.push(
+    `A \`provide_status_update\` tool is available. Use it to emit one-sentence progress updates during long-running work.`,
+    ``,
+    `Guidelines:`,
+    `- Keep messages under 200 characters`,
+    `- One sentence only \u2014 describe what you're currently working on`,
+    `- Rate limited to once per 60 seconds per task`,
+    `- Call it sparingly; the user sees these interleaved with the task log`,
+    ``,
+    `Example: "Writing the route handler for /api/users" or "Running typecheck after edits"`
+  );
   if (task.context !== void 0 && task.context.trim().length > 0) {
     sections.push(``, `## Context`, ``, task.context.trim());
   }
@@ -2547,8 +1872,8 @@ var DEFAULT_OUTPUT_CAP_BYTES = 256 * 1024;
 var TRUNCATION_NOTICE = "\n[pilot] verify output truncated\n";
 async function runVerify(commands, options) {
   const results = [];
-  for (const command12 of commands) {
-    const result = await runOne(command12, options);
+  for (const command10 of commands) {
+    const result = await runOne(command10, options);
     results.push(result);
     if (!result.ok) {
       return { ok: false, results, failure: result };
@@ -2559,8 +1884,8 @@ async function runVerify(commands, options) {
     results
   };
 }
-async function runOne(command12, options) {
-  if (typeof command12 !== "string" || command12.length === 0) {
+async function runOne(command10, options) {
+  if (typeof command10 !== "string" || command10.length === 0) {
     throw new TypeError(`runOne: command must be a non-empty string`);
   }
   if (typeof options.cwd !== "string" || options.cwd.length === 0) {
@@ -2576,7 +1901,7 @@ async function runOne(command12, options) {
     stdout: { partial: "" },
     stderr: { partial: "" }
   };
-  const child = spawn2("bash", ["-c", command12], {
+  const child = spawn2("bash", ["-c", command10], {
     cwd: options.cwd,
     env: options.env ?? process.env,
     stdio: ["ignore", "pipe", "pipe"]
@@ -2621,18 +1946,18 @@ async function runOne(command12, options) {
       const lines = combined.split("\n");
       state.partial = lines.pop();
       for (const line of lines) {
-        options.onLine({ stream, line, command: command12 });
+        options.onLine({ stream, line, command: command10 });
       }
     }
   };
   child.stdout?.on("data", (c2) => handleChunk("stdout", c2));
   child.stderr?.on("data", (c2) => handleChunk("stderr", c2));
-  const { code, signal } = await new Promise((resolve5) => {
+  const { code, signal } = await new Promise((resolve6) => {
     let resolved = false;
     const finalize = (code2, signal2) => {
       if (resolved) return;
       resolved = true;
-      resolve5({ code: code2, signal: signal2 });
+      resolve6({ code: code2, signal: signal2 });
     };
     child.on("error", (err) => {
       if (!truncated) {
@@ -2652,7 +1977,7 @@ async function runOne(command12, options) {
     for (const stream of ["stdout", "stderr"]) {
       const partial = streamState[stream].partial;
       if (partial.length > 0) {
-        options.onLine({ stream, line: partial, command: command12 });
+        options.onLine({ stream, line: partial, command: command10 });
       }
     }
   }
@@ -2661,7 +1986,7 @@ async function runOne(command12, options) {
   if (code === 0 && !timedOut && !aborted) {
     return {
       ok: true,
-      command: command12,
+      command: command10,
       exitCode: 0,
       output,
       durationMs
@@ -2669,7 +1994,7 @@ async function runOne(command12, options) {
   }
   return {
     ok: false,
-    command: command12,
+    command: command10,
     exitCode: code ?? -1,
     signal,
     timedOut,
@@ -2697,15 +2022,66 @@ function killTree(child) {
 
 // src/pilot/verify/touches.ts
 import picomatch2 from "picomatch";
+import { execFile as execFile2 } from "child_process";
+import { promisify } from "util";
+var execFileP = promisify(execFile2);
+var DEFAULT_TOLERATE = [
+  // Next.js — `next build` regenerates this every run.
+  "**/next-env.d.ts",
+  // Next.js app-router generated types (routes.d.ts, etc.)
+  "**/.next/types/**",
+  "**/.next/dev/types/**",
+  // TypeScript project-reference build info — tsc writes these.
+  "**/*.tsbuildinfo",
+  // Snapshot test updates — `vitest -u` / `jest -u` rewrites these
+  // when assertions match; allowing them lets snapshot-driven tasks
+  // pass without the agent authoring every snapshot path.
+  "**/__snapshots__/**",
+  "**/*.snap"
+];
+async function diffNamesSince(cwd, sinceSha) {
+  const run2 = async (args) => {
+    for (const a of args) {
+      if (a.includes("\0")) {
+        throw new Error(`git arg contains null byte: ${JSON.stringify(a)}`);
+      }
+    }
+    const { stdout } = await execFileP("git", ["-C", cwd, ...args], {
+      timeout: 3e4,
+      maxBuffer: 16 * 1024 * 1024
+    });
+    return stdout.toString().split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+  };
+  const sets = await Promise.all([
+    run2(["diff", "--name-only", `${sinceSha}..HEAD`]),
+    run2(["diff", "--cached", "--name-only"]),
+    run2(["diff", "--name-only"]),
+    run2(["ls-files", "--others", "--exclude-standard"])
+  ]);
+  const all = /* @__PURE__ */ new Set();
+  for (const s of sets) for (const p of s) all.add(p);
+  return [...all].sort();
+}
 async function enforceTouches(args) {
-  const changed = await diffNamesSince(args.worktree, args.sinceSha);
+  const changed = await diffNamesSince(args.cwd, args.sinceSha);
   if (changed.length === 0) {
     return { ok: true, changed: [] };
   }
+  const combined = [
+    ...args.allowed,
+    ...args.tolerate ?? [],
+    ...DEFAULT_TOLERATE
+  ];
   if (args.allowed.length === 0) {
-    return { ok: false, changed, violators: [...changed] };
+    const matchPassthrough = picomatch2(
+      [...args.tolerate ?? [], ...DEFAULT_TOLERATE],
+      { dot: true }
+    );
+    const violators2 = changed.filter((p) => !matchPassthrough(p));
+    if (violators2.length === 0) return { ok: true, changed };
+    return { ok: false, changed, violators: violators2 };
   }
-  const matchAllowed = picomatch2([...args.allowed], { dot: true });
+  const matchAllowed = picomatch2(combined, { dot: true });
   const violators = changed.filter((p) => !matchAllowed(p));
   if (violators.length === 0) return { ok: true, changed };
   return { ok: false, changed, violators };
@@ -2860,12 +2236,71 @@ function isTextPart(v) {
 }
 
 // src/pilot/worker/worker.ts
+var execFileWorker = promisifyUtil(execFileCb);
+async function commitAll(cwd, subject, authorName, authorEmail) {
+  const env = { ...process.env };
+  if (authorName) env.GIT_AUTHOR_NAME = authorName;
+  if (authorEmail) env.GIT_AUTHOR_EMAIL = authorEmail;
+  if (authorName) env.GIT_COMMITTER_NAME = authorName;
+  if (authorEmail) env.GIT_COMMITTER_EMAIL = authorEmail;
+  await execFileWorker("git", ["add", "-A"], { cwd, timeout: 1e4 });
+  await execFileWorker("git", ["commit", "-m", subject], {
+    cwd,
+    timeout: 3e4,
+    env
+  });
+  const { stdout } = await execFileWorker("git", ["rev-parse", "HEAD"], {
+    cwd,
+    timeout: 1e4
+  });
+  return stdout.toString().trim();
+}
+async function resetTree(cwd) {
+  try {
+    await execFileWorker("git", ["reset", "--hard", "HEAD"], {
+      cwd,
+      timeout: 3e4
+    });
+    await execFileWorker("git", ["clean", "-fd"], {
+      cwd,
+      timeout: 3e4
+    });
+    return true;
+  } catch (err) {
+    const e = err;
+    process.stderr.write(
+      `[pilot] tree cleanup failed: ${(e.stderr ?? e.message ?? "").toString()}
+`
+    );
+    return false;
+  }
+}
 async function runWorker(deps) {
   const attempted = [];
-  const maxAttempts = deps.maxAttempts ?? 3;
+  const maxAttempts = deps.maxAttempts ?? 5;
   const stallMs = deps.stallMs ?? 60 * 60 * 1e3;
-  let setupAborted = false;
-  const depsWithAbort = deps;
+  const cwd = deps.cwd ?? process.cwd();
+  const gate = await checkCwdSafety(cwd);
+  if (!gate.ok) {
+    process.stderr.write(`[pilot] ${gate.reason}
+`);
+    return { aborted: true, attempted: [] };
+  }
+  for (const w of gate.warnings) {
+    process.stderr.write(`[pilot] ${w}
+`);
+  }
+  const { loadPilotConfig } = await import("./pilot-config-7LJZ23YK.js");
+  let pilotConfig;
+  try {
+    pilotConfig = await loadPilotConfig(cwd);
+  } catch (err) {
+    process.stderr.write(
+      `[pilot] ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return { aborted: true, attempted: [] };
+  }
   while (true) {
     if (deps.abortSignal?.aborted) {
       return { aborted: true, attempted };
@@ -2875,9 +2310,13 @@ async function runWorker(deps) {
       return { aborted: false, attempted };
     }
     attempted.push(pick.task.id);
-    await runOneTask(depsWithAbort, pick.task, { maxAttempts, stallMs });
-    if (depsWithAbort.setupAborted) {
-      return { aborted: false, attempted };
+    await runOneTask(deps, pick.task, { maxAttempts, stallMs, cwd, pilotConfig });
+    if (deps.treeCleanupFailed) {
+      process.stderr.write(
+        `[pilot] halting run: tree cleanup failed after task ${pick.task.id}; subsequent tasks cannot safely run on a dirty tree
+`
+      );
+      return { aborted: true, attempted };
     }
     const row = getTask(deps.db, deps.runId, pick.task.id);
     if (row && (row.status === "failed" || row.status === "aborted")) {
@@ -2929,118 +2368,50 @@ function openForensics(args) {
   };
 }
 async function runOneTask(deps, task, opts) {
-  const cwd = process.cwd();
+  try {
+    await runOneTaskImpl(deps, task, opts);
+  } finally {
+    const ok = await resetTree(opts.cwd);
+    if (!ok) {
+      deps.treeCleanupFailed = true;
+      appendEvent(deps.db, {
+        runId: deps.runId,
+        taskId: task.id,
+        kind: "run.cleanup.failed",
+        payload: {
+          reason: "git reset --hard HEAD && git clean -fd failed after task; subsequent tasks aborted"
+        }
+      });
+    }
+  }
+}
+async function runOneTaskImpl(deps, task, opts) {
+  const cwd = opts.cwd;
   appendEvent(deps.db, {
     runId: deps.runId,
     taskId: task.id,
     kind: "task.started",
     payload: {}
   });
-  let slot;
-  let prepared;
+  let sinceSha;
   try {
-    slot = deps.pool.acquire();
-    prepared = await deps.pool.prepare({
-      slot,
-      taskId: task.id,
-      branchPrefix: deps.branchPrefix,
-      base: deps.base
-    });
+    sinceSha = await headSha(cwd);
   } catch (err) {
-    const reason2 = `worktree prepare failed: ${errorMessage2(err)}`;
-    try {
-      const row = getTask(deps.db, deps.runId, task.id);
-      if (row?.status === "pending") {
-        deps.scheduler.next();
-      }
-      markFailed(deps.db, deps.runId, task.id, reason2);
-    } catch {
-    }
+    const reason2 = `headSha failed: ${errorMessage2(err)}`;
+    markFailedSafe(deps.db, deps.runId, task.id, reason2);
     appendEvent(deps.db, {
       runId: deps.runId,
       taskId: task.id,
       kind: "task.failed",
-      payload: { phase: "prepare", reason: reason2 }
+      payload: { phase: "headSha", reason: reason2 }
     });
     return;
   }
-  const setupCommands = deps.plan.setup ?? [];
-  if (setupCommands.length > 0 && !slot.setupCompleted) {
-    const setupStart = Date.now();
-    appendEvent(deps.db, {
-      runId: deps.runId,
-      taskId: task.id,
-      kind: "slot.setup.started",
-      payload: {
-        slotIndex: slot.index,
-        commands: deps.plan.setup,
-        taskId: task.id
-      }
-    });
-    const setupResult = await runVerify(setupCommands, {
-      cwd: prepared.path,
-      abortSignal: deps.abortSignal,
-      onLine: deps.onVerifyLine
-    });
-    if (!setupResult.ok) {
-      const durationMs = Date.now() - setupStart;
-      const failure = setupResult.failure;
-      const reason2 = `setup failed: ${failure.command} \u2192 exit ${failure.exitCode}`;
-      appendEvent(deps.db, {
-        runId: deps.runId,
-        taskId: task.id,
-        kind: "slot.setup.failed",
-        payload: {
-          slotIndex: slot.index,
-          command: failure.command,
-          exitCode: failure.exitCode,
-          output: failure.output.slice(0, 4096),
-          // truncate
-          durationMs
-        }
-      });
-      deps.pool.preserveOnFailure(slot);
-      markFailedSafe(deps.db, deps.runId, task.id, reason2);
-      const blocked = new Set(
-        deps.scheduler.cascadeFail(task.id, reason2)
-      );
-      for (const row of listTasks(deps.db, deps.runId)) {
-        if (row.task_id === task.id) continue;
-        if (blocked.has(row.task_id)) continue;
-        if (row.status !== "pending" && row.status !== "ready") continue;
-        try {
-          markBlocked(deps.db, deps.runId, row.task_id, reason2);
-          blocked.add(row.task_id);
-        } catch {
-        }
-      }
-      for (const blockedId of blocked) {
-        appendEvent(deps.db, {
-          runId: deps.runId,
-          taskId: blockedId,
-          kind: "task.blocked",
-          payload: { reason: reason2, failedDep: task.id }
-        });
-      }
-      deps.setupAborted = true;
-      return;
-    }
-    slot.setupCompleted = true;
-    appendEvent(deps.db, {
-      runId: deps.runId,
-      taskId: task.id,
-      kind: "slot.setup.completed",
-      payload: {
-        slotIndex: slot.index,
-        durationMs: Date.now() - setupStart
-      }
-    });
-  }
   let sessionId;
   try {
     const created = await deps.client.session.create({
       body: { title: `pilot/${deps.runId}/${task.id}` },
-      query: { directory: prepared.path }
+      query: { directory: cwd }
     });
     if (!created.data?.id) {
       throw new Error(`session.create returned no id`);
@@ -3048,7 +2419,6 @@ async function runOneTask(deps, task, opts) {
     sessionId = created.data.id;
   } catch (err) {
     const reason2 = `session.create failed: ${errorMessage2(err)}`;
-    deps.pool.preserveOnFailure(slot);
     markFailedSafe(deps.db, deps.runId, task.id, reason2);
     appendEvent(deps.db, {
       runId: deps.runId,
@@ -3058,7 +2428,14 @@ async function runOneTask(deps, task, opts) {
     });
     return;
   }
-  const bus = deps.busFactory(prepared.path);
+  const runDir = await getRunDir(process.cwd(), deps.runId);
+  await registerSession({
+    runDir,
+    sessionId,
+    runId: deps.runId,
+    taskId: task.id
+  });
+  const bus = deps.busFactory(cwd);
   await new Promise((r) => setTimeout(r, 200));
   const disposeBus = async () => {
     try {
@@ -3077,18 +2454,23 @@ async function runOneTask(deps, task, opts) {
     if (forensics) forensics.dispose();
     void disposeBus();
   };
+  const unregisterSessionSafe = async () => {
+    try {
+      await unregisterSession({ runDir, sessionId });
+    } catch {
+    }
+  };
   const forensicsCounters = () => forensics ? forensics.counters() : { lastEventTs: null, eventCount: 0 };
   try {
     markRunning(deps.db, {
       runId: deps.runId,
       taskId: task.id,
       sessionId,
-      branch: prepared.branch,
-      worktreePath: prepared.path
+      branch: "",
+      worktreePath: cwd
     });
   } catch (err) {
     disposeForensics();
-    deps.pool.preserveOnFailure(slot);
     const reason2 = `markRunning failed: ${errorMessage2(err)}`;
     markFailedSafe(deps.db, deps.runId, task.id, reason2);
     appendEvent(deps.db, {
@@ -3103,12 +2485,12 @@ async function runOneTask(deps, task, opts) {
     runId: deps.runId,
     taskId: task.id,
     kind: "task.session.created",
-    payload: { sessionId, branch: prepared.branch, worktreePath: prepared.path }
+    payload: { sessionId, branch: "", worktreePath: cwd }
   });
   const ctx = {
     planName: deps.plan.name,
-    branch: prepared.branch,
-    worktreePath: prepared.path,
+    branch: "",
+    worktreePath: cwd,
     milestone: task.milestone,
     verifyAfterEach: deps.plan.defaults.verify_after_each,
     verifyMilestone: task.milestone !== void 0 ? deps.plan.milestones.find((m) => m.name === task.milestone)?.verify ?? [] : []
@@ -3116,8 +2498,50 @@ async function runOneTask(deps, task, opts) {
   const allVerify = [
     ...task.verify,
     ...deps.plan.defaults.verify_after_each,
-    ...ctx.verifyMilestone
+    ...ctx.verifyMilestone,
+    ...opts.pilotConfig.after_each
+  ];
+  const baselineVerify = [
+    ...deps.plan.defaults.verify_after_each,
+    ...ctx.verifyMilestone,
+    ...opts.pilotConfig.after_each,
+    ...opts.pilotConfig.baseline.filter(
+      (c2) => !deps.plan.defaults.verify_after_each.includes(c2) && !ctx.verifyMilestone.includes(c2) && !opts.pilotConfig.after_each.includes(c2)
+    )
   ];
+  if (baselineVerify.length > 0) {
+    const baselineResult = await runVerify(baselineVerify, {
+      cwd,
+      abortSignal: deps.abortSignal,
+      onLine: deps.onVerifyLine,
+      env: process.env
+    });
+    if (!baselineResult.ok) {
+      const f = baselineResult.failure;
+      const reason2 = `baseline verify failed: ${f.command} \u2192 exit ${f.exitCode}. This command fails on the clean tree BEFORE the agent starts \u2014 fix your environment or narrow the verify scope.`;
+      disposeForensics();
+      markFailedSafe(deps.db, deps.runId, task.id, reason2);
+      appendEvent(deps.db, {
+        runId: deps.runId,
+        taskId: task.id,
+        kind: "task.baseline.failed",
+        payload: {
+          phase: "baseline",
+          command: f.command,
+          exitCode: f.exitCode,
+          output: f.output.slice(0, 4096),
+          reason: reason2
+        }
+      });
+      return;
+    }
+    appendEvent(deps.db, {
+      runId: deps.runId,
+      taskId: task.id,
+      kind: "task.baseline.passed",
+      payload: { commands: allVerify.length }
+    });
+  }
   let lastFailure = null;
   let stopReason = null;
   for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
@@ -3125,7 +2549,7 @@ async function runOneTask(deps, task, opts) {
       await abortSession(deps, sessionId);
       markAbortedSafe(deps.db, deps.runId, task.id, "abort signal");
       disposeForensics();
-      deps.pool.preserveOnFailure(slot);
+      await unregisterSessionSafe();
       appendEvent(deps.db, {
         runId: deps.runId,
         taskId: task.id,
@@ -3155,7 +2579,7 @@ async function runOneTask(deps, task, opts) {
     try {
       await deps.client.session.promptAsync({
         path: { id: sessionId },
-        query: { directory: prepared.path },
+        query: { directory: cwd },
         body: {
           agent: task.agent ?? deps.plan.defaults.agent,
           parts: [{ type: "text", text: promptText }]
@@ -3165,7 +2589,7 @@ async function runOneTask(deps, task, opts) {
       unsubStop();
       const reason2 = `promptAsync failed: ${errorMessage2(err)}`;
       disposeForensics();
-      deps.pool.preserveOnFailure(slot);
+      await unregisterSessionSafe();
       markFailedSafe(deps.db, deps.runId, task.id, reason2);
       appendEvent(deps.db, {
         runId: deps.runId,
@@ -3185,7 +2609,7 @@ async function runOneTask(deps, task, opts) {
       await abortSession(deps, sessionId);
       markAbortedSafe(deps.db, deps.runId, task.id, "abort signal");
       disposeForensics();
-      deps.pool.preserveOnFailure(slot);
+      await unregisterSessionSafe();
       appendEvent(deps.db, {
         runId: deps.runId,
         taskId: task.id,
@@ -3203,8 +2627,8 @@ async function runOneTask(deps, task, opts) {
       } catch {
       }
       disposeForensics();
+      await unregisterSessionSafe();
       markFailedSafe(deps.db, deps.runId, task.id, reason2);
-      deps.pool.preserveOnFailure(slot);
       appendEvent(deps.db, {
         runId: deps.runId,
         taskId: task.id,
@@ -3222,8 +2646,8 @@ async function runOneTask(deps, task, opts) {
     if (idleResult.kind === "session-error") {
       const reason2 = `session error: ${JSON.stringify(idleResult.properties)}`;
       disposeForensics();
+      await unregisterSessionSafe();
       markFailedSafe(deps.db, deps.runId, task.id, reason2);
-      deps.pool.preserveOnFailure(slot);
       appendEvent(deps.db, {
         runId: deps.runId,
         taskId: task.id,
@@ -3238,8 +2662,8 @@ async function runOneTask(deps, task, opts) {
     }
     if (stopReason !== null) {
       disposeForensics();
+      await unregisterSessionSafe();
       markFailedSafe(deps.db, deps.runId, task.id, stopReason);
-      deps.pool.preserveOnFailure(slot);
       appendEvent(deps.db, {
         runId: deps.runId,
         taskId: task.id,
@@ -3249,9 +2673,10 @@ async function runOneTask(deps, task, opts) {
       return;
     }
     const verifyResult = await runVerify(allVerify, {
-      cwd: prepared.path,
+      cwd,
       abortSignal: deps.abortSignal,
-      onLine: deps.onVerifyLine
+      onLine: deps.onVerifyLine,
+      env: process.env
     });
     if (!verifyResult.ok) {
       lastFailure = {
@@ -3269,20 +2694,21 @@ async function runOneTask(deps, task, opts) {
           command: lastFailure.command,
           exitCode: lastFailure.exitCode,
           timedOut: verifyResult.failure.timedOut,
-          aborted: verifyResult.failure.aborted
+          aborted: verifyResult.failure.aborted,
+          output: verifyResult.failure.output.slice(-2048)
         }
       });
       if (verifyResult.failure.aborted) {
         disposeForensics();
+        await unregisterSessionSafe();
         markAbortedSafe(deps.db, deps.runId, task.id, "abort signal during verify");
-        deps.pool.preserveOnFailure(slot);
         return;
       }
       if (attempt < opts.maxAttempts) continue;
       const reason2 = `verify failed after ${opts.maxAttempts} attempts: ${lastFailure.command} \u2192 exit ${lastFailure.exitCode}`;
       disposeForensics();
+      await unregisterSessionSafe();
       markFailedSafe(deps.db, deps.runId, task.id, reason2);
-      deps.pool.preserveOnFailure(slot);
       appendEvent(deps.db, {
         runId: deps.runId,
         taskId: task.id,
@@ -3298,9 +2724,10 @@ async function runOneTask(deps, task, opts) {
       payload: { attempt }
     });
     const touches = await enforceTouches({
-      worktree: prepared.path,
-      sinceSha: prepared.sinceSha,
-      allowed: task.touches
+      cwd,
+      sinceSha,
+      allowed: task.touches,
+      tolerate: task.tolerate
     });
     if (!touches.ok) {
       lastFailure = {
@@ -3318,8 +2745,8 @@ async function runOneTask(deps, task, opts) {
       if (attempt < opts.maxAttempts) continue;
       const reason2 = `touches violation after ${opts.maxAttempts} attempts: ${touches.violators.join(", ")}`;
       disposeForensics();
+      await unregisterSessionSafe();
       markFailedSafe(deps.db, deps.runId, task.id, reason2);
-      deps.pool.preserveOnFailure(slot);
       appendEvent(deps.db, {
         runId: deps.runId,
         taskId: task.id,
@@ -3330,8 +2757,8 @@ async function runOneTask(deps, task, opts) {
     }
     if (touches.changed.length === 0) {
       disposeForensics();
+      await unregisterSessionSafe();
       markSucceeded(deps.db, deps.runId, task.id);
-      deps.pool.release(slot);
       appendEvent(deps.db, {
         runId: deps.runId,
         taskId: task.id,
@@ -3342,15 +2769,15 @@ async function runOneTask(deps, task, opts) {
     }
     try {
       const commitMessage = `${task.id}: ${task.title}`;
-      const sha = await commitAll({
-        worktree: prepared.path,
-        message: commitMessage,
-        authorName: deps.authorName,
-        authorEmail: deps.authorEmail
-      });
+      const sha = await commitAll(
+        cwd,
+        commitMessage,
+        deps.authorName,
+        deps.authorEmail
+      );
       disposeForensics();
+      await unregisterSessionSafe();
       markSucceeded(deps.db, deps.runId, task.id);
-      deps.pool.release(slot);
       appendEvent(deps.db, {
         runId: deps.runId,
         taskId: task.id,
@@ -3359,23 +2786,36 @@ async function runOneTask(deps, task, opts) {
       });
       return;
     } catch (err) {
-      const reason2 = `commit failed: ${errorMessage2(err)}`;
+      const errMsg = errorMessage2(err);
+      lastFailure = {
+        command: "git commit (pre-commit hook)",
+        exitCode: 1,
+        output: errMsg.slice(0, 8192)
+      };
+      appendEvent(deps.db, {
+        runId: deps.runId,
+        taskId: task.id,
+        kind: "task.commit.failed",
+        payload: { attempt, error: errMsg.slice(0, 4096) }
+      });
+      if (attempt < opts.maxAttempts) continue;
+      const reason2 = `commit failed after ${opts.maxAttempts} attempts: ${errMsg.slice(0, 500)}`;
       disposeForensics();
+      await unregisterSessionSafe();
       markFailedSafe(deps.db, deps.runId, task.id, reason2);
-      deps.pool.preserveOnFailure(slot);
       appendEvent(deps.db, {
         runId: deps.runId,
         taskId: task.id,
         kind: "task.failed",
-        payload: { phase: "commit", reason: reason2 }
+        payload: { phase: "commit", reason: reason2, attempts: opts.maxAttempts }
       });
       return;
     }
   }
   const reason = "worker loop exited unexpectedly";
   disposeForensics();
+  await unregisterSessionSafe();
   markFailedSafe(deps.db, deps.runId, task.id, reason);
-  deps.pool.preserveOnFailure(slot);
   appendEvent(deps.db, {
     runId: deps.runId,
     taskId: task.id,
@@ -3447,7 +2887,7 @@ function errorMessage2(err) {
 }
 
 // src/pilot/cli/build.ts
-import { promises as fs10 } from "fs";
+import { promises as fs7 } from "fs";
 var buildCmd = command3({
   name: "build",
   description: "Execute a pilot.yaml plan via the worker loop.",
@@ -3552,8 +2992,8 @@ async function runBuild(opts) {
   const opened = openStateDb(":memory:");
   opened.close();
   const cleanup = [];
-  const { ulid: ulid2 } = await import("ulid");
-  const runId = ulid2();
+  const { ulid } = await import("ulid");
+  const runId = ulid();
   const dbPath = await getStateDbPath(cwd, runId);
   const runDir = await getRunDir(cwd, runId);
   const branchPrefix = deriveBranchPrefix(plan.branch_prefix, slug, runId);
@@ -3572,6 +3012,49 @@ async function runBuild(opts) {
     kind: "run.started",
     payload: { planPath, slug, runDir, branchPrefix }
   });
+  const { runSetupHook, SETUP_HOOK_RELATIVE_PATH } = await import("./setup-hook-FHTXMAQL.js");
+  const hookResult = await runSetupHook({
+    cwd,
+    onLine: (c2) => stderrWriter(c2)
+  });
+  switch (hookResult.kind) {
+    case "skipped":
+      break;
+    case "ok":
+      stderrWriter(
+        `[pilot] setup hook ${SETUP_HOOK_RELATIVE_PATH} passed (${Math.round(hookResult.durationMs / 1e3)}s)
+`
+      );
+      break;
+    case "not-executable":
+      stderrWriter(
+        `[pilot] setup hook ${hookResult.hookPath} is not executable. Run \`chmod +x ${SETUP_HOOK_RELATIVE_PATH}\` and re-run pilot.
+`
+      );
+      await runCleanup(cleanup);
+      return 1;
+    case "timed-out":
+      stderrWriter(
+        `[pilot] setup hook ${hookResult.hookPath} timed out after ${Math.round(hookResult.timeoutMs / 1e3)}s
+`
+      );
+      await runCleanup(cleanup);
+      return 1;
+    case "failed":
+      stderrWriter(
+        `[pilot] setup hook ${hookResult.hookPath} exited ${hookResult.exitCode} (after ${Math.round(hookResult.durationMs / 1e3)}s). Fix the environment and re-run pilot.
+`
+      );
+      await runCleanup(cleanup);
+      return 1;
+    case "spawn-error":
+      stderrWriter(
+        `[pilot] setup hook ${hookResult.hookPath} failed to spawn: ${hookResult.error}
+`
+      );
+      await runCleanup(cleanup);
+      return 1;
+  }
   return executeRun({
     db: real,
     runId,
@@ -3589,10 +3072,17 @@ async function executeRun(args) {
   const { db, runId, plan, planPath, runDir, branchPrefix, cleanup } = args;
   const cwd = process.cwd();
   const stderrWriter = args.stderrWriter ?? ((s) => void process.stderr.write(s));
+  const runDirForMcp = await getRunDir(cwd, runId);
+  const dbPathForMcp = await getStateDbPath(cwd, runId);
   let server;
   try {
     server = await startOpencodeServer({
-      port: args.opencodePort ?? 0
+      port: args.opencodePort ?? 0,
+      runContext: {
+        runDir: runDirForMcp,
+        dbPath: dbPathForMcp,
+        runId
+      }
     });
   } catch (err) {
     const reason = err instanceof Error ? err.message : String(err);
@@ -3609,28 +3099,7 @@ async function executeRun(args) {
   }
   cleanup.push(() => server.shutdown());
   const busFactory = (directory) => new EventBus(server.client, directory);
-  const pool = new WorktreePool({
-    repoPath: cwd,
-    worktreeDir: async (n) => getWorktreeDir(cwd, runId, n)
-  });
-  cleanup.push(() => pool.shutdown({ keepPreserved: true }));
   const scheduler = makeScheduler({ db: db.db, runId, plan });
-  let base;
-  try {
-    base = await headSha(cwd);
-  } catch (err) {
-    const reason = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`pilot: cannot resolve HEAD sha: ${reason}
-`);
-    appendEvent(db.db, {
-      runId,
-      kind: "run.error",
-      payload: { phase: "head-sha", reason }
-    });
-    markRunFinished(db.db, runId, "failed");
-    await runCleanup(cleanup);
-    return 1;
-  }
   const aborter = new AbortController();
   const sigintHandler = () => aborter.abort("SIGINT");
   process.once("SIGINT", sigintHandler);
@@ -3638,28 +3107,26 @@ async function executeRun(args) {
     process.off("SIGINT", sigintHandler);
   });
   if (args.quiet !== true) {
+    stderrWriter(
+      `pilot build: run ${runId} started (${plan.tasks.length} tasks)
+`
+    );
     const unsubLogger = startStreamingLogger({
       stderrWriter,
       runId,
       totalTasks: plan.tasks.length,
-      subscribe: subscribeToEvents
+      subscribe: subscribeToEvents,
+      db: db.db
     });
     cleanup.push(() => unsubLogger());
-    stderrWriter(
-      `pilot build: run ${runId} started (${plan.tasks.length} tasks)
-`
-    );
   }
   const result = await runWorker({
     db: db.db,
     runId,
     plan,
     scheduler,
-    pool,
     client: server.client,
     busFactory,
-    branchPrefix,
-    base,
     abortSignal: aborter.signal
   });
   const counts = countByStatus(db.db, runId);
@@ -3678,7 +3145,7 @@ async function executeRun(args) {
 }
 async function resolvePlanPathSmart(input, cwd, readPlanSelection) {
   if (input.flag !== void 0 && input.flag.length > 0) {
-    const resolved = path9.isAbsolute(input.flag) ? input.flag : path9.resolve(cwd, input.flag);
+    const resolved = path7.isAbsolute(input.flag) ? input.flag : path7.resolve(cwd, input.flag);
     if (await isFile(resolved)) {
       return { kind: "ok", path: resolved };
     }
@@ -3690,14 +3157,14 @@ async function resolvePlanPathSmart(input, cwd, readPlanSelection) {
   if (input.positional !== void 0 && input.positional.length > 0) {
     const plansDir2 = await getPlansDir(cwd);
     const candidates = [];
-    if (path9.isAbsolute(input.positional)) {
+    if (path7.isAbsolute(input.positional)) {
       candidates.push(input.positional);
     } else {
-      candidates.push(path9.resolve(cwd, input.positional));
-      candidates.push(path9.join(plansDir2, input.positional));
+      candidates.push(path7.resolve(cwd, input.positional));
+      candidates.push(path7.join(plansDir2, input.positional));
       if (!/\.(ya?ml)$/i.test(input.positional)) {
-        candidates.push(path9.join(plansDir2, `${input.positional}.yaml`));
-        candidates.push(path9.join(plansDir2, `${input.positional}.yml`));
+        candidates.push(path7.join(plansDir2, `${input.positional}.yaml`));
+        candidates.push(path7.join(plansDir2, `${input.positional}.yml`));
       }
     }
     for (const c2 of candidates) {
@@ -3731,7 +3198,7 @@ async function resolvePlanPathSmart(input, cwd, readPlanSelection) {
 }
 async function isFile(p) {
   try {
-    const st = await fs10.stat(p);
+    const st = await fs7.stat(p);
     return st.isFile();
   } catch {
     return false;
@@ -3740,7 +3207,7 @@ async function isFile(p) {
 async function findNewestYaml2(dir) {
   let entries;
   try {
-    entries = await fs10.readdir(dir);
+    entries = await fs7.readdir(dir);
   } catch {
     return null;
   }
@@ -3751,7 +3218,7 @@ async function findNewestYaml2(dir) {
   let newest = null;
   for (const name of yamls) {
     try {
-      const st = await fs10.stat(path9.join(dir, name));
+      const st = await fs7.stat(path7.join(dir, name));
       if (newest === null || st.mtimeMs > newest.mtime) {
         newest = { name, mtime: st.mtimeMs };
       }
@@ -3759,13 +3226,13 @@ async function findNewestYaml2(dir) {
       continue;
     }
   }
-  return newest ? path9.join(dir, newest.name) : null;
+  return newest ? path7.join(dir, newest.name) : null;
 }
 async function defaultReadPlanSelection(cwd) {
   const plansDir = await getPlansDir(cwd);
   let entries;
   try {
-    entries = await fs10.readdir(plansDir);
+    entries = await fs7.readdir(plansDir);
   } catch {
     return void 0;
   }
@@ -3775,9 +3242,9 @@ async function defaultReadPlanSelection(cwd) {
   if (yamls.length === 0) return void 0;
   const stats = await Promise.all(
     yamls.map(async (name) => {
-      const full = path9.join(plansDir, name);
+      const full = path7.join(plansDir, name);
       try {
-        const st = await fs10.stat(full);
+        const st = await fs7.stat(full);
         return { name, full, mtime: st.mtimeMs };
       } catch {
         return null;
@@ -3828,6 +3295,13 @@ function relativeTimeFromNow(thenMs) {
   const d = Math.round(h / 24);
   return `${d}d ago`;
 }
+function formatDuration(ms) {
+  const totalSeconds = Math.max(0, Math.round(ms / 1e3));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return `${minutes}m ${seconds}s`;
+}
 function isExitPromptError2(err) {
   return err !== null && typeof err === "object" && "name" in err && err.name === "ExitPromptError";
 }
@@ -3851,8 +3325,9 @@ function startStreamingLogger(args) {
     return `${hh}:${mm}:${ss}`;
   };
   const write = (line) => {
-    stderrWriter(`[${formatTs3(clock())}] ${line}
-`);
+    const msg = `[${formatTs3(clock())}] ${line}
+`;
+    stderrWriter(msg);
   };
   const writeRaw = (line) => {
     stderrWriter(`${line}
@@ -3885,6 +3360,11 @@ function startStreamingLogger(args) {
           write(
             `task.verify.failed ${id ?? "?"} attempt ${p.attempt}/${p.of} (${p.command} \u2192 exit ${p.exitCode}${timedOutSuffix})`
           );
+          const output = typeof p.output === "string" ? p.output : null;
+          if (output !== null && output.length > 0) {
+            const tail = output.trim().split("\n").slice(-3).map((l) => `    ${l}`).join("\n");
+            writeRaw(tail);
+          }
         } else {
           write(`task.verify.failed ${id ?? "?"}`);
         }
@@ -3893,14 +3373,14 @@ function startStreamingLogger(args) {
       case "task.succeeded": {
         succeeded += 1;
         const ms = id !== null ? event.ts - (taskStart.get(id) ?? event.ts) : 0;
-        write(`task.succeeded ${id ?? "?"} in ${Math.round(ms / 1e3)}s`);
+        write(`task.succeeded ${id ?? "?"} in ${formatDuration(ms)}`);
         write(`run.progress ${succeeded}/${totalTasks} succeeded`);
         break;
       }
       case "task.failed": {
         failed += 1;
         const ms = id !== null ? event.ts - (taskStart.get(id) ?? event.ts) : 0;
-        write(`task.failed ${id ?? "?"} in ${Math.round(ms / 1e3)}s`);
+        write(`task.failed ${id ?? "?"} in ${formatDuration(ms)}`);
         const detail = extractPhaseReason(event.payload);
         if (detail !== null) {
           writeRaw(`  \u2192 ${detail.phase}: ${truncate(detail.reason, 200)}`);
@@ -3965,6 +3445,12 @@ function startStreamingLogger(args) {
       case "task.touches.violation":
         write(`task.touches.violation ${id ?? "?"}`);
         break;
+      case "task.progress": {
+        const p = event.payload;
+        const message = p?.message ?? "(no message)";
+        write(`${id ?? "?"} > ${message}`);
+        break;
+      }
       // Other kinds (task.session.created, run.*) are intentionally
       // suppressed — too chatty for stdout. `pilot logs` carries the
       // full trace.
@@ -3972,8 +3458,39 @@ function startStreamingLogger(args) {
         break;
     }
   });
+  let progressPollTimer = null;
+  let lastProgressId = 0;
+  if (args.db) {
+    const pollDb = args.db;
+    const pollMs = args.progressPollMs ?? 2e3;
+    try {
+      const row = pollDb.query(
+        `SELECT MAX(id) as maxId FROM events WHERE run_id=? AND kind='task.progress'`
+      ).get(runId);
+      lastProgressId = row?.maxId ?? 0;
+    } catch {
+    }
+    progressPollTimer = setInterval(() => {
+      try {
+        const rows = pollDb.query(
+          `SELECT id, task_id, ts, payload FROM events WHERE run_id=? AND kind='task.progress' AND id > ? ORDER BY id`
+        ).all(runId, lastProgressId);
+        for (const row of rows) {
+          lastProgressId = row.id;
+          try {
+            const p = JSON.parse(row.payload);
+            const message = p?.message ?? "(no message)";
+            write(`${row.task_id ?? "?"} > ${message}`);
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }, pollMs);
+  }
   return () => {
     flushBlockedSummary();
+    if (progressPollTimer) clearInterval(progressPollTimer);
     unsub();
   };
 }
@@ -3994,11 +3511,11 @@ function deriveBranchPrefix(planBranchPrefix, slug, runId) {
   return `${base}/${runId}`;
 }
 async function deriveUniqueSlug(plan, planPath, cwd) {
-  const base = path9.basename(planPath, path9.extname(planPath)) || deriveSlug(plan.name);
+  const base = path7.basename(planPath, path7.extname(planPath)) || deriveSlug(plan.name);
   const dir = await getPlansDir(cwd);
-  const entries = await fs10.readdir(dir).catch(() => []);
+  const entries = await fs7.readdir(dir).catch(() => []);
   const existingSlugs = new Set(
-    entries.filter((n) => n.endsWith(".yaml") || n.endsWith(".yml")).map((n) => path9.basename(n, path9.extname(n)))
+    entries.filter((n) => n.endsWith(".yaml") || n.endsWith(".yml")).map((n) => path7.basename(n, path7.extname(n)))
   );
   existingSlugs.delete(base);
   return resolveUniqueSlug(base, existingSlugs);
@@ -4036,14 +3553,14 @@ Failed tasks (${failed.length}):
         const { phase, reason } = resolveFailureDetail(db, runId, t);
         const session = t.session_id ?? "(none \u2014 failed before session.create)";
         const worktree = t.worktree_path ?? "(none)";
-        const elapsed = t.started_at !== null && t.finished_at !== null ? Math.round((t.finished_at - t.started_at) / 1e3) : 0;
+        const elapsed = t.started_at !== null && t.finished_at !== null ? formatDuration(t.finished_at - t.started_at) : "0s";
         process.stdout.write(
           `  ${t.task_id}
     phase:    ${phase}
     reason:   ${truncateSummary(reason, 300)}
     session:  ${session}
     worktree: ${worktree}
-    elapsed:  ${elapsed}s   attempts: ${t.attempts}
+    elapsed:  ${elapsed}   attempts: ${t.attempts}
 
 `
         );
@@ -4089,12 +3606,16 @@ async function runCleanup(cleanup) {
   }
 }
 
-// src/pilot/cli/status.ts
-import { command as command4, flag as flag3, option as option3, optional as optional4, string as string4 } from "cmd-ts";
+// src/pilot/cli/build-resume.ts
+import { command as command4, flag as flag3, option as option3, optional as optional4, string as string4, number as cmdNumber2 } from "cmd-ts";
+import { execFile as execFileCb2 } from "child_process";
+import { promises as fs9 } from "fs";
+import * as path9 from "path";
+import { promisify as promisify2 } from "util";
 
 // src/pilot/cli/discover.ts
-import { promises as fs11 } from "fs";
-import * as path10 from "path";
+import { promises as fs8 } from "fs";
+import * as path8 from "path";
 async function discoverRun(args) {
   const cwd = args.cwd;
   if (args.runId !== void 0 && args.runId.length > 0) {
@@ -4102,7 +3623,7 @@ async function discoverRun(args) {
     const cwdDbPath = await getStateDbPath(cwd, args.runId);
     tried.push(cwdDbPath);
     try {
-      await fs11.stat(cwdDbPath);
+      await fs8.stat(cwdDbPath);
       const runDir = await getRunDir(cwd, args.runId);
       return { runId: args.runId, dbPath: cwdDbPath, runDir };
     } catch {
@@ -4110,14 +3631,14 @@ async function discoverRun(args) {
     const base = resolveBaseDir();
     let repoFolders;
     try {
-      repoFolders = await fs11.readdir(base);
+      repoFolders = await fs8.readdir(base);
     } catch {
       throw new Error(
         `pilot: no state.db for run ${JSON.stringify(args.runId)} (looked at ${tried.join(", ")}; base ${base} does not exist)`
       );
     }
     for (const folder of repoFolders) {
-      const candidateDbPath = path10.join(
+      const candidateDbPath = path8.join(
         base,
         folder,
         "pilot",
@@ -4127,15 +3648,15 @@ async function discoverRun(args) {
       );
       if (tried.includes(candidateDbPath)) continue;
       try {
-        const stat2 = await fs11.stat(path10.join(base, folder));
-        if (!stat2.isDirectory()) continue;
+        const stat = await fs8.stat(path8.join(base, folder));
+        if (!stat.isDirectory()) continue;
       } catch {
         continue;
       }
       tried.push(candidateDbPath);
       try {
-        await fs11.stat(candidateDbPath);
-        const candidateRunDir = path10.join(
+        await fs8.stat(candidateDbPath);
+        const candidateRunDir = path8.join(
           base,
           folder,
           "pilot",
@@ -4155,10 +3676,10 @@ async function discoverRun(args) {
     );
   }
   const pilot = await getPilotDir(cwd);
-  const runsDir = path10.join(pilot, "runs");
+  const runsDir = path8.join(pilot, "runs");
   let entries;
   try {
-    entries = await fs11.readdir(runsDir);
+    entries = await fs8.readdir(runsDir);
   } catch {
     throw new Error(
       `pilot: no runs found at ${runsDir} (run \`pilot build\` first)`
@@ -4166,10 +3687,10 @@ async function discoverRun(args) {
   }
   let newest = null;
   for (const id of entries) {
-    const dbPath = path10.join(runsDir, id, "state.db");
+    const dbPath = path8.join(runsDir, id, "state.db");
     let st;
     try {
-      st = await fs11.stat(dbPath);
+      st = await fs8.stat(dbPath);
     } catch {
       continue;
     }
@@ -4185,21 +3706,338 @@ async function discoverRun(args) {
   return {
     runId: newest.id,
     dbPath: newest.dbPath,
-    runDir: path10.join(runsDir, newest.id)
+    runDir: path8.join(runsDir, newest.id)
   };
 }
 
+// src/pilot/cli/build-resume.ts
+var execFileP2 = promisify2(execFileCb2);
+var buildResumeCmd = command4({
+  name: "build-resume",
+  description: "Resume a partially-completed pilot run from where it left off.",
+  args: {
+    run: option3({
+      long: "run",
+      type: optional4(string4),
+      description: "Run ID to resume. Defaults to the newest resumable run matching --plan (or interactive picker if multiple exist)."
+    }),
+    plan: option3({
+      long: "plan",
+      type: optional4(string4),
+      description: "Filter to runs that used this plan path (absolute, cwd-relative, or bare filename resolved against the plans dir). Disambiguates when multiple worktrees share a state dir."
+    }),
+    opencodePort: option3({
+      long: "opencode-port",
+      type: optional4(cmdNumber2),
+      description: "Port for the spawned opencode server (default: 0 = random)."
+    }),
+    quiet: flag3({
+      long: "quiet",
+      description: "Suppress per-task progress lines on stderr. Summary still prints."
+    })
+  },
+  handler: async (args) => {
+    await requirePlugin();
+    const code = await runBuildResume(args);
+    process.exit(code);
+  }
+});
+async function runBuildResume(opts) {
+  const cwd = process.cwd();
+  const stderrWriter = opts.stderrWriter ?? ((s) => void process.stderr.write(s));
+  let runId;
+  let dbPath;
+  let runDir;
+  try {
+    if (opts.run !== void 0 && opts.run.length > 0) {
+      const d = await discoverRun({ cwd, runId: opts.run });
+      runId = d.runId;
+      dbPath = d.dbPath;
+      runDir = d.runDir;
+    } else {
+      const planFilter = opts.plan !== void 0 && opts.plan.length > 0 ? await resolvePlanFilter(cwd, opts.plan) : void 0;
+      const resumable = await findLatestResumableRun(cwd, planFilter);
+      if (resumable === null) {
+        const suffix = planFilter ? ` matching plan "${path9.basename(planFilter)}"` : "";
+        process.stderr.write(
+          `pilot build-resume: no resumable runs found in this repo${suffix} (no run has non-succeeded tasks)
+`
+        );
+        return 2;
+      }
+      runId = resumable.runId;
+      dbPath = resumable.dbPath;
+      runDir = resumable.runDir;
+    }
+  } catch (err) {
+    process.stderr.write(
+      `pilot build-resume: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return 1;
+  }
+  const opened = openStateDb(dbPath);
+  const cleanup = [];
+  cleanup.push(() => opened.close());
+  const run2 = getRun(opened.db, runId);
+  if (run2 === null) {
+    process.stderr.write(
+      `pilot build-resume: state.db exists at ${dbPath} but has no row for ${runId}
+`
+    );
+    await runCleanup2(cleanup);
+    return 1;
+  }
+  const counts = countByStatus(opened.db, runId);
+  const remaining = counts.pending + counts.ready + counts.running + counts.failed + counts.blocked + counts.aborted;
+  if (remaining === 0) {
+    process.stderr.write(
+      `pilot build-resume: run ${runId} has no tasks to resume (all ${counts.succeeded} succeeded)
+`
+    );
+    await runCleanup2(cleanup);
+    return 2;
+  }
+  const planPath = run2.plan_path;
+  const loaded = await loadPlan(planPath);
+  if (!loaded.ok) {
+    process.stderr.write(
+      `pilot build-resume: plan at ${planPath} failed to load:
+` + loaded.errors.map((e) => `  - ${e.path}: ${e.message}`).join("\n") + `
+`
+    );
+    await runCleanup2(cleanup);
+    return 1;
+  }
+  const plan = loaded.plan;
+  const preflight = await runResumePreflight({ cwd, opened, runId });
+  if (!preflight.ok) {
+    process.stderr.write(`pilot build-resume: ${preflight.reason}
+`);
+    await runCleanup2(cleanup);
+    return 1;
+  }
+  for (const w of preflight.warnings) {
+    stderrWriter(`[pilot] ${w}
+`);
+  }
+  const { runSetupHook, SETUP_HOOK_RELATIVE_PATH } = await import("./setup-hook-FHTXMAQL.js");
+  const hookResult = await runSetupHook({
+    cwd,
+    onLine: (c2) => stderrWriter(c2)
+  });
+  switch (hookResult.kind) {
+    case "skipped":
+      break;
+    case "ok":
+      stderrWriter(
+        `[pilot] setup hook ${SETUP_HOOK_RELATIVE_PATH} passed (${Math.round(hookResult.durationMs / 1e3)}s)
+`
+      );
+      break;
+    case "not-executable":
+      stderrWriter(
+        `[pilot] setup hook ${hookResult.hookPath} is not executable. Run \`chmod +x ${SETUP_HOOK_RELATIVE_PATH}\` and re-run pilot.
+`
+      );
+      await runCleanup2(cleanup);
+      return 1;
+    case "timed-out":
+      stderrWriter(
+        `[pilot] setup hook ${hookResult.hookPath} timed out after ${Math.round(hookResult.timeoutMs / 1e3)}s
+`
+      );
+      await runCleanup2(cleanup);
+      return 1;
+    case "failed":
+      stderrWriter(
+        `[pilot] setup hook ${hookResult.hookPath} exited ${hookResult.exitCode} (after ${Math.round(hookResult.durationMs / 1e3)}s). Fix the environment and re-run pilot.
+`
+      );
+      await runCleanup2(cleanup);
+      return 1;
+    case "spawn-error":
+      stderrWriter(
+        `[pilot] setup hook ${hookResult.hookPath} failed to spawn: ${hookResult.error}
+`
+      );
+      await runCleanup2(cleanup);
+      return 1;
+  }
+  const resetIds = resetTasksForResume(opened.db, runId);
+  try {
+    markRunResumed(opened.db, runId);
+  } catch (err) {
+    process.stderr.write(
+      `pilot build-resume: cannot mark run as running: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    await runCleanup2(cleanup);
+    return 1;
+  }
+  appendEvent(opened.db, {
+    runId,
+    kind: "run.resumed",
+    payload: {
+      resetTaskIds: resetIds,
+      skippedSucceeded: counts.succeeded
+    }
+  });
+  if (opts.quiet !== true) {
+    stderrWriter(
+      `pilot build-resume: resuming run ${runId} \u2014 ${resetIds.length} task(s) reset (skipping ${counts.succeeded} succeeded)
+`
+    );
+  }
+  const branchPrefix = deriveBranchPrefix(plan.branch_prefix, run2.plan_slug, runId);
+  return executeRun({
+    db: opened,
+    runId,
+    plan,
+    planPath,
+    runDir,
+    branchPrefix,
+    cleanup,
+    opencodePort: opts.opencodePort,
+    quiet: opts.quiet,
+    stderrWriter
+  });
+}
+async function runResumePreflight(args) {
+  const { cwd, opened, runId } = args;
+  const { checkCwdSafety: checkCwdSafety2 } = await import("./safety-gate-WM3EWOCY.js");
+  const gate = await checkCwdSafety2(cwd);
+  if (!gate.ok) {
+    return { ok: false, reason: gate.reason };
+  }
+  const { listTasks: listTasks2 } = await import("./tasks-KJ3WN2KY.js");
+  const tasks = listTasks2(opened.db, runId);
+  const withBranch = tasks.filter(
+    (t) => t.branch !== null && t.branch.length > 0
+  );
+  if (withBranch.length > 0) {
+    const recordedBranch = withBranch[0].branch;
+    const current = await currentBranch(cwd);
+    if (current !== recordedBranch) {
+      return {
+        ok: false,
+        reason: `branch mismatch: run ${runId} was started on "${recordedBranch}", but cwd is currently on "${current}". Switch branches: \`git checkout ${recordedBranch}\``
+      };
+    }
+  }
+  return { ok: true, warnings: gate.warnings };
+}
+async function currentBranch(cwd) {
+  try {
+    const { stdout } = await execFileP2(
+      "git",
+      ["rev-parse", "--abbrev-ref", "HEAD"],
+      { cwd, timeout: 1e4 }
+    );
+    return stdout.toString().trim();
+  } catch {
+    return "";
+  }
+}
+async function findLatestResumableRun(cwd, planFilter) {
+  const { getPilotDir: getPilotDir2 } = await import("./paths-LT3QQKCF.js");
+  const pilot = await getPilotDir2(cwd);
+  const runsDir = path9.join(pilot, "runs");
+  let entries;
+  try {
+    entries = await fs9.readdir(runsDir);
+  } catch {
+    return null;
+  }
+  const candidates = [];
+  for (const id of entries) {
+    const dbPath = path9.join(runsDir, id, "state.db");
+    let st;
+    try {
+      st = await fs9.stat(dbPath);
+    } catch {
+      continue;
+    }
+    candidates.push({
+      runId: id,
+      dbPath,
+      runDir: path9.join(runsDir, id),
+      mtime: st.mtimeMs
+    });
+  }
+  candidates.sort((a, b) => b.mtime - a.mtime);
+  for (const c2 of candidates) {
+    const opened = openStateDb(c2.dbPath);
+    try {
+      if (planFilter !== void 0) {
+        const { getRun: getRun2 } = await import("./runs-QWPL3TKV.js");
+        const run2 = getRun2(opened.db, c2.runId);
+        if (!run2) continue;
+        const matches = run2.plan_path === planFilter || path9.basename(run2.plan_path) === path9.basename(planFilter);
+        if (!matches) continue;
+      }
+      const counts = countByStatus(opened.db, c2.runId);
+      const nonSucceeded = counts.pending + counts.ready + counts.running + counts.failed + counts.blocked + counts.aborted;
+      if (nonSucceeded > 0) {
+        return c2;
+      }
+    } finally {
+      opened.close();
+    }
+  }
+  void resolveBaseDir;
+  return null;
+}
+async function resolvePlanFilter(cwd, input) {
+  const { getPlansDir: getPlansDir2 } = await import("./paths-LT3QQKCF.js");
+  if (path9.isAbsolute(input)) return input;
+  const cwdRel = path9.resolve(cwd, input);
+  try {
+    await fs9.stat(cwdRel);
+    return cwdRel;
+  } catch {
+  }
+  const plansDir = await getPlansDir2(cwd);
+  const plansDirRel = path9.join(plansDir, input);
+  try {
+    await fs9.stat(plansDirRel);
+    return plansDirRel;
+  } catch {
+  }
+  if (!/\.(ya?ml)$/i.test(input)) {
+    for (const ext of [".yaml", ".yml"]) {
+      const withExt = path9.join(plansDir, `${input}${ext}`);
+      try {
+        await fs9.stat(withExt);
+        return withExt;
+      } catch {
+      }
+    }
+  }
+  return input;
+}
+async function runCleanup2(cleanup) {
+  while (cleanup.length > 0) {
+    const fn = cleanup.pop();
+    try {
+      await fn();
+    } catch {
+    }
+  }
+}
+
 // src/pilot/cli/status.ts
-var statusCmd = command4({
+import { command as command5, flag as flag4, option as option4, optional as optional5, string as string5 } from "cmd-ts";
+var statusCmd = command5({
   name: "status",
   description: "Print the run + task status for a pilot run.",
   args: {
-    run: option3({
+    run: option4({
       long: "run",
-      type: optional4(string4),
+      type: optional5(string5),
       description: "Run ID. Defaults to the newest run with a state.db."
     }),
-    json: flag3({
+    json: flag4({
       long: "json",
       description: "Emit JSON instead of human-readable text."
     })
@@ -4289,199 +4127,19 @@ function wrap(text, width) {
   return out;
 }
 
-// src/pilot/cli/resume.ts
-import { command as command5, option as option4, optional as optional5, string as string5 } from "cmd-ts";
-var resumeCmd = command5({
-  name: "resume",
-  description: "Continue a partially-completed pilot run.",
-  args: {
-    run: option4({
-      long: "run",
-      type: optional5(string5),
-      description: "Run ID. Defaults to the newest run."
-    })
-  },
-  handler: async ({ run: run2 }) => {
-    await requirePlugin();
-    const code = await runResume({ runId: run2 });
-    process.exit(code);
-  }
-});
-async function runResume(opts) {
-  let discovered;
-  try {
-    discovered = await discoverRun({
-      cwd: process.cwd(),
-      runId: opts.runId
-    });
-  } catch (err) {
-    process.stderr.write(
-      `${err instanceof Error ? err.message : String(err)}
-`
-    );
-    return 1;
-  }
-  const opened = openStateDb(discovered.dbPath);
-  const cleanup = [
-    () => opened.close()
-  ];
-  const run2 = getRun(opened.db, discovered.runId);
-  if (run2 === null) {
-    process.stderr.write(
-      `pilot resume: run ${discovered.runId} missing from DB
-`
-    );
-    await runCleanup2(cleanup);
-    return 1;
-  }
-  const loaded = await loadPlan(run2.plan_path);
-  if (!loaded.ok) {
-    process.stderr.write(
-      `pilot resume: cannot reload plan at ${run2.plan_path} (${loaded.kind})
-`
-    );
-    for (const e of loaded.errors) {
-      process.stderr.write(`  ${e.path}: ${e.message}
-`);
-    }
-    await runCleanup2(cleanup);
-    return 1;
-  }
-  if (run2.status === "pending") {
-    markRunRunning(opened.db, discovered.runId);
-  } else if (run2.status === "running") {
-  } else {
-    opened.db.run(
-      `UPDATE runs SET status='running', finished_at=NULL WHERE id=?`,
-      [discovered.runId]
-    );
-  }
-  appendEvent(opened.db, {
-    runId: discovered.runId,
-    kind: "run.resumed",
-    payload: { previousStatus: run2.status }
-  });
-  const runDir = await getRunDir(process.cwd(), discovered.runId);
-  return executeRun({
-    db: opened,
-    runId: discovered.runId,
-    plan: loaded.plan,
-    planPath: run2.plan_path,
-    runDir,
-    // Reconstruct the same branch prefix the original `pilot build` used.
-    // The runId segment is what makes branches unique per run; resume MUST
-    // match the original to find the existing worktrees.
-    branchPrefix: deriveBranchPrefix(
-      loaded.plan.branch_prefix,
-      run2.plan_slug,
-      discovered.runId
-    ),
-    cleanup
-  });
-}
-async function runCleanup2(cleanup) {
-  while (cleanup.length > 0) {
-    const fn = cleanup.pop();
-    try {
-      await fn();
-    } catch {
-    }
-  }
-}
-
-// src/pilot/cli/retry.ts
-import { command as command6, option as option5, optional as optional6, positional as positional4, string as string6, flag as flag4 } from "cmd-ts";
-var retryCmd = command6({
-  name: "retry",
-  description: "Reset a single task to pending. Optionally also re-run it.",
-  args: {
-    taskId: positional4({
-      type: string6,
-      displayName: "task-id",
-      description: "Task id to reset (e.g. T1)."
-    }),
-    run: option5({
-      long: "run",
-      type: optional6(string6),
-      description: "Run ID. Defaults to the newest run."
-    }),
-    runNow: flag4({
-      long: "run-now",
-      description: "After resetting, immediately run `pilot resume` on the same DB."
-    })
-  },
-  handler: async ({ taskId, run: run2, runNow }) => {
-    await requirePlugin();
-    const code = await runRetry({ taskId, runId: run2, runNow });
-    process.exit(code);
-  }
-});
-async function runRetry(opts) {
-  let discovered;
-  try {
-    discovered = await discoverRun({
-      cwd: process.cwd(),
-      runId: opts.runId
-    });
-  } catch (err) {
-    process.stderr.write(
-      `${err instanceof Error ? err.message : String(err)}
-`
-    );
-    return 1;
-  }
-  const opened = openStateDb(discovered.dbPath);
-  try {
-    const task = getTask(opened.db, discovered.runId, opts.taskId);
-    if (task === null) {
-      process.stderr.write(
-        `pilot retry: task ${JSON.stringify(opts.taskId)} not found in run ${discovered.runId}
-`
-      );
-      return 1;
-    }
-    const previousStatus = task.status;
-    try {
-      markPending(opened.db, discovered.runId, opts.taskId);
-    } catch (err) {
-      process.stderr.write(
-        `pilot retry: ${err instanceof Error ? err.message : String(err)}
-`
-      );
-      return 1;
-    }
-    appendEvent(opened.db, {
-      runId: discovered.runId,
-      taskId: opts.taskId,
-      kind: "task.retry",
-      payload: { previousStatus }
-    });
-    process.stdout.write(
-      `pilot retry: ${opts.taskId} reset to pending (was ${previousStatus})
-`
-    );
-  } finally {
-    opened.close();
-  }
-  if (opts.runNow) {
-    return runResume({ runId: discovered.runId });
-  }
-  return 0;
-}
-
 // src/pilot/cli/logs.ts
-import { command as command7, flag as flag5, option as option6, optional as optional7, positional as positional5, string as string7 } from "cmd-ts";
-var logsCmd = command7({
+import { command as command6, flag as flag5, option as option5, optional as optional6, positional as positional4, string as string6 } from "cmd-ts";
+var logsCmd = command6({
   name: "logs",
   description: "Print structured events for a task.",
   args: {
-    taskId: positional5({
-      type: string7,
+    taskId: positional4({
+      type: string6,
       displayName: "task-id"
     }),
-    run: option6({
+    run: option5({
       long: "run",
-      type: optional7(string7),
+      type: optional6(string6),
       description: "Run ID. Defaults to the newest run."
     }),
     json: flag5({
@@ -4601,172 +4259,18 @@ function summarizePayload(kind, payload) {
   return s;
 }
 
-// src/pilot/cli/worktrees.ts
-import { command as command8, flag as flag6, option as option7, optional as optional8, string as string8, subcommands } from "cmd-ts";
-import { promises as fs12 } from "fs";
-import * as path11 from "path";
-var listSubcmd = command8({
-  name: "list",
-  description: "List worktrees registered with the repo (filter to pilot ones).",
-  args: {
-    run: option7({
-      long: "run",
-      type: optional8(string8),
-      description: "Run ID for context. Defaults to the newest run."
-    })
-  },
-  handler: async ({ run: run2 }) => {
-    const code = await runWorktreesList({ runId: run2 });
-    process.exit(code);
-  }
-});
-var pruneSubcmd = command8({
-  name: "prune",
-  description: "Remove worktrees from succeeded tasks (default) or all (--all).",
-  args: {
-    run: option7({
-      long: "run",
-      type: optional8(string8),
-      description: "Run ID. Defaults to the newest run."
-    }),
-    all: flag6({
-      long: "all",
-      description: "Remove every pilot worktree for this run, even failed/aborted ones."
-    }),
-    dryRun: flag6({
-      long: "dry-run",
-      description: "Print what would be removed without removing."
-    })
-  },
-  handler: async ({ run: run2, all, dryRun }) => {
-    const code = await runWorktreesPrune({ runId: run2, all, dryRun });
-    process.exit(code);
-  }
-});
-var worktreesCmd = subcommands({
-  name: "worktrees",
-  description: "Inspect and prune pilot-managed git worktrees.",
-  cmds: {
-    list: listSubcmd,
-    prune: pruneSubcmd
-  }
-});
-async function runWorktreesList(opts) {
-  let discovered;
-  try {
-    discovered = await discoverRun({
-      cwd: process.cwd(),
-      runId: opts.runId
-    });
-  } catch (err) {
-    process.stderr.write(
-      `${err instanceof Error ? err.message : String(err)}
-`
-    );
-    return 1;
-  }
-  const all = await gitWorktreeList(process.cwd());
-  const wtBase = path11.join(discovered.runDir, "..");
-  const pilotDir = path11.dirname(path11.dirname(discovered.runDir));
-  const wtPrefix = path11.join(pilotDir, "worktrees", discovered.runId);
-  const filtered = all.filter((w) => w.path.startsWith(wtPrefix));
-  void wtBase;
-  if (filtered.length === 0) {
-    process.stdout.write(
-      `pilot worktrees list: no pilot worktrees for run ${discovered.runId}
-`
-    );
-    return 0;
-  }
-  for (const w of filtered) {
-    process.stdout.write(
-      `${w.path}	${w.head.slice(0, 7)}	${w.branch ?? "(detached)"}
-`
-    );
-  }
-  return 0;
-}
-async function runWorktreesPrune(opts) {
-  let discovered;
-  try {
-    discovered = await discoverRun({
-      cwd: process.cwd(),
-      runId: opts.runId
-    });
-  } catch (err) {
-    process.stderr.write(
-      `${err instanceof Error ? err.message : String(err)}
-`
-    );
-    return 1;
-  }
-  const opened = openStateDb(discovered.dbPath);
-  let candidates;
-  try {
-    const tasks = listTasks(opened.db, discovered.runId);
-    const run2 = getRun(opened.db, discovered.runId);
-    if (opts.all) {
-      candidates = tasks.map((t) => t.worktree_path).filter((p) => p !== null);
-    } else {
-      const safeStatuses = run2?.status === "completed";
-      candidates = tasks.filter((t) => safeStatuses && t.status === "succeeded").map((t) => t.worktree_path).filter((p) => p !== null);
-    }
-  } finally {
-    opened.close();
-  }
-  const uniq = [...new Set(candidates)];
-  if (uniq.length === 0) {
-    process.stdout.write(
-      `pilot worktrees prune: nothing to prune for run ${discovered.runId}` + (opts.all ? "" : " (use --all to force)") + "\n"
-    );
-    return 0;
-  }
-  if (opts.dryRun) {
-    process.stdout.write("Would remove:\n");
-    for (const p of uniq) process.stdout.write(`  ${p}
-`);
-    return 0;
-  }
-  let removed = 0;
-  let errors = 0;
-  for (const p of uniq) {
-    try {
-      await gitWorktreeRemove({
-        repoPath: process.cwd(),
-        worktreePath: p
-      });
-      try {
-        await fs12.rm(p, { recursive: true, force: true });
-      } catch {
-      }
-      removed++;
-    } catch (err) {
-      errors++;
-      process.stderr.write(
-        `pilot worktrees prune: failed to remove ${p}: ${err instanceof Error ? err.message : String(err)}
-`
-      );
-    }
-  }
-  process.stdout.write(
-    `pilot worktrees prune: removed ${removed}/${uniq.length} (${errors} errors)
-`
-  );
-  return errors > 0 ? 1 : 0;
-}
-
 // src/pilot/cli/cost.ts
-import { command as command9, flag as flag7, option as option8, optional as optional9, string as string9 } from "cmd-ts";
-var costCmd = command9({
+import { command as command7, flag as flag6, option as option6, optional as optional7, string as string7 } from "cmd-ts";
+var costCmd = command7({
   name: "cost",
   description: "Print per-task and total cost for a run.",
   args: {
-    run: option8({
+    run: option6({
       long: "run",
-      type: optional9(string9),
+      type: optional7(string7),
       description: "Run ID. Defaults to the newest run."
     }),
-    json: flag7({
+    json: flag6({
       long: "json",
       description: "Emit JSON instead of human-readable text."
     })
@@ -4828,8 +4332,8 @@ async function runCost(opts) {
 }
 
 // src/pilot/cli/plan-dir.ts
-import { command as command10 } from "cmd-ts";
-var planDirCmd = command10({
+import { command as command8 } from "cmd-ts";
+var planDirCmd = command8({
   name: "plan-dir",
   description: "Print the pilot plans directory for the current worktree (creates it if missing).",
   args: {},
@@ -4849,29 +4353,27 @@ var planDirCmd = command10({
 });
 
 // src/pilot/cli/index.ts
-var pilotSubcommand = subcommands2({
+var pilotSubcommand = subcommands({
   name: "pilot",
   description: "Pilot subsystem \u2014 plan, validate, build, and manage unattended task runs.",
   cmds: {
     validate: validateCmd,
     plan: planCmd,
     build: buildCmd,
+    "build-resume": buildResumeCmd,
     status: statusCmd,
-    resume: resumeCmd,
-    retry: retryCmd,
     logs: logsCmd,
-    worktrees: worktreesCmd,
     cost: costCmd,
     "plan-dir": planDirCmd
   }
 });
 
 // src/cli/cli-update.ts
-import * as fs13 from "fs";
-import * as path12 from "path";
-import * as os5 from "os";
+import * as fs10 from "fs";
+import * as path10 from "path";
+import * as os3 from "os";
 import { spawn as spawn3 } from "child_process";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var PACKAGE_NAME = "@glrs-dev/harness-plugin-opencode";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var c = {
@@ -4896,12 +4398,12 @@ function isMajorBump(current, latest) {
   return latest.major > current.major;
 }
 function getStateFilePath() {
-  const cacheHome = process.env["XDG_CACHE_HOME"] ?? path12.join(os5.homedir(), ".cache");
-  return path12.join(cacheHome, "harness-opencode", "cli-update.json");
+  const cacheHome = process.env["XDG_CACHE_HOME"] ?? path10.join(os3.homedir(), ".cache");
+  return path10.join(cacheHome, "harness-opencode", "cli-update.json");
 }
 function readState() {
   try {
-    const raw = fs13.readFileSync(getStateFilePath(), "utf8");
+    const raw = fs10.readFileSync(getStateFilePath(), "utf8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -4910,21 +4412,21 @@ function readState() {
 function writeState(state) {
   try {
     const statePath = getStateFilePath();
-    fs13.mkdirSync(path12.dirname(statePath), { recursive: true });
-    fs13.writeFileSync(statePath, JSON.stringify(state));
+    fs10.mkdirSync(path10.dirname(statePath), { recursive: true });
+    fs10.writeFileSync(statePath, JSON.stringify(state));
   } catch {
   }
 }
 function readInstalledVersion() {
-  const here = path12.dirname(fileURLToPath2(import.meta.url));
+  const here = path10.dirname(fileURLToPath3(import.meta.url));
   const candidates = [
-    path12.join(here, "..", "package.json"),
-    path12.join(here, "..", "..", "package.json"),
-    path12.join(here, "package.json")
+    path10.join(here, "..", "package.json"),
+    path10.join(here, "..", "..", "package.json"),
+    path10.join(here, "package.json")
   ];
   for (const candidate of candidates) {
     try {
-      const raw = fs13.readFileSync(candidate, "utf8");
+      const raw = fs10.readFileSync(candidate, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed.name === PACKAGE_NAME && typeof parsed.version === "string") {
         return parsed.version;
@@ -5050,15 +4552,15 @@ Upgrade Node or run via a compatible Bun runtime. See the "engines" field in pac
   }
 }
 var VERSION = "0.1.0";
-var installCmd = command11({
+var installCmd = command9({
   name: "install",
   description: 'Add "@glrs-dev/harness-plugin-opencode" to your opencode.json plugin array.',
   args: {
-    dryRun: flag8({
+    dryRun: flag7({
       long: "dry-run",
       description: "Preview changes without writing."
     }),
-    pin: flag8({
+    pin: flag7({
       long: "pin",
       description: "Pin to the current exact version (e.g. @0.1.0)."
     })
@@ -5067,11 +4569,11 @@ var installCmd = command11({
     await install({ dryRun, pin });
   }
 });
-var uninstallCmd = command11({
+var uninstallCmd = command9({
   name: "uninstall",
   description: 'Remove "@glrs-dev/harness-plugin-opencode" from your opencode.json plugin array.',
   args: {
-    dryRun: flag8({
+    dryRun: flag7({
       long: "dry-run",
       description: "Preview changes without writing."
     })
@@ -5080,7 +4582,7 @@ var uninstallCmd = command11({
     uninstall({ dryRun });
   }
 });
-var doctorCmd = command11({
+var doctorCmd = command9({
   name: "doctor",
   description: "Check installation health (OpenCode CLI, plugin registration, MCP backends).",
   args: {},
@@ -5088,22 +4590,22 @@ var doctorCmd = command11({
     doctor();
   }
 });
-var planCheckCmd = command11({
+var planCheckCmd = command9({
   name: "plan-check",
   description: "Parse a plan file's plan-state fence (legacy markdown plans).",
   args: {
-    run: option9({
+    run: option7({
       long: "run",
-      type: optional10(string10),
+      type: optional8(string8),
       description: "Print verify commands for pending items, one per line."
     }),
-    check: option9({
+    check: option7({
       long: "check",
-      type: optional10(string10),
+      type: optional8(string8),
       description: "Structural validation; exits 1 if any item is invalid."
     }),
     rest: restPositionals({
-      type: string10,
+      type: string8,
       displayName: "plan-path",
       description: "Path to a plan markdown file. Required unless --run / --check is given."
     })
@@ -5120,7 +4622,7 @@ var planCheckCmd = command11({
     planCheck(legacy);
   }
 });
-var planDirCmd2 = command11({
+var planDirCmd2 = command9({
   name: "plan-dir",
   description: "Print the repo-shared plan directory for the current worktree (resolves + creates + migrates legacy).",
   args: {},
@@ -5139,15 +4641,15 @@ var planDirCmd2 = command11({
     }
   }
 });
-var installPluginCmd = command11({
+var installPluginCmd = command9({
   name: "install-plugin",
   description: 'Add "@glrs-dev/harness-plugin-opencode" to your opencode.json plugin array.',
   args: {
-    dryRun: flag8({
+    dryRun: flag7({
       long: "dry-run",
       description: "Preview changes without writing."
     }),
-    pin: flag8({
+    pin: flag7({
       long: "pin",
       description: "Pin to the current exact version (e.g. @0.1.0)."
     })
@@ -5156,7 +4658,7 @@ var installPluginCmd = command11({
     await install({ dryRun, pin });
   }
 });
-var cli = subcommands3({
+var cli = subcommands2({
   name: "glrs-oc",
   description: "OpenCode agent harness CLI.",
   version: VERSION,