@autopilot-harness/cli 0.2.12 → 0.2.13

package/dist/assets/vendor/runtime.mjs

@@ -42,6 +42,7 @@ var en_default = {
     recover_ambient: "Recover: the previous turn ended with an error. Continue your current work; Autopilot RUN is not active.",
     review_complete: "Review complete. All {total} confirm rounds passed; the review chain has ended. If the working tree still has uncommitted changes from this session, local commit only per the safe checklist (never stage .env/secrets/.autopilot runtime; no push unless the user asks); if clean, briefly confirm only.",
     stuck: "Stuck: no progress for several stops. Change strategy or send Autopilot RESUME after fixing.",
+    stuck_soft: "Stuck: no progress for several stops (missing completion evidence). Change strategy, write matching .autopilot/verify-last.json, then end the turn. Session stays armed \u2014 Autopilot RESUME is not required unless the session was paused.",
     verify_fix: "Verify failed ({reason}). Fix verify commands and rewrite verify-last.json; do not advance.",
     need_evidence: `Need evidence: no-code item {currentId}{currentTitleSuffix} cannot advance without matching soft completion evidence. Write .autopilot/verify-last.json with itemId "{currentId}" and ok: true (only after this item's work is done). Then end the turn so the stop hook can advance/done. Do not ask the user to continue; do not invent Advance/Done.`,
     track_pick: "Select a plan by number or slug."
@@ -118,6 +119,7 @@ var zh_CN_default = {
     recover_ambient: "\u6062\u590D\uFF1A\u4E0A\u4E00\u56DE\u5408\u51FA\u9519\u3002\u7EE7\u7EED\u5F53\u524D\u4EFB\u52A1\uFF08\u672A\u5728\u6267\u884C checklist\uFF09\u3002",
     review_complete: "\u81EA\u5BA1\u5B8C\u6210\u3002\u8FDE\u7EED {total} \u8F6E\u786E\u8BA4\u5DF2\u901A\u8FC7\uFF0C\u81EA\u5BA1\u94FE\u5DF2\u7ED3\u675F\u3002\u82E5\u5DE5\u4F5C\u533A\u4ECD\u6709\u672C\u4F1A\u8BDD\u672A\u63D0\u4EA4\u6539\u52A8\uFF0C\u6309\u5B89\u5168\u6E05\u5355\u672C\u5730 commit\uFF08\u52FF stage .env/\u5BC6\u94A5/.autopilot \u8FD0\u884C\u65F6\uFF1B\u52FF push\uFF0C\u9664\u975E\u7528\u6237\u660E\u786E\u8981\u6C42\uFF09\uFF1B\u5DF2\u5E72\u51C0\u5219\u53EA\u7B80\u77ED\u786E\u8BA4\u5373\u53EF\u3002",
     stuck: "\u5361\u4F4F\uFF1A\u8FDE\u7EED\u591A\u8F6E\u65E0\u8FDB\u5C55\u3002\u8BF7\u6362\u7B56\u7565\uFF0C\u6216\u4FEE\u597D\u540E\u53D1\u9001 Autopilot RESUME\u3002",
+    stuck_soft: "\u5361\u4F4F\uFF1A\u8FDE\u7EED\u591A\u8F6E\u65E0\u8FDB\u5C55\uFF08\u7F3A\u5B8C\u6210\u8BC1\u636E\uFF09\u3002\u8BF7\u6362\u7B56\u7565\u5E76\u5199\u5165\u5339\u914D\u7684 .autopilot/verify-last.json \u540E\u7ED3\u675F\u56DE\u5408\u3002\u4F1A\u8BDD\u4ECD\u5728\u8FD0\u884C\uFF0C\u65E0\u9700 RESUME\uFF1B\u4EC5\u5728\u5DF2 pause \u65F6\u624D\u53D1\u9001 Autopilot RESUME\u3002",
     verify_fix: "\u6821\u9A8C\u5931\u8D25\uFF08{reason}\uFF09\u3002\u8BF7\u4FEE\u590D verify \u547D\u4EE4\u5E76\u91CD\u5199 verify-last.json\uFF1B\u4E0D\u8981\u63A8\u8FDB\u3002",
     need_evidence: '\u9700\u8981\u5B8C\u6210\u8BC1\u636E\uFF1A\u65E0\u4EE3\u7801\u6539\u52A8\u9879 {currentId}{currentTitleSuffix} \u7F3A\u5C11\u5339\u914D\u7684 soft \u5B8C\u6210\u8BC1\u636E\uFF0C\u65E0\u6CD5\u63A8\u8FDB\u3002\u8BF7\u5199\u5165 .autopilot/verify-last.json\uFF08itemId \u4E3A "{currentId}"\uFF0Cok: true\uFF1B\u987B\u5728\u8BE5\u9879\u5DE5\u4F5C\u5B8C\u6210\u540E\uFF09\u3002\u7136\u540E\u7ED3\u675F\u672C\u56DE\u5408\uFF0C\u7531 stop hook \u63A8\u8FDB/\u5B8C\u6210\u3002\u4E0D\u8981\u8BA9\u7528\u6237\u8BF4\u300C\u7EE7\u7EED\u300D\uFF1B\u4E0D\u8981\u81EA\u884C\u53D1\u660E\u63A8\u8FDB/\u5B8C\u6210\u6307\u4EE4\u3002',
     track_pick: "\u8BF7\u7528\u6570\u5B57\u6216 slug \u9009\u62E9\u8981\u6267\u884C\u7684 plan\u3002"
@@ -2398,6 +2400,380 @@ function pendingRedeliverAllowed(lastRedeliverAt) {
   return Date.now() - t >= PENDING_REDELIVER_COOLDOWN_MS;
 }
 
+// ../core/src/code-edit-detector.ts
+import { spawnSync } from "node:child_process";
+import path7 from "node:path";
+
+// ../core/src/autopilot-ignore.ts
+import fs7 from "node:fs";
+import path6 from "node:path";
+var DEFAULT_AUTOPILOT_IGNORE_TEXT = `# Autopilot \u2014 paths that do NOT trigger self-review (gitignore syntax).
+#
+# What this file is:
+#   - Controls whether an afterFileEdit counts as "product code" (opens fix/confirm).
+#   - Does NOT change \`git diff\` / \`git status\` output (that is \`.gitignore\`).
+#   - Review followups ask the agent to skip these paths when reading diffs (soft).
+#
+# Semantics:
+#   - Same glob rules as gitignore; last matching pattern wins.
+#   - Use \`!\` to force-include an exception (e.g. \`!docs/feed/**/*.yml\`).
+#   - Markdown (*.md / *.mdx) is NOT ignored by default \u2014 design docs can be reviewed.
+#   - \`docs/**\` is NOT ignored by default.
+#   - Also skip untracked paths ignored by \`.gitignore\` (tracked files still count).
+#
+# Later (not implemented): hard-filtered review-diff / path ledger \u2014 see
+# docs/autopilot/workflows/autopilot-executing.md (B2 strong).
+
+# Runtime / editor (prefer also listing these in .gitignore)
+.autopilot/**
+.cursor/**
+.claude/**
+
+# Planning artifacts
+plans/**
+
+# Common build / vendor trees
+node_modules/**
+dist/**
+build/**
+out/**
+target/**
+.target/**
+coverage/**
+.venv/**
+venv/**
+__pycache__/**
+
+# Lockfiles / package manager noise
+package-lock.json
+pnpm-lock.yaml
+yarn.lock
+bun.lock
+bun.lockb
+Cargo.lock
+poetry.lock
+composer.lock
+
+# Media / binary (do not trigger self-review)
+*.png
+*.jpg
+*.jpeg
+*.gif
+*.webp
+*.ico
+*.svg
+*.bmp
+*.mp3
+*.mp4
+*.wav
+*.webm
+*.mov
+*.woff
+*.woff2
+*.ttf
+*.otf
+*.eot
+*.pdf
+*.zip
+*.gz
+*.tgz
+*.7z
+*.rar
+*.jar
+*.class
+*.o
+*.a
+*.so
+*.dylib
+*.dll
+*.exe
+*.wasm
+
+# Prose / data noise
+*.txt
+*.html
+*.htm
+*.csv
+*.tsv
+*.log
+*.map
+*.min.js
+*.min.css
+`;
+var MAX_AUTOPILOT_IGNORE_BYTES = 1e6;
+var MAX_AUTOPILOT_IGNORE_LINE_CHARS = 4096;
+var MAX_AUTOPILOT_IGNORE_PATTERNS = 1e4;
+var ignoreCache = /* @__PURE__ */ new Map();
+function escapeRegexChar(ch) {
+  return ch.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function globBodyToRegex(glob) {
+  let out = "";
+  for (let i = 0; i < glob.length; ) {
+    const ch = glob[i];
+    if (ch === "*" && glob[i + 1] === "*") {
+      if (glob[i + 2] === "/") {
+        out += "(?:.*/)?";
+        i += 3;
+        continue;
+      }
+      out += ".*";
+      i += 2;
+      continue;
+    }
+    if (ch === "*") {
+      out += "[^/]*";
+      i += 1;
+      continue;
+    }
+    if (ch === "?") {
+      out += "[^/]";
+      i += 1;
+      continue;
+    }
+    out += escapeRegexChar(ch);
+    i += 1;
+  }
+  return out;
+}
+function compilePattern(raw) {
+  let line = raw.trim();
+  if (!line || line.startsWith("#")) return null;
+  if (line.length > MAX_AUTOPILOT_IGNORE_LINE_CHARS) return null;
+  let negated = false;
+  if (line.startsWith("!")) {
+    negated = true;
+    line = line.slice(1).trim();
+    if (!line || line.startsWith("#")) return null;
+  }
+  const dirOnly = line.endsWith("/");
+  if (dirOnly) line = line.slice(0, -1);
+  if (!line) return null;
+  if (line.length > MAX_AUTOPILOT_IGNORE_LINE_CHARS) return null;
+  let anchored = false;
+  if (line.startsWith("/")) {
+    anchored = true;
+    line = line.slice(1);
+  }
+  const body = globBodyToRegex(line);
+  let regexSource;
+  if (anchored) {
+    regexSource = `^${body}`;
+    if (dirOnly || line.endsWith("/**") || line.endsWith("/*")) {
+      regexSource += "(?:/.*)?";
+    }
+    regexSource += "$";
+  } else if (line.includes("/")) {
+    regexSource = `(?:^|.*/)${body}`;
+    if (dirOnly || line.endsWith("/**") || line.endsWith("/*")) {
+      regexSource += "(?:/.*)?";
+    }
+    regexSource += "$";
+  } else {
+    regexSource = `(?:^|.*/)?${body}$`;
+  }
+  return { negated, regex: new RegExp(regexSource) };
+}
+function parseAutopilotIgnore(text) {
+  const patterns = [];
+  for (const rawLine of text.split(/\r?\n/)) {
+    const compiled = compilePattern(rawLine);
+    if (!compiled) continue;
+    patterns.push(compiled);
+    if (patterns.length >= MAX_AUTOPILOT_IGNORE_PATTERNS) break;
+  }
+  return patterns;
+}
+var DEFAULT_AUTOPILOT_IGNORE_PATTERNS = parseAutopilotIgnore(
+  DEFAULT_AUTOPILOT_IGNORE_TEXT
+);
+function normalizeRelativePath(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function isAutopilotIgnoredPath(relativePath, patterns) {
+  const norm = normalizeRelativePath(relativePath);
+  let ignored = false;
+  for (const pat of patterns) {
+    if (pat.regex.test(norm)) {
+      ignored = !pat.negated;
+    }
+  }
+  return ignored;
+}
+function realpathForCompare(absPath) {
+  try {
+    return fs7.realpathSync(absPath);
+  } catch {
+  }
+  let dir = path6.dirname(absPath);
+  const base = path6.basename(absPath);
+  const missing = [];
+  for (; ; ) {
+    try {
+      const realDir = fs7.realpathSync(dir);
+      return path6.join(realDir, ...missing, base);
+    } catch {
+      const parent = path6.dirname(dir);
+      if (parent === dir) return absPath;
+      missing.unshift(path6.basename(dir));
+      dir = parent;
+    }
+  }
+}
+function toProjectRelativePath(filePath, projectRoot) {
+  const posix = filePath.replace(/\\/g, "/");
+  if (!projectRoot?.trim()) {
+    return normalizeRelativePath(posix);
+  }
+  const root = realpathForCompare(path6.resolve(projectRoot));
+  const abs = realpathForCompare(
+    path6.isAbsolute(posix) ? path6.resolve(posix) : path6.resolve(root, posix)
+  );
+  const rel = path6.relative(root, abs);
+  if (rel.startsWith("..") || path6.isAbsolute(rel)) {
+    return "";
+  }
+  return normalizeRelativePath(rel.replace(/\\/g, "/"));
+}
+function loadAutopilotIgnorePatterns(projectRoot) {
+  const root = path6.resolve(projectRoot);
+  const filePath = path6.join(root, ".autopilotignore");
+  let st;
+  try {
+    st = fs7.lstatSync(filePath);
+  } catch {
+    return DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
+  }
+  if (st.isSymbolicLink() || !st.isFile()) {
+    return DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
+  }
+  if (st.size > MAX_AUTOPILOT_IGNORE_BYTES) {
+    return DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
+  }
+  const cached = ignoreCache.get(root);
+  if (cached && cached.mtimeMs === st.mtimeMs) {
+    return cached.patterns;
+  }
+  let text;
+  try {
+    text = fs7.readFileSync(filePath, "utf8");
+  } catch {
+    return DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
+  }
+  if (text.length > MAX_AUTOPILOT_IGNORE_BYTES) {
+    return DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
+  }
+  const patterns = parseAutopilotIgnore(text);
+  ignoreCache.set(root, { mtimeMs: st.mtimeMs, patterns });
+  return patterns;
+}
+
+// ../core/src/code-edit-detector.ts
+function isUntrackedGitIgnored(projectRoot, relativePath) {
+  if (!relativePath || relativePath.includes("\0")) return false;
+  try {
+    const r = spawnSync(
+      "git",
+      ["check-ignore", "-q", "--", relativePath],
+      {
+        cwd: projectRoot,
+        encoding: "utf8",
+        timeout: 5e3,
+        windowsHide: true,
+        shell: false
+      }
+    );
+    return r.status === 0;
+  } catch {
+    return false;
+  }
+}
+function isProductCodeEdit(filePath, opts) {
+  const relative = toProjectRelativePath(filePath, opts?.projectRoot);
+  if (!relative) return false;
+  const patterns = opts?.projectRoot?.trim() ? loadAutopilotIgnorePatterns(opts.projectRoot) : DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
+  if (isAutopilotIgnoredPath(relative, patterns)) return false;
+  const root = opts?.projectRoot?.trim();
+  if (root && isUntrackedGitIgnored(root, relative)) return false;
+  return true;
+}
+var MAX_DIRTY_PATHS_COLLECT = 2e3;
+var MAX_DIRTY_PATHS_CLASSIFY = 200;
+function gitDirtyRelativePaths(projectRoot) {
+  if (!projectRoot || projectRoot.includes("\0")) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushZ = (stdout) => {
+    for (const raw of stdout.split("\0")) {
+      const p = raw.replace(/\r$/, "");
+      if (!p) continue;
+      if (seen.has(p)) continue;
+      seen.add(p);
+      out.push(p);
+      if (out.length >= MAX_DIRTY_PATHS_COLLECT) return;
+    }
+  };
+  try {
+    const tracked = spawnSync(
+      "git",
+      ["diff", "--name-only", "-z", "HEAD", "--"],
+      {
+        cwd: projectRoot,
+        encoding: "utf8",
+        timeout: 5e3,
+        windowsHide: true,
+        shell: false
+      }
+    );
+    if (tracked.error || tracked.status !== 0) {
+      return [];
+    }
+    if (tracked.stdout) pushZ(tracked.stdout);
+    if (out.length >= MAX_DIRTY_PATHS_COLLECT) return out;
+    const untracked = spawnSync(
+      "git",
+      ["ls-files", "-o", "--exclude-standard", "-z", "--"],
+      {
+        cwd: projectRoot,
+        encoding: "utf8",
+        timeout: 5e3,
+        windowsHide: true,
+        shell: false
+      }
+    );
+    if (!untracked.error && untracked.status === 0 && untracked.stdout) {
+      pushZ(untracked.stdout);
+    }
+  } catch {
+    return [];
+  }
+  return out;
+}
+function hasDirtyProductCode(projectRoot) {
+  const root = normalizeProjectRoot(projectRoot);
+  if (!root) return false;
+  const relatives = gitDirtyRelativePaths(root);
+  const patterns = loadAutopilotIgnorePatterns(root);
+  let classified = 0;
+  for (const rel of relatives) {
+    if (!rel || rel.includes("\0") || path7.isAbsolute(rel) || rel.split(/[/\\]/).includes("..")) {
+      continue;
+    }
+    const abs = path7.join(root, rel);
+    const relative = toProjectRelativePath(abs, root);
+    if (!relative) continue;
+    if (isAutopilotIgnoredPath(relative, patterns)) continue;
+    classified += 1;
+    if (classified > MAX_DIRTY_PATHS_CLASSIFY) {
+      return false;
+    }
+    if (isProductCodeEdit(abs, { projectRoot: root })) {
+      return true;
+    }
+  }
+  return false;
+}
+
 // ../core/src/review-engine.ts
 function defaultRender(kind, vars) {
   switch (kind) {
@@ -2421,6 +2797,8 @@ function defaultRender(kind, vars) {
       return `Review complete. All ${vars.total ?? 5} confirm rounds passed; the review chain has ended. If the working tree still has uncommitted changes from this session, local commit only per the safe checklist (never stage .env/secrets/.autopilot runtime; no push unless the user asks); if clean, briefly confirm only.`;
     case "stuck":
       return `Stuck: no progress for several stops. Change strategy or send Autopilot RESUME after fixing.`;
+    case "stuck_soft":
+      return `Stuck: no progress for several stops (missing completion evidence). Change strategy, write matching .autopilot/verify-last.json, then end the turn. Session stays armed \u2014 Autopilot RESUME is not required unless the session was paused.`;
     case "verify_fix":
       return `Verify failed (${vars.reason ?? "unknown"}). Fix verify commands and rewrite verify-last.json; do not advance.`;
     case "need_evidence":
@@ -2527,6 +2905,31 @@ var ReviewEngine = class {
       return fromPending;
     });
   }
+  /**
+   * Stop-time arm when Shell (or other non-afterFileEdit) dirtied product paths.
+   * - `clean`: no product dirty → caller may soft E0
+   * - `armed`: code_edited set → caller must prefer E2 (never soft)
+   * - `dirty_unarmed`: dirty seen but arm failed → caller must not soft
+   *   (otherwise unreviewed product could soft-advance)
+   */
+  maybeArmCodeEditedFromDirtyTree(session) {
+    const root = this.trustedProjectRoot();
+    if (!root) return "clean";
+    let dirty = false;
+    try {
+      dirty = hasDirtyProductCode(root);
+    } catch {
+      return "dirty_unarmed";
+    }
+    if (!dirty) return "clean";
+    try {
+      this.onCodeEdited(session.conversation_id);
+    } catch {
+      return "dirty_unarmed";
+    }
+    const live = this.store.getReviewChain(session.conversation_id);
+    return live?.code_edited === 1 ? "armed" : "dirty_unarmed";
+  }
   handleStop(input) {
     if (!this.store.isConversationIdOk(input.conversationId)) {
       return null;
@@ -2688,10 +3091,48 @@ var ReviewEngine = class {
           return null;
         }
       }
-      const inChain = chainNow.chain_pending === 1 || chainNow.fix_round > 0 && isChecklistExecuting(session);
-      if (chainNow.confirm_left === null && chainNow.item_confirm_complete === 0 && inChain) {
-        return this.e3ArmConfirm(session, chainNow);
-      }
+      const inChain = chainNow.chain_pending === 1 || chainNow.fix_round > 0 && isChecklistExecuting(session);
+      if (chainNow.confirm_left === null && chainNow.item_confirm_complete === 0 && inChain) {
+        return this.e3ArmConfirm(session, chainNow);
+      }
+      if (chainNow.code_edited === 0 && isChecklistExecuting(session)) {
+        const dirtyArm = this.maybeArmCodeEditedFromDirtyTree(session);
+        if (dirtyArm === "dirty_unarmed") {
+          return null;
+        }
+        if (dirtyArm === "armed") {
+          const armed = this.store.getReviewChain(session.conversation_id) ?? chainNow;
+          if (armed.code_edited === 1) {
+            const tip = armed.pending_followup?.trim() ?? "";
+            if (isRecoverOrStuckFollowupMessage(tip)) {
+              const again = this.tryRedeliverPending(
+                session.conversation_id,
+                armed,
+                events,
+                transcriptPath
+              );
+              if (again) return again;
+              return null;
+            }
+            const fix = this.e2Fix(session, armed);
+            if (fix) return fix;
+            const afterE2 = this.store.getReviewChain(session.conversation_id) ?? armed;
+            const afterTip = afterE2.pending_followup?.trim() ?? "";
+            if (isRecoverOrStuckFollowupMessage(afterTip)) {
+              const again = this.tryRedeliverPending(
+                session.conversation_id,
+                afterE2,
+                events,
+                transcriptPath
+              );
+              if (again) return again;
+              return null;
+            }
+            return null;
+          }
+          return null;
+        }
+      }
       return this.e0NoCodeContinue(session, chainNow);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -3207,10 +3648,10 @@ var ReviewEngine = class {
    * salvage again — the prior tip does not cover the new failure.
    */
   classifyCompletedOrphan(transcriptPath) {
-    const path10 = transcriptPath?.trim();
-    if (!path10) return "none";
+    const path11 = transcriptPath?.trim();
+    if (!path11) return "none";
     try {
-      const events = readTranscriptTail(path10);
+      const events = readTranscriptTail(path11);
       const errIdx = latestUnresolvedTurnEndedErrorIndex(events);
       if (errIdx < 0) return "none";
       for (let i = events.length - 1; i > errIdx; i--) {
@@ -3924,28 +4365,16 @@ var ReviewEngine = class {
       }
       const nextIdle = sess.idle_stop_count + 1;
       const nowStuck = nextIdle >= this.config.maxIdleStops;
-      if (nowStuck) {
-        this.store.upsertSession({
-          conversation_id: cid2,
-          project_root: sess.project_root,
-          code_root: sess.code_root,
-          idle_stop_count: nextIdle,
-          paused: 1,
-          paused_reason: "stuck",
-          armed: 0
-        });
-      } else {
-        this.store.upsertSession({
-          conversation_id: cid2,
-          project_root: sess.project_root,
-          code_root: sess.code_root,
-          idle_stop_count: nextIdle
-        });
-      }
+      this.store.upsertSession({
+        conversation_id: cid2,
+        project_root: sess.project_root,
+        code_root: sess.code_root,
+        idle_stop_count: nextIdle
+      });
       const kind = nowStuck ? "stuck" : "need_evidence";
       const title = (lockedItem.title ?? "").trim();
       const message = this.render(
-        kind,
+        nowStuck ? "stuck_soft" : "need_evidence",
         nowStuck ? {} : {
           currentId: lockedItem.id,
           currentTitle: title,
@@ -4304,8 +4733,8 @@ var ReviewEngine = class {
       let unchecked = checklist.unchecked;
       let next = checklist.next;
       let targets = null;
-      const path10 = lockedSession.checklist_path?.trim() ?? "";
-      const onChecklistPath = isChecklistExecuting(lockedSession) && path10.length > 0;
+      const path11 = lockedSession.checklist_path?.trim() ?? "";
+      const onChecklistPath = isChecklistExecuting(lockedSession) && path11.length > 0;
       if (onChecklistPath) {
         const refreshed = this.parseSessionChecklist(lockedSession);
         if (!refreshed?.checklist) {
@@ -4437,28 +4866,7 @@ var ReviewEngine = class {
     } catch {
     }
   }
-  incrementIdle(session) {
-    const next = session.idle_stop_count + 1;
-    if (next >= this.config.maxIdleStops) {
-      this.store.upsertSession({
-        conversation_id: session.conversation_id,
-        project_root: session.project_root,
-        code_root: session.code_root,
-        idle_stop_count: next,
-        paused: 1,
-        paused_reason: "stuck",
-        armed: 0
-      });
-    } else {
-      this.store.upsertSession({
-        conversation_id: session.conversation_id,
-        project_root: session.project_root,
-        code_root: session.code_root,
-        idle_stop_count: next
-      });
-    }
-  }
-  /** After a no-progress stop that didn't inject, check stuck threshold. */
+  /** After a hard-stuck pause that didn't inject, surface stuck tip. */
   checkStuck(session) {
     const fresh = this.store.getSession(session.conversation_id);
     if (!fresh) return null;
@@ -4663,8 +5071,8 @@ function applyResumeReview(store, conversationId) {
 }
 
 // ../core/src/project-config.ts
-import fs7 from "node:fs";
-import path6 from "node:path";
+import fs8 from "node:fs";
+import path8 from "node:path";
 var MAX_CONFIG_BYTES = 1e6;
 var DEFAULT_PROJECT_REVIEW_CONFIG = {
   confirmRounds: 5,
@@ -4824,28 +5232,28 @@ function loadProjectReviewConfig(projectRoot) {
   if (!root) {
     return cloneDefaultProjectReviewConfig();
   }
-  const configPath = path6.join(root, ".autopilot", "config.yml");
+  const configPath = path8.join(root, ".autopilot", "config.yml");
   try {
-    const nofollow = typeof fs7.constants.O_NOFOLLOW === "number" ? fs7.constants.O_NOFOLLOW : 0;
+    const nofollow = typeof fs8.constants.O_NOFOLLOW === "number" ? fs8.constants.O_NOFOLLOW : 0;
     if (nofollow === 0) {
-      if (!fs7.existsSync(configPath)) return cloneDefaultProjectReviewConfig();
-      if (fs7.lstatSync(configPath).isSymbolicLink()) {
+      if (!fs8.existsSync(configPath)) return cloneDefaultProjectReviewConfig();
+      if (fs8.lstatSync(configPath).isSymbolicLink()) {
         return cloneDefaultProjectReviewConfig();
       }
     }
     let fd;
     try {
-      fd = fs7.openSync(configPath, fs7.constants.O_RDONLY | nofollow);
+      fd = fs8.openSync(configPath, fs8.constants.O_RDONLY | nofollow);
     } catch {
       return cloneDefaultProjectReviewConfig();
     }
     let raw;
     try {
-      const st = fs7.fstatSync(fd);
+      const st = fs8.fstatSync(fd);
       if (!st.isFile() || st.size > MAX_CONFIG_BYTES) {
         return cloneDefaultProjectReviewConfig();
       }
-      const lst = fs7.lstatSync(configPath);
+      const lst = fs8.lstatSync(configPath);
       if (lst.isSymbolicLink() || !lst.isFile()) {
         return cloneDefaultProjectReviewConfig();
       }
@@ -4856,10 +5264,10 @@ function loadProjectReviewConfig(projectRoot) {
         return cloneDefaultProjectReviewConfig();
       }
       const buf = Buffer.alloc(st.size);
-      const n = fs7.readSync(fd, buf, 0, st.size, 0);
+      const n = fs8.readSync(fd, buf, 0, st.size, 0);
       raw = buf.subarray(0, n).toString("utf8");
     } finally {
-      fs7.closeSync(fd);
+      fs8.closeSync(fd);
     }
     if (Buffer.byteLength(raw, "utf8") > MAX_CONFIG_BYTES) {
       return cloneDefaultProjectReviewConfig();
@@ -4959,6 +5367,12 @@ function createRenderFollowup(bundle) {
         );
       case "stuck":
         return renderTemplate(f.stuck ?? "", vars);
+      case "stuck_soft":
+        return renderTemplate(
+          // Never fall back to hard `stuck` (RESUME-required) — that defeats C2.
+          f.stuck_soft ?? "Stuck: no progress for several stops (missing completion evidence). Change strategy, write matching .autopilot/verify-last.json, then end the turn. Session stays armed \u2014 Autopilot RESUME is not required unless the session was paused.",
+          vars
+        );
       case "verify_fix":
         return renderTemplate(
           f.verify_fix ?? "Verify failed ({reason}). Fix verify commands and rewrite verify-last.json; do not advance.",
@@ -5011,1000 +5425,703 @@ function createConfiguredReviewEngine(store, projectRoot, localeBundle, preloade
 }
 
 // ../core/src/phase-actions.ts
-import fs9 from "node:fs";
-import path8 from "node:path";
+import fs10 from "node:fs";
+import path10 from "node:path";
 
 // ../core/src/list-tracks.ts
-import fs8 from "node:fs";
-import path7 from "node:path";
+import fs9 from "node:fs";
+import path9 from "node:path";
 function isRunnableTrack(t) {
   if (t.paused) return false;
   const unchecked = t.checklistTotal - t.checklistDone;
   if (unchecked <= 0) return false;
   return t.phase === "planning" || t.phase === "executing" || t.phase === "idle" || t.phase === "done";
-}
-function readPlansDir(root, plansDir = "plans") {
-  if (typeof plansDir !== "string" || !root || root.includes("\0") || plansDir.includes("\0")) {
-    return [];
-  }
-  const dir = path7.join(root, plansDir);
-  try {
-    const lst = fs8.lstatSync(dir);
-    if (lst.isSymbolicLink() || !lst.isDirectory()) return [];
-    if (!isRealpathInsideProject(root, dir)) return [];
-  } catch {
-    return [];
-  }
-  const names = fs8.readdirSync(dir, { withFileTypes: true }).filter(
-    (d) => d.isDirectory() && !d.isSymbolicLink() && isSafeTrackSlug(d.name)
-  ).map((d) => d.name);
-  try {
-    const lst = fs8.lstatSync(dir);
-    if (lst.isSymbolicLink() || !lst.isDirectory()) return [];
-    if (!isRealpathInsideProject(root, dir)) return [];
-  } catch {
-    return [];
-  }
-  return names;
-}
-function titleFromPlan(planPath, slug, projectRoot) {
-  if (!planPath || planPath.includes("\0")) return slug;
-  const root = normalizeProjectRoot(projectRoot);
-  if (!root) return slug;
-  const maxBytes = 65536;
-  try {
-    const nofollow = typeof fs8.constants.O_NOFOLLOW === "number" ? fs8.constants.O_NOFOLLOW : 0;
-    if (nofollow === 0) {
-      const lst = fs8.lstatSync(planPath);
-      if (lst.isSymbolicLink() || !lst.isFile()) return slug;
-    }
-    const fd = fs8.openSync(planPath, fs8.constants.O_RDONLY | nofollow);
-    try {
-      const st = fs8.fstatSync(fd);
-      if (!st.isFile() || st.size <= 0) return slug;
-      const lst = fs8.lstatSync(planPath);
-      if (lst.isSymbolicLink() || !lst.isFile()) return slug;
-      if (lst.ino !== st.ino || lst.dev !== st.dev) return slug;
-      if (!isRealpathInsideProject(root, planPath)) return slug;
-      const len = Math.min(st.size, maxBytes);
-      const buf = Buffer.alloc(len);
-      const n = fs8.readSync(fd, buf, 0, len, 0);
-      const first = buf.subarray(0, n).toString("utf8").split(/\r?\n/)[0] ?? "";
-      const m = first.match(/^#\s+(.+)/);
-      return m?.[1]?.trim() ?? slug;
-    } finally {
-      fs8.closeSync(fd);
-    }
-  } catch {
-    return slug;
-  }
-}
-function listTracks(root, store, filter = "all", plansDir = "plans") {
-  const normalized = normalizeProjectRoot(root);
-  if (!normalized) return [];
-  root = normalized;
-  const safePlans = normalizeInProjectPlansDir(root, plansDir);
-  if (!safePlans) return [];
-  plansDir = safePlans;
-  const slugs = readPlansDir(root, plansDir);
-  const tracks = [];
-  for (const slug of slugs) {
-    const trackDir = path7.join(root, plansDir, slug);
-    try {
-      const lst = fs8.lstatSync(trackDir);
-      if (lst.isSymbolicLink() || !lst.isDirectory()) continue;
-      if (!isRealpathInsideProject(root, trackDir)) continue;
-    } catch {
-      continue;
-    }
-    const planPath = path7.join(trackDir, "plan.md");
-    const checklistPath = path7.join(trackDir, "checklist.md");
-    let checklistTotal = 0;
-    let checklistDone = 0;
-    const checklistInProject = isRealpathInsideProject(root, checklistPath);
-    const planInProject = isRealpathInsideProject(root, planPath);
-    if (checklistInProject) {
-      try {
-        const cl = parseChecklist(checklistPath, { projectRoot: root });
-        checklistTotal = cl.items.length;
-        checklistDone = cl.items.filter((i) => i.checked).length;
-      } catch {
-      }
-    } else if (!planInProject) {
-      continue;
-    }
-    let phase = "idle";
-    let paused = false;
-    let pausedReason;
-    let updatedAt = (/* @__PURE__ */ new Date(0)).toISOString();
-    if (store) {
-      const sessions = store.db.prepare(
-        `SELECT * FROM sessions WHERE track_id = ? ORDER BY last_active_at DESC LIMIT 1`
-      ).all(slug);
-      const latest = sessions[0];
-      if (latest) {
-        phase = latest.phase;
-        paused = latest.paused === 1;
-        if (latest.paused_reason === "stuck" || latest.paused_reason === "repeated_errors" || latest.paused_reason === "human_gate") {
-          pausedReason = latest.paused_reason;
-        }
-        updatedAt = latest.last_active_at;
-      } else {
-        if (checklistTotal > 0 && checklistDone === checklistTotal) {
-          phase = "done";
-        } else if (checklistTotal - checklistDone > 0 && planInProject) {
-          phase = "idle";
-        }
-      }
-    } else {
-      if (checklistTotal > 0 && checklistDone === checklistTotal) {
-        phase = "done";
-      } else if (checklistTotal - checklistDone > 0) {
-        phase = "idle";
-      }
-    }
-    tracks.push({
-      slug,
-      title: planInProject ? titleFromPlan(planPath, slug, root) : slug,
-      phase,
-      paused,
-      pausedReason,
-      checklistTotal,
-      checklistDone,
-      planPath,
-      updatedAt
-    });
-  }
-  if (filter === "all") return tracks;
-  if (filter === "planning") {
-    return tracks.filter((t) => t.phase === "planning");
-  }
-  return tracks.filter(isRunnableTrack);
-}
-function canEnterExecuting(options) {
-  const { slug, checklistPath, paused, projectRoot } = options;
-  if (!slug || slug === "_pending") {
-    return { ok: false, reason: "no track slug" };
-  }
-  const root = normalizeProjectRoot(projectRoot);
-  if (!root) {
-    return { ok: false, reason: "invalid project root" };
-  }
-  if (!checklistPath || !fs8.existsSync(checklistPath)) {
-    return { ok: false, reason: "checklist missing" };
-  }
-  if (!isRealpathInsideProject(root, checklistPath)) {
-    return { ok: false, reason: "checklist outside project" };
-  }
-  let unchecked = 0;
-  try {
-    unchecked = countUnchecked(
-      parseChecklist(checklistPath, { projectRoot: root })
-    );
-  } catch {
-    return { ok: false, reason: "checklist unreadable" };
-  }
-  if (unchecked < 1) {
-    return { ok: false, reason: "no unchecked items" };
-  }
-  if (paused) {
-    return { ok: false, reason: "session paused" };
-  }
-  return { ok: true };
-}
-
-// ../core/src/phase-actions.ts
-function displayUntrusted(raw, max = 64) {
-  const text = typeof raw === "string" ? raw : String(raw ?? "");
-  return sanitizeSessionDisplayText(text).slice(0, max) || "?";
-}
-function isChannelANeedPick(fail) {
-  return fail.needPick === true && fail.busy !== true;
-}
-function formatOneExecutorBusyMessage(trackId, conversationId) {
-  const occTrack = displayUntrusted(trackId || "(unknown)");
-  const rawCid = typeof conversationId === "string" ? conversationId : String(conversationId ?? "");
-  const occSession = displayUntrusted(shortConversationId(rawCid) || "?") || "?";
-  return `Another session is already executing (track: ${occTrack}, session: ${occSession}). Send Autopilot OFF there or wait, then retry. If the host only shows opaque blocked, run: npx @autopilot-harness/cli status or npx @autopilot-harness/cli doctor`;
-}
-function logBusyOccupier(message) {
-  try {
-    process.stderr.write(`[autopilot] ${message}
-`);
-  } catch {
-  }
-}
-function nowIso2() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function checklistPathFor(projectRoot, slug, plansDir) {
-  const root = normalizeProjectRoot(projectRoot);
-  if (!root) return path8.join(plansDir, slug, "checklist.md");
-  return path8.join(root, plansDir, slug, "checklist.md");
-}
-function sameChecklistBinding(stored, rebuilt, projectRoot) {
-  if (stored === rebuilt) return true;
-  if (!stored || !rebuilt || stored.includes("\0") || rebuilt.includes("\0")) {
-    return false;
+}
+function readPlansDir(root, plansDir = "plans") {
+  if (typeof plansDir !== "string" || !root || root.includes("\0") || plansDir.includes("\0")) {
+    return [];
   }
-  const root = normalizeProjectRoot(projectRoot);
-  if (!root) return false;
+  const dir = path9.join(root, plansDir);
   try {
-    const absStored = path8.isAbsolute(stored) ? path8.resolve(stored) : path8.resolve(root, stored);
-    const absRebuilt = path8.isAbsolute(rebuilt) ? path8.resolve(rebuilt) : path8.resolve(root, rebuilt);
-    return absStored === absRebuilt;
+    const lst = fs9.lstatSync(dir);
+    if (lst.isSymbolicLink() || !lst.isDirectory()) return [];
+    if (!isRealpathInsideProject(root, dir)) return [];
   } catch {
-    return false;
-  }
-}
-function trustedChecklistPath(projectRoot, plansDir, slug, storedPath, boundTrackId) {
-  const rebuilt = checklistPathFor(projectRoot, slug, plansDir);
-  if (storedPath && boundTrackId === slug) {
-    if (isChecklistPathAllowed(projectRoot, storedPath)) {
-      return storedPath;
-    }
+    return [];
   }
-  return rebuilt;
-}
-function isChecklistPathAllowed(projectRoot, checklistPath) {
-  if (!checklistPath || checklistPath.includes("\0")) return false;
-  const root = normalizeProjectRoot(projectRoot);
-  if (!root) return false;
+  const names = fs9.readdirSync(dir, { withFileTypes: true }).filter(
+    (d) => d.isDirectory() && !d.isSymbolicLink() && isSafeTrackSlug(d.name)
+  ).map((d) => d.name);
   try {
-    fs9.lstatSync(
-      path8.isAbsolute(checklistPath) ? checklistPath : path8.resolve(root, checklistPath)
-    );
-    return isRealpathInsideProject(root, checklistPath);
+    const lst = fs9.lstatSync(dir);
+    if (lst.isSymbolicLink() || !lst.isDirectory()) return [];
+    if (!isRealpathInsideProject(root, dir)) return [];
   } catch {
-    return isLexicallyInsideProject(root, checklistPath);
-  }
-}
-function ensureSession(store, conversationId, projectRoot, platform) {
-  const existing = store.getSession(conversationId);
-  if (existing) {
-    const want = resolveSessionPlatform(platform, existing.platform);
-    if (want !== existing.platform) {
-      return store.upsertSession({
-        conversation_id: conversationId,
-        project_root: existing.project_root,
-        code_root: existing.code_root,
-        platform: want
-      });
-    }
-    return existing;
+    return [];
   }
-  return store.upsertSession({
-    conversation_id: conversationId,
-    project_root: projectRoot,
-    code_root: projectRoot,
-    platform: normalizeSessionPlatform(platform),
-    phase: "idle",
-    armed: 0,
-    paused: 0,
-    track_id: "_pending",
-    checklist_path: ""
-  });
+  return names;
 }
-function upsertTrack(store, slug, checklistPath, plansDir, projectRoot) {
-  const ts = nowIso2();
+function titleFromPlan(planPath, slug, projectRoot) {
+  if (!planPath || planPath.includes("\0")) return slug;
   const root = normalizeProjectRoot(projectRoot);
-  if (!root) return;
-  const planPath = path8.join(root, plansDir, slug, "plan.md");
-  const briefPath = path8.join(root, plansDir, slug, "brief.md");
-  store.db.prepare(
-    `INSERT INTO tracks (track_id, slug, checklist_path, plan_path, brief_path, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?)
-       ON CONFLICT(track_id) DO UPDATE SET
-         slug = excluded.slug,
-         checklist_path = excluded.checklist_path,
-         plan_path = excluded.plan_path,
-         brief_path = excluded.brief_path,
-         updated_at = excluded.updated_at`
-  ).run(
-    slug,
-    slug,
-    checklistPath,
-    fs9.existsSync(planPath) ? planPath : null,
-    fs9.existsSync(briefPath) ? briefPath : null,
-    ts
-  );
-}
-function candidatePayload(tracks) {
-  return JSON.stringify(
-    tracks.map((t) => ({
-      slug: t.slug,
-      title: sanitizeSessionDisplayText(t.title || t.slug) || t.slug,
-      phase: t.phase,
-      progress: `${t.checklistDone}/${t.checklistTotal}`
-    }))
-  );
-}
-function resolveRunSlug(store, session, projectRoot, plansDir, requestedSlug) {
-  const runnable = listTracks(projectRoot, store, "runnable", plansDir).filter(
-    (t) => isSafeTrackSlug(t.slug)
-  );
-  if (requestedSlug) {
-    if (!isSafeTrackSlug(requestedSlug)) {
-      return {
-        kind: "none",
-        userMessage: `Invalid track slug "${displayUntrusted(requestedSlug)}".`
-      };
-    }
-    const hit = runnable.find((t) => t.slug === requestedSlug);
-    if (!hit) {
-      const all = listTracks(projectRoot, store, "all", plansDir);
-      if (!all.some((t) => t.slug === requestedSlug)) {
-        return {
-          kind: "none",
-          userMessage: `Track "${displayUntrusted(requestedSlug)}" not found or has no unchecked checklist items.`
-        };
-      }
-      return {
-        kind: "none",
-        userMessage: `Track "${displayUntrusted(requestedSlug)}" is not runnable (paused or no unchecked items).`
-      };
-    }
-    return { kind: "slug", slug: requestedSlug };
-  }
-  const midPick = session.pending_action === "run" || session.pending_action === "replan";
-  if (!midPick && isBoundRunTrackId(session.track_id)) {
-    const bound = runnable.find((t) => t.slug === session.track_id);
-    if (bound) {
-      return { kind: "slug", slug: bound.slug };
+  if (!root) return slug;
+  const maxBytes = 65536;
+  try {
+    const nofollow = typeof fs9.constants.O_NOFOLLOW === "number" ? fs9.constants.O_NOFOLLOW : 0;
+    if (nofollow === 0) {
+      const lst = fs9.lstatSync(planPath);
+      if (lst.isSymbolicLink() || !lst.isFile()) return slug;
     }
-  }
-  if (runnable.length === 0) {
-    return {
-      kind: "none",
-      userMessage: "No runnable plan. Use /autopilot-on to plan, then finalize a checklist with unchecked items."
-    };
-  }
-  if (runnable.length === 1) {
-    if (session.pending_action === "replan") {
-      return { kind: "pick", candidates: runnable };
+    const fd = fs9.openSync(planPath, fs9.constants.O_RDONLY | nofollow);
+    try {
+      const st = fs9.fstatSync(fd);
+      if (!st.isFile() || st.size <= 0) return slug;
+      const lst = fs9.lstatSync(planPath);
+      if (lst.isSymbolicLink() || !lst.isFile()) return slug;
+      if (lst.ino !== st.ino || lst.dev !== st.dev) return slug;
+      if (!isRealpathInsideProject(root, planPath)) return slug;
+      const len = Math.min(st.size, maxBytes);
+      const buf = Buffer.alloc(len);
+      const n = fs9.readSync(fd, buf, 0, len, 0);
+      const first = buf.subarray(0, n).toString("utf8").split(/\r?\n/)[0] ?? "";
+      const m = first.match(/^#\s+(.+)/);
+      return m?.[1]?.trim() ?? slug;
+    } finally {
+      fs9.closeSync(fd);
     }
-    return { kind: "slug", slug: runnable[0].slug };
+  } catch {
+    return slug;
   }
-  return { kind: "pick", candidates: runnable };
-}
-function requireProjectRoot(store, projectRoot) {
-  return normalizeProjectRoot(store.projectRoot) ?? normalizeProjectRoot(projectRoot);
 }
-function requirePlansDir(projectRoot, plansDir) {
-  return normalizeInProjectPlansDir(projectRoot, plansDir);
-}
-function applyRun(store, conversationId, projectRoot, opts) {
-  const root = requireProjectRoot(store, projectRoot);
-  if (!root) {
-    return { ok: false, userMessage: "Invalid project root." };
-  }
-  projectRoot = root;
-  const plansDir = requirePlansDir(projectRoot, opts?.config?.plansDir);
-  if (!plansDir) {
-    return { ok: false, userMessage: "Invalid plans directory." };
-  }
-  const concurrencyMode = opts?.config?.concurrencyMode ?? "one_executor";
-  const session = ensureSession(
-    store,
-    conversationId,
-    projectRoot,
-    opts?.platform
-  );
-  const resolved = resolveRunSlug(
-    store,
-    session,
-    projectRoot,
-    plansDir,
-    opts?.slug
-  );
-  if (resolved.kind === "none") {
-    return { ok: false, userMessage: resolved.userMessage };
-  }
-  if (resolved.kind === "pick") {
-    const clearingStaleBind = isBoundRunTrackId(session.track_id);
-    const trackForPick = clearingStaleBind ? "_pending" : session.track_id;
-    store.upsertSession({
-      conversation_id: conversationId,
-      project_root: session.project_root,
-      code_root: session.code_root,
-      track_id: trackForPick,
-      // Drop checklist binding with the stale track so planning state stays consistent.
-      ...clearingStaleBind ? { checklist_path: "" } : {},
-      pending_action: "run",
-      track_candidates_json: candidatePayload(resolved.candidates),
-      armed: 0
-      // phase unchanged — do not write executing
-    });
-    const lines = resolved.candidates.map((t, i) => {
-      const title = sanitizeSessionDisplayText(t.title || t.slug) || t.slug;
-      const left = t.checklistTotal - t.checklistDone;
-      return `  ${i + 1}. ${t.slug} \u2014 ${title} (${left}/${t.checklistTotal} left)`;
-    }).join("\n");
-    return {
-      ok: false,
-      needPick: true,
-      candidates: resolved.candidates,
-      userMessage: `Select a plan to execute:
-
-${lines}
-
-Reply with a number or /autopilot-run <slug>.`
-    };
-  }
-  const slug = resolved.slug;
-  if (!isSafeTrackSlug(slug)) {
-    return {
-      ok: false,
-      userMessage: `Invalid track slug "${displayUntrusted(slug)}".`
-    };
-  }
-  const checklistPath = checklistPathFor(projectRoot, slug, plansDir);
-  const gate = canEnterExecuting({
-    slug,
-    checklistPath,
-    paused: session.paused === 1,
-    projectRoot
-  });
-  if (!gate.ok) {
-    return {
-      ok: false,
-      userMessage: `Cannot start executing: ${gate.reason}.`
-    };
-  }
-  try {
-    const result = store.exclusiveWrite(() => {
-      if (concurrencyMode === "one_executor") {
-        const other = store.findExecutingSession(conversationId);
-        if (other) {
-          const userMessage = formatOneExecutorBusyMessage(
-            other.track_id,
-            other.conversation_id
-          );
-          return {
-            commit: false,
-            value: {
-              ok: false,
-              busy: true,
-              userMessage
-            }
-          };
-        }
+function listTracks(root, store, filter = "all", plansDir = "plans") {
+  const normalized = normalizeProjectRoot(root);
+  if (!normalized) return [];
+  root = normalized;
+  const safePlans = normalizeInProjectPlansDir(root, plansDir);
+  if (!safePlans) return [];
+  plansDir = safePlans;
+  const slugs = readPlansDir(root, plansDir);
+  const tracks = [];
+  for (const slug of slugs) {
+    const trackDir = path9.join(root, plansDir, slug);
+    try {
+      const lst = fs9.lstatSync(trackDir);
+      if (lst.isSymbolicLink() || !lst.isDirectory()) continue;
+      if (!isRealpathInsideProject(root, trackDir)) continue;
+    } catch {
+      continue;
+    }
+    const planPath = path9.join(trackDir, "plan.md");
+    const checklistPath = path9.join(trackDir, "checklist.md");
+    let checklistTotal = 0;
+    let checklistDone = 0;
+    const checklistInProject = isRealpathInsideProject(root, checklistPath);
+    const planInProject = isRealpathInsideProject(root, planPath);
+    if (checklistInProject) {
+      try {
+        const cl = parseChecklist(checklistPath, { projectRoot: root });
+        checklistTotal = cl.items.length;
+        checklistDone = cl.items.filter((i) => i.checked).length;
+      } catch {
       }
-      const fresh = store.getSession(conversationId);
-      const alreadyExecutingSameTrack = fresh?.phase === "executing" && fresh.armed === 1 && fresh.paused === 0 && fresh.track_id === slug && sameChecklistBinding(fresh.checklist_path, checklistPath, projectRoot);
-      upsertTrack(store, slug, checklistPath, plansDir, projectRoot);
-      const updated = store.upsertSession({
-        conversation_id: conversationId,
-        project_root: projectRoot,
-        code_root: projectRoot,
-        track_id: slug,
-        checklist_path: checklistPath,
-        phase: "executing",
-        armed: 1,
-        paused: 0,
-        paused_reason: null,
-        pending_action: null,
-        track_candidates_json: null,
-        error_count: 0,
-        idle_stop_count: 0
-      });
-      if (!alreadyExecutingSameTrack) {
-        let reviewingItemId = null;
-        try {
-          const cl = parseChecklist(checklistPath, { projectRoot });
-          reviewingItemId = firstUnchecked(cl)?.id ?? null;
-        } catch {
+    } else if (!planInProject) {
+      continue;
+    }
+    let phase = "idle";
+    let paused = false;
+    let pausedReason;
+    let updatedAt = (/* @__PURE__ */ new Date(0)).toISOString();
+    if (store) {
+      const sessions = store.db.prepare(
+        `SELECT * FROM sessions WHERE track_id = ? ORDER BY last_active_at DESC LIMIT 1`
+      ).all(slug);
+      const latest = sessions[0];
+      if (latest) {
+        phase = latest.phase;
+        paused = latest.paused === 1;
+        if (latest.paused_reason === "stuck" || latest.paused_reason === "repeated_errors" || latest.paused_reason === "human_gate") {
+          pausedReason = latest.paused_reason;
         }
-        store.updateReviewChain(conversationId, {
-          fix_round: 0,
-          confirm_left: null,
-          chain_pending: 0,
-          code_edited: 0,
-          item_confirm_complete: 0,
-          reviewing_item_id: reviewingItemId,
-          pending_followup: null,
-          pending_followup_at: null,
-          pending_redeliver_at: null
-        });
+        updatedAt = latest.last_active_at;
       } else {
-        store.ensureReviewChain(conversationId);
+        if (checklistTotal > 0 && checklistDone === checklistTotal) {
+          phase = "done";
+        } else if (checklistTotal - checklistDone > 0 && planInProject) {
+          phase = "idle";
+        }
+      }
+    } else {
+      if (checklistTotal > 0 && checklistDone === checklistTotal) {
+        phase = "done";
+      } else if (checklistTotal - checklistDone > 0) {
+        phase = "idle";
       }
-      return { commit: true, value: { ok: true, session: updated } };
-    });
-    if (!result.ok && result.busy === true) {
-      logBusyOccupier(result.userMessage);
-    }
-    return result;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (/busy|locked|SQLITE_BUSY|SQLITE_LOCKED/i.test(msg)) {
-      const userMessage = "State database is busy; retry Autopilot RUN in a moment.";
-      logBusyOccupier(userMessage);
-      return {
-        ok: false,
-        busy: true,
-        userMessage
-      };
     }
-    throw err;
+    tracks.push({
+      slug,
+      title: planInProject ? titleFromPlan(planPath, slug, root) : slug,
+      phase,
+      paused,
+      pausedReason,
+      checklistTotal,
+      checklistDone,
+      planPath,
+      updatedAt
+    });
+  }
+  if (filter === "all") return tracks;
+  if (filter === "planning") {
+    return tracks.filter((t) => t.phase === "planning");
   }
+  return tracks.filter(isRunnableTrack);
 }
-function applyReplan(store, conversationId, projectRoot, opts) {
-  const root = requireProjectRoot(store, projectRoot);
-  if (!root) {
-    return { ok: false, userMessage: "Invalid project root." };
+function canEnterExecuting(options) {
+  const { slug, checklistPath, paused, projectRoot } = options;
+  if (!slug || slug === "_pending") {
+    return { ok: false, reason: "no track slug" };
   }
-  projectRoot = root;
-  const plansDir = requirePlansDir(projectRoot, opts?.config?.plansDir);
-  if (!plansDir) {
-    return { ok: false, userMessage: "Invalid plans directory." };
+  const root = normalizeProjectRoot(projectRoot);
+  if (!root) {
+    return { ok: false, reason: "invalid project root" };
   }
-  const session = ensureSession(
-    store,
-    conversationId,
-    projectRoot,
-    opts?.platform
-  );
-  let slug = opts?.slug;
-  if (!slug) {
-    const tid = session.track_id;
-    const midPick = session.pending_action === "run" || session.pending_action === "replan";
-    slug = !midPick && isBoundRunTrackId(tid) ? tid : void 0;
+  if (!checklistPath || !fs9.existsSync(checklistPath)) {
+    return { ok: false, reason: "checklist missing" };
   }
-  if (slug && !isSafeTrackSlug(slug)) {
-    return {
-      ok: false,
-      userMessage: `Invalid track slug "${displayUntrusted(slug)}".`
-    };
+  if (!isRealpathInsideProject(root, checklistPath)) {
+    return { ok: false, reason: "checklist outside project" };
   }
-  if (!slug) {
-    const all = listTracks(projectRoot, store, "all", plansDir).filter(
-      (t) => isSafeTrackSlug(t.slug)
+  let unchecked = 0;
+  try {
+    unchecked = countUnchecked(
+      parseChecklist(checklistPath, { projectRoot: root })
     );
-    if (all.length === 1 && session.pending_action !== "run") {
-      slug = all[0].slug;
-    } else if (all.length > 1 || all.length === 1 && session.pending_action === "run") {
-      const clearingStaleBind = isBoundRunTrackId(session.track_id);
-      store.upsertSession({
-        conversation_id: conversationId,
-        project_root: session.project_root,
-        code_root: session.code_root,
-        track_id: clearingStaleBind ? "_pending" : session.track_id,
-        ...clearingStaleBind ? { checklist_path: "" } : {},
-        pending_action: "replan",
-        track_candidates_json: candidatePayload(all),
-        armed: 0
-      });
-      const lines = all.map((t, i) => {
-        const title = sanitizeSessionDisplayText(t.title || t.slug) || t.slug;
-        return `  ${i + 1}. ${t.slug} \u2014 ${title}`;
-      }).join("\n");
-      return {
-        ok: false,
-        needPick: true,
-        candidates: all,
-        userMessage: `Select a plan to replan:
-
-${lines}
-
-Reply with a number or /autopilot-replan <slug>.`
-      };
-    } else {
-      return {
-        ok: false,
-        userMessage: "No plan to replan. Use /autopilot-on first."
-      };
-    }
+  } catch {
+    return { ok: false, reason: "checklist unreadable" };
   }
-  const checklistPath = trustedChecklistPath(
-    projectRoot,
-    plansDir,
-    slug,
-    session.checklist_path,
-    session.track_id
-  );
-  const updated = store.upsertSession({
-    conversation_id: conversationId,
-    project_root: projectRoot,
-    code_root: projectRoot,
-    track_id: slug,
-    checklist_path: checklistPath,
-    phase: "planning",
-    armed: 0,
-    paused: 0,
-    paused_reason: null,
-    pending_action: null,
-    track_candidates_json: null
-  });
-  store.updateReviewChain(conversationId, {
-    fix_round: 0,
-    confirm_left: null,
-    chain_pending: 0,
-    code_edited: 0,
-    item_confirm_complete: 0,
-    reviewing_item_id: null,
-    pending_followup: null,
-    pending_followup_at: null,
-    pending_redeliver_at: null
-  });
-  return { ok: true, session: updated };
+  if (unchecked < 1) {
+    return { ok: false, reason: "no unchecked items" };
+  }
+  if (paused) {
+    return { ok: false, reason: "session paused" };
+  }
+  return { ok: true };
 }
-function applyTrackPick(store, conversationId, projectRoot, pick, opts) {
-  const root = requireProjectRoot(store, projectRoot);
-  if (!root) {
-    return { ok: false, userMessage: "Invalid project root." };
+
+// ../core/src/phase-actions.ts
+function displayUntrusted(raw, max = 64) {
+  const text = typeof raw === "string" ? raw : String(raw ?? "");
+  return sanitizeSessionDisplayText(text).slice(0, max) || "?";
+}
+function isChannelANeedPick(fail) {
+  return fail.needPick === true && fail.busy !== true;
+}
+function formatOneExecutorBusyMessage(trackId, conversationId) {
+  const occTrack = displayUntrusted(trackId || "(unknown)");
+  const rawCid = typeof conversationId === "string" ? conversationId : String(conversationId ?? "");
+  const occSession = displayUntrusted(shortConversationId(rawCid) || "?") || "?";
+  return `Another session is already executing (track: ${occTrack}, session: ${occSession}). Send Autopilot OFF there or wait, then retry. If the host only shows opaque blocked, run: npx @autopilot-harness/cli status or npx @autopilot-harness/cli doctor`;
+}
+function logBusyOccupier(message) {
+  try {
+    process.stderr.write(`[autopilot] ${message}
+`);
+  } catch {
   }
-  projectRoot = root;
-  const session = store.getSession(conversationId);
-  if (!session?.pending_action) {
-    return {
-      ok: false,
-      userMessage: "No pending track selection."
-    };
+}
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function checklistPathFor(projectRoot, slug, plansDir) {
+  const root = normalizeProjectRoot(projectRoot);
+  if (!root) return path10.join(plansDir, slug, "checklist.md");
+  return path10.join(root, plansDir, slug, "checklist.md");
+}
+function sameChecklistBinding(stored, rebuilt, projectRoot) {
+  if (stored === rebuilt) return true;
+  if (!stored || !rebuilt || stored.includes("\0") || rebuilt.includes("\0")) {
+    return false;
   }
-  const pending = session.pending_action;
-  if (pending !== "run" && pending !== "replan") {
-    return {
-      ok: false,
-      userMessage: `Unknown pending action "${displayUntrusted(pending)}".`
-    };
+  const root = normalizeProjectRoot(projectRoot);
+  if (!root) return false;
+  try {
+    const absStored = path10.isAbsolute(stored) ? path10.resolve(stored) : path10.resolve(root, stored);
+    const absRebuilt = path10.isAbsolute(rebuilt) ? path10.resolve(rebuilt) : path10.resolve(root, rebuilt);
+    return absStored === absRebuilt;
+  } catch {
+    return false;
   }
-  if (!session.track_candidates_json) {
-    return { ok: false, userMessage: "Invalid track candidates JSON." };
+}
+function trustedChecklistPath(projectRoot, plansDir, slug, storedPath, boundTrackId) {
+  const rebuilt = checklistPathFor(projectRoot, slug, plansDir);
+  if (storedPath && boundTrackId === slug) {
+    if (isChecklistPathAllowed(projectRoot, storedPath)) {
+      return storedPath;
+    }
   }
-  let candidates = [];
+  return rebuilt;
+}
+function isChecklistPathAllowed(projectRoot, checklistPath) {
+  if (!checklistPath || checklistPath.includes("\0")) return false;
+  const root = normalizeProjectRoot(projectRoot);
+  if (!root) return false;
   try {
-    const parsed = JSON.parse(session.track_candidates_json);
-    if (!Array.isArray(parsed) || parsed.length === 0) {
-      return { ok: false, userMessage: "Invalid track candidates JSON." };
-    }
-    const hasValidSlug = parsed.some(
-      (c) => !!c && typeof c === "object" && !Array.isArray(c) && typeof c.slug === "string" && isSafeTrackSlug(c.slug)
+    fs10.lstatSync(
+      path10.isAbsolute(checklistPath) ? checklistPath : path10.resolve(root, checklistPath)
     );
-    if (!hasValidSlug) {
-      return { ok: false, userMessage: "Invalid track candidates JSON." };
-    }
-    candidates = parsed;
+    return isRealpathInsideProject(root, checklistPath);
   } catch {
-    return { ok: false, userMessage: "Invalid track candidates JSON." };
+    return isLexicallyInsideProject(root, checklistPath);
   }
-  let slug;
-  if (/^\d+$/.test(pick)) {
-    const idx = Number.parseInt(pick, 10) - 1;
-    const entry = candidates[idx];
-    slug = entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.slug === "string" ? entry.slug : void 0;
-    if (!slug || !isSafeTrackSlug(slug)) {
-      return {
-        ok: false,
-        userMessage: `Invalid selection "${displayUntrusted(pick)}". Choose 1\u2013${candidates.length}.`
-      };
-    }
-  } else {
-    if (!isSafeTrackSlug(pick)) {
-      return {
-        ok: false,
-        userMessage: `Invalid track slug "${displayUntrusted(pick)}".`
-      };
-    }
-    slug = pick;
-    if (!candidates.some(
-      (c) => !!c && typeof c === "object" && !Array.isArray(c) && c.slug === slug
-    )) {
-      return {
-        ok: false,
-        userMessage: `Unknown slug "${displayUntrusted(pick)}".`
-      };
+}
+function ensureSession(store, conversationId, projectRoot, platform) {
+  const existing = store.getSession(conversationId);
+  if (existing) {
+    const want = resolveSessionPlatform(platform, existing.platform);
+    if (want !== existing.platform) {
+      return store.upsertSession({
+        conversation_id: conversationId,
+        project_root: existing.project_root,
+        code_root: existing.code_root,
+        platform: want
+      });
     }
+    return existing;
   }
-  if (pending === "replan") {
-    return applyReplan(store, conversationId, projectRoot, {
-      slug,
-      config: opts?.config,
-      platform: opts?.platform
-    });
-  }
-  return applyRun(store, conversationId, projectRoot, {
-    slug,
-    config: opts?.config,
-    platform: opts?.platform
+  return store.upsertSession({
+    conversation_id: conversationId,
+    project_root: projectRoot,
+    code_root: projectRoot,
+    platform: normalizeSessionPlatform(platform),
+    phase: "idle",
+    armed: 0,
+    paused: 0,
+    track_id: "_pending",
+    checklist_path: ""
   });
 }
-
-// ../core/src/code-edit-detector.ts
-import { spawnSync } from "node:child_process";
-
-// ../core/src/autopilot-ignore.ts
-import fs10 from "node:fs";
-import path9 from "node:path";
-var DEFAULT_AUTOPILOT_IGNORE_TEXT = `# Autopilot \u2014 paths that do NOT trigger self-review (gitignore syntax).
-#
-# What this file is:
-#   - Controls whether an afterFileEdit counts as "product code" (opens fix/confirm).
-#   - Does NOT change \`git diff\` / \`git status\` output (that is \`.gitignore\`).
-#   - Review followups ask the agent to skip these paths when reading diffs (soft).
-#
-# Semantics:
-#   - Same glob rules as gitignore; last matching pattern wins.
-#   - Use \`!\` to force-include an exception (e.g. \`!docs/feed/**/*.yml\`).
-#   - Markdown (*.md / *.mdx) is NOT ignored by default \u2014 design docs can be reviewed.
-#   - \`docs/**\` is NOT ignored by default.
-#   - Also skip untracked paths ignored by \`.gitignore\` (tracked files still count).
-#
-# Later (not implemented): hard-filtered review-diff / path ledger \u2014 see
-# docs/autopilot/workflows/autopilot-executing.md (B2 strong).
-
-# Runtime / editor (prefer also listing these in .gitignore)
-.autopilot/**
-.cursor/**
-.claude/**
-
-# Planning artifacts
-plans/**
-
-# Common build / vendor trees
-node_modules/**
-dist/**
-build/**
-out/**
-target/**
-.target/**
-coverage/**
-.venv/**
-venv/**
-__pycache__/**
-
-# Lockfiles / package manager noise
-package-lock.json
-pnpm-lock.yaml
-yarn.lock
-bun.lock
-bun.lockb
-Cargo.lock
-poetry.lock
-composer.lock
-
-# Media / binary (do not trigger self-review)
-*.png
-*.jpg
-*.jpeg
-*.gif
-*.webp
-*.ico
-*.svg
-*.bmp
-*.mp3
-*.mp4
-*.wav
-*.webm
-*.mov
-*.woff
-*.woff2
-*.ttf
-*.otf
-*.eot
-*.pdf
-*.zip
-*.gz
-*.tgz
-*.7z
-*.rar
-*.jar
-*.class
-*.o
-*.a
-*.so
-*.dylib
-*.dll
-*.exe
-*.wasm
-
-# Prose / data noise
-*.txt
-*.html
-*.htm
-*.csv
-*.tsv
-*.log
-*.map
-*.min.js
-*.min.css
-`;
-var MAX_AUTOPILOT_IGNORE_BYTES = 1e6;
-var MAX_AUTOPILOT_IGNORE_LINE_CHARS = 4096;
-var MAX_AUTOPILOT_IGNORE_PATTERNS = 1e4;
-var ignoreCache = /* @__PURE__ */ new Map();
-function escapeRegexChar(ch) {
-  return ch.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+function upsertTrack(store, slug, checklistPath, plansDir, projectRoot) {
+  const ts = nowIso2();
+  const root = normalizeProjectRoot(projectRoot);
+  if (!root) return;
+  const planPath = path10.join(root, plansDir, slug, "plan.md");
+  const briefPath = path10.join(root, plansDir, slug, "brief.md");
+  store.db.prepare(
+    `INSERT INTO tracks (track_id, slug, checklist_path, plan_path, brief_path, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(track_id) DO UPDATE SET
+         slug = excluded.slug,
+         checklist_path = excluded.checklist_path,
+         plan_path = excluded.plan_path,
+         brief_path = excluded.brief_path,
+         updated_at = excluded.updated_at`
+  ).run(
+    slug,
+    slug,
+    checklistPath,
+    fs10.existsSync(planPath) ? planPath : null,
+    fs10.existsSync(briefPath) ? briefPath : null,
+    ts
+  );
+}
+function candidatePayload(tracks) {
+  return JSON.stringify(
+    tracks.map((t) => ({
+      slug: t.slug,
+      title: sanitizeSessionDisplayText(t.title || t.slug) || t.slug,
+      phase: t.phase,
+      progress: `${t.checklistDone}/${t.checklistTotal}`
+    }))
+  );
 }
-function globBodyToRegex(glob) {
-  let out = "";
-  for (let i = 0; i < glob.length; ) {
-    const ch = glob[i];
-    if (ch === "*" && glob[i + 1] === "*") {
-      if (glob[i + 2] === "/") {
-        out += "(?:.*/)?";
-        i += 3;
-        continue;
+function resolveRunSlug(store, session, projectRoot, plansDir, requestedSlug) {
+  const runnable = listTracks(projectRoot, store, "runnable", plansDir).filter(
+    (t) => isSafeTrackSlug(t.slug)
+  );
+  if (requestedSlug) {
+    if (!isSafeTrackSlug(requestedSlug)) {
+      return {
+        kind: "none",
+        userMessage: `Invalid track slug "${displayUntrusted(requestedSlug)}".`
+      };
+    }
+    const hit = runnable.find((t) => t.slug === requestedSlug);
+    if (!hit) {
+      const all = listTracks(projectRoot, store, "all", plansDir);
+      if (!all.some((t) => t.slug === requestedSlug)) {
+        return {
+          kind: "none",
+          userMessage: `Track "${displayUntrusted(requestedSlug)}" not found or has no unchecked checklist items.`
+        };
       }
-      out += ".*";
-      i += 2;
-      continue;
+      return {
+        kind: "none",
+        userMessage: `Track "${displayUntrusted(requestedSlug)}" is not runnable (paused or no unchecked items).`
+      };
     }
-    if (ch === "*") {
-      out += "[^/]*";
-      i += 1;
-      continue;
+    return { kind: "slug", slug: requestedSlug };
+  }
+  const midPick = session.pending_action === "run" || session.pending_action === "replan";
+  if (!midPick && isBoundRunTrackId(session.track_id)) {
+    const bound = runnable.find((t) => t.slug === session.track_id);
+    if (bound) {
+      return { kind: "slug", slug: bound.slug };
     }
-    if (ch === "?") {
-      out += "[^/]";
-      i += 1;
-      continue;
+  }
+  if (runnable.length === 0) {
+    return {
+      kind: "none",
+      userMessage: "No runnable plan. Use /autopilot-on to plan, then finalize a checklist with unchecked items."
+    };
+  }
+  if (runnable.length === 1) {
+    if (session.pending_action === "replan") {
+      return { kind: "pick", candidates: runnable };
     }
-    out += escapeRegexChar(ch);
-    i += 1;
+    return { kind: "slug", slug: runnable[0].slug };
   }
-  return out;
+  return { kind: "pick", candidates: runnable };
 }
-function compilePattern(raw) {
-  let line = raw.trim();
-  if (!line || line.startsWith("#")) return null;
-  if (line.length > MAX_AUTOPILOT_IGNORE_LINE_CHARS) return null;
-  let negated = false;
-  if (line.startsWith("!")) {
-    negated = true;
-    line = line.slice(1).trim();
-    if (!line || line.startsWith("#")) return null;
+function requireProjectRoot(store, projectRoot) {
+  return normalizeProjectRoot(store.projectRoot) ?? normalizeProjectRoot(projectRoot);
+}
+function requirePlansDir(projectRoot, plansDir) {
+  return normalizeInProjectPlansDir(projectRoot, plansDir);
+}
+function applyRun(store, conversationId, projectRoot, opts) {
+  const root = requireProjectRoot(store, projectRoot);
+  if (!root) {
+    return { ok: false, userMessage: "Invalid project root." };
   }
-  const dirOnly = line.endsWith("/");
-  if (dirOnly) line = line.slice(0, -1);
-  if (!line) return null;
-  if (line.length > MAX_AUTOPILOT_IGNORE_LINE_CHARS) return null;
-  let anchored = false;
-  if (line.startsWith("/")) {
-    anchored = true;
-    line = line.slice(1);
+  projectRoot = root;
+  const plansDir = requirePlansDir(projectRoot, opts?.config?.plansDir);
+  if (!plansDir) {
+    return { ok: false, userMessage: "Invalid plans directory." };
   }
-  const body = globBodyToRegex(line);
-  let regexSource;
-  if (anchored) {
-    regexSource = `^${body}`;
-    if (dirOnly || line.endsWith("/**") || line.endsWith("/*")) {
-      regexSource += "(?:/.*)?";
+  const concurrencyMode = opts?.config?.concurrencyMode ?? "one_executor";
+  const session = ensureSession(
+    store,
+    conversationId,
+    projectRoot,
+    opts?.platform
+  );
+  const resolved = resolveRunSlug(
+    store,
+    session,
+    projectRoot,
+    plansDir,
+    opts?.slug
+  );
+  if (resolved.kind === "none") {
+    return { ok: false, userMessage: resolved.userMessage };
+  }
+  if (resolved.kind === "pick") {
+    const clearingStaleBind = isBoundRunTrackId(session.track_id);
+    const trackForPick = clearingStaleBind ? "_pending" : session.track_id;
+    store.upsertSession({
+      conversation_id: conversationId,
+      project_root: session.project_root,
+      code_root: session.code_root,
+      track_id: trackForPick,
+      // Drop checklist binding with the stale track so planning state stays consistent.
+      ...clearingStaleBind ? { checklist_path: "" } : {},
+      pending_action: "run",
+      track_candidates_json: candidatePayload(resolved.candidates),
+      armed: 0
+      // phase unchanged — do not write executing
+    });
+    const lines = resolved.candidates.map((t, i) => {
+      const title = sanitizeSessionDisplayText(t.title || t.slug) || t.slug;
+      const left = t.checklistTotal - t.checklistDone;
+      return `  ${i + 1}. ${t.slug} \u2014 ${title} (${left}/${t.checklistTotal} left)`;
+    }).join("\n");
+    return {
+      ok: false,
+      needPick: true,
+      candidates: resolved.candidates,
+      userMessage: `Select a plan to execute:
+
+${lines}
+
+Reply with a number or /autopilot-run <slug>.`
+    };
+  }
+  const slug = resolved.slug;
+  if (!isSafeTrackSlug(slug)) {
+    return {
+      ok: false,
+      userMessage: `Invalid track slug "${displayUntrusted(slug)}".`
+    };
+  }
+  const checklistPath = checklistPathFor(projectRoot, slug, plansDir);
+  const gate = canEnterExecuting({
+    slug,
+    checklistPath,
+    paused: session.paused === 1,
+    projectRoot
+  });
+  if (!gate.ok) {
+    return {
+      ok: false,
+      userMessage: `Cannot start executing: ${gate.reason}.`
+    };
+  }
+  try {
+    const result = store.exclusiveWrite(() => {
+      if (concurrencyMode === "one_executor") {
+        const other = store.findExecutingSession(conversationId);
+        if (other) {
+          const userMessage = formatOneExecutorBusyMessage(
+            other.track_id,
+            other.conversation_id
+          );
+          return {
+            commit: false,
+            value: {
+              ok: false,
+              busy: true,
+              userMessage
+            }
+          };
+        }
+      }
+      const fresh = store.getSession(conversationId);
+      const alreadyExecutingSameTrack = fresh?.phase === "executing" && fresh.armed === 1 && fresh.paused === 0 && fresh.track_id === slug && sameChecklistBinding(fresh.checklist_path, checklistPath, projectRoot);
+      upsertTrack(store, slug, checklistPath, plansDir, projectRoot);
+      const updated = store.upsertSession({
+        conversation_id: conversationId,
+        project_root: projectRoot,
+        code_root: projectRoot,
+        track_id: slug,
+        checklist_path: checklistPath,
+        phase: "executing",
+        armed: 1,
+        paused: 0,
+        paused_reason: null,
+        pending_action: null,
+        track_candidates_json: null,
+        error_count: 0,
+        idle_stop_count: 0
+      });
+      if (!alreadyExecutingSameTrack) {
+        let reviewingItemId = null;
+        try {
+          const cl = parseChecklist(checklistPath, { projectRoot });
+          reviewingItemId = firstUnchecked(cl)?.id ?? null;
+        } catch {
+        }
+        store.updateReviewChain(conversationId, {
+          fix_round: 0,
+          confirm_left: null,
+          chain_pending: 0,
+          code_edited: 0,
+          item_confirm_complete: 0,
+          reviewing_item_id: reviewingItemId,
+          pending_followup: null,
+          pending_followup_at: null,
+          pending_redeliver_at: null
+        });
+      } else {
+        store.ensureReviewChain(conversationId);
+      }
+      return { commit: true, value: { ok: true, session: updated } };
+    });
+    if (!result.ok && result.busy === true) {
+      logBusyOccupier(result.userMessage);
     }
-    regexSource += "$";
-  } else if (line.includes("/")) {
-    regexSource = `(?:^|.*/)${body}`;
-    if (dirOnly || line.endsWith("/**") || line.endsWith("/*")) {
-      regexSource += "(?:/.*)?";
+    return result;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (/busy|locked|SQLITE_BUSY|SQLITE_LOCKED/i.test(msg)) {
+      const userMessage = "State database is busy; retry Autopilot RUN in a moment.";
+      logBusyOccupier(userMessage);
+      return {
+        ok: false,
+        busy: true,
+        userMessage
+      };
     }
-    regexSource += "$";
-  } else {
-    regexSource = `(?:^|.*/)?${body}$`;
+    throw err;
   }
-  return { negated, regex: new RegExp(regexSource) };
 }
-function parseAutopilotIgnore(text) {
-  const patterns = [];
-  for (const rawLine of text.split(/\r?\n/)) {
-    const compiled = compilePattern(rawLine);
-    if (!compiled) continue;
-    patterns.push(compiled);
-    if (patterns.length >= MAX_AUTOPILOT_IGNORE_PATTERNS) break;
+function applyReplan(store, conversationId, projectRoot, opts) {
+  const root = requireProjectRoot(store, projectRoot);
+  if (!root) {
+    return { ok: false, userMessage: "Invalid project root." };
   }
-  return patterns;
-}
-var DEFAULT_AUTOPILOT_IGNORE_PATTERNS = parseAutopilotIgnore(
-  DEFAULT_AUTOPILOT_IGNORE_TEXT
-);
-function normalizeRelativePath(filePath) {
-  return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
-}
-function isAutopilotIgnoredPath(relativePath, patterns) {
-  const norm = normalizeRelativePath(relativePath);
-  let ignored = false;
-  for (const pat of patterns) {
-    if (pat.regex.test(norm)) {
-      ignored = !pat.negated;
-    }
+  projectRoot = root;
+  const plansDir = requirePlansDir(projectRoot, opts?.config?.plansDir);
+  if (!plansDir) {
+    return { ok: false, userMessage: "Invalid plans directory." };
   }
-  return ignored;
-}
-function realpathForCompare(absPath) {
-  try {
-    return fs10.realpathSync(absPath);
-  } catch {
+  const session = ensureSession(
+    store,
+    conversationId,
+    projectRoot,
+    opts?.platform
+  );
+  let slug = opts?.slug;
+  if (!slug) {
+    const tid = session.track_id;
+    const midPick = session.pending_action === "run" || session.pending_action === "replan";
+    slug = !midPick && isBoundRunTrackId(tid) ? tid : void 0;
   }
-  let dir = path9.dirname(absPath);
-  const base = path9.basename(absPath);
-  const missing = [];
-  for (; ; ) {
-    try {
-      const realDir = fs10.realpathSync(dir);
-      return path9.join(realDir, ...missing, base);
-    } catch {
-      const parent = path9.dirname(dir);
-      if (parent === dir) return absPath;
-      missing.unshift(path9.basename(dir));
-      dir = parent;
-    }
+  if (slug && !isSafeTrackSlug(slug)) {
+    return {
+      ok: false,
+      userMessage: `Invalid track slug "${displayUntrusted(slug)}".`
+    };
   }
-}
-function toProjectRelativePath(filePath, projectRoot) {
-  const posix = filePath.replace(/\\/g, "/");
-  if (!projectRoot?.trim()) {
-    return normalizeRelativePath(posix);
+  if (!slug) {
+    const all = listTracks(projectRoot, store, "all", plansDir).filter(
+      (t) => isSafeTrackSlug(t.slug)
+    );
+    if (all.length === 1 && session.pending_action !== "run") {
+      slug = all[0].slug;
+    } else if (all.length > 1 || all.length === 1 && session.pending_action === "run") {
+      const clearingStaleBind = isBoundRunTrackId(session.track_id);
+      store.upsertSession({
+        conversation_id: conversationId,
+        project_root: session.project_root,
+        code_root: session.code_root,
+        track_id: clearingStaleBind ? "_pending" : session.track_id,
+        ...clearingStaleBind ? { checklist_path: "" } : {},
+        pending_action: "replan",
+        track_candidates_json: candidatePayload(all),
+        armed: 0
+      });
+      const lines = all.map((t, i) => {
+        const title = sanitizeSessionDisplayText(t.title || t.slug) || t.slug;
+        return `  ${i + 1}. ${t.slug} \u2014 ${title}`;
+      }).join("\n");
+      return {
+        ok: false,
+        needPick: true,
+        candidates: all,
+        userMessage: `Select a plan to replan:
+
+${lines}
+
+Reply with a number or /autopilot-replan <slug>.`
+      };
+    } else {
+      return {
+        ok: false,
+        userMessage: "No plan to replan. Use /autopilot-on first."
+      };
+    }
   }
-  const root = realpathForCompare(path9.resolve(projectRoot));
-  const abs = realpathForCompare(
-    path9.isAbsolute(posix) ? path9.resolve(posix) : path9.resolve(root, posix)
+  const checklistPath = trustedChecklistPath(
+    projectRoot,
+    plansDir,
+    slug,
+    session.checklist_path,
+    session.track_id
   );
-  const rel = path9.relative(root, abs);
-  if (rel.startsWith("..") || path9.isAbsolute(rel)) {
-    return "";
-  }
-  return normalizeRelativePath(rel.replace(/\\/g, "/"));
+  const updated = store.upsertSession({
+    conversation_id: conversationId,
+    project_root: projectRoot,
+    code_root: projectRoot,
+    track_id: slug,
+    checklist_path: checklistPath,
+    phase: "planning",
+    armed: 0,
+    paused: 0,
+    paused_reason: null,
+    pending_action: null,
+    track_candidates_json: null
+  });
+  store.updateReviewChain(conversationId, {
+    fix_round: 0,
+    confirm_left: null,
+    chain_pending: 0,
+    code_edited: 0,
+    item_confirm_complete: 0,
+    reviewing_item_id: null,
+    pending_followup: null,
+    pending_followup_at: null,
+    pending_redeliver_at: null
+  });
+  return { ok: true, session: updated };
 }
-function loadAutopilotIgnorePatterns(projectRoot) {
-  const root = path9.resolve(projectRoot);
-  const filePath = path9.join(root, ".autopilotignore");
-  let st;
-  try {
-    st = fs10.lstatSync(filePath);
-  } catch {
-    return DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
+function applyTrackPick(store, conversationId, projectRoot, pick, opts) {
+  const root = requireProjectRoot(store, projectRoot);
+  if (!root) {
+    return { ok: false, userMessage: "Invalid project root." };
   }
-  if (st.isSymbolicLink() || !st.isFile()) {
-    return DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
+  projectRoot = root;
+  const session = store.getSession(conversationId);
+  if (!session?.pending_action) {
+    return {
+      ok: false,
+      userMessage: "No pending track selection."
+    };
   }
-  if (st.size > MAX_AUTOPILOT_IGNORE_BYTES) {
-    return DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
+  const pending = session.pending_action;
+  if (pending !== "run" && pending !== "replan") {
+    return {
+      ok: false,
+      userMessage: `Unknown pending action "${displayUntrusted(pending)}".`
+    };
   }
-  const cached = ignoreCache.get(root);
-  if (cached && cached.mtimeMs === st.mtimeMs) {
-    return cached.patterns;
+  if (!session.track_candidates_json) {
+    return { ok: false, userMessage: "Invalid track candidates JSON." };
   }
-  let text;
+  let candidates = [];
   try {
-    text = fs10.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(session.track_candidates_json);
+    if (!Array.isArray(parsed) || parsed.length === 0) {
+      return { ok: false, userMessage: "Invalid track candidates JSON." };
+    }
+    const hasValidSlug = parsed.some(
+      (c) => !!c && typeof c === "object" && !Array.isArray(c) && typeof c.slug === "string" && isSafeTrackSlug(c.slug)
+    );
+    if (!hasValidSlug) {
+      return { ok: false, userMessage: "Invalid track candidates JSON." };
+    }
+    candidates = parsed;
   } catch {
-    return DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
+    return { ok: false, userMessage: "Invalid track candidates JSON." };
   }
-  if (text.length > MAX_AUTOPILOT_IGNORE_BYTES) {
-    return DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
+  let slug;
+  if (/^\d+$/.test(pick)) {
+    const idx = Number.parseInt(pick, 10) - 1;
+    const entry = candidates[idx];
+    slug = entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.slug === "string" ? entry.slug : void 0;
+    if (!slug || !isSafeTrackSlug(slug)) {
+      return {
+        ok: false,
+        userMessage: `Invalid selection "${displayUntrusted(pick)}". Choose 1\u2013${candidates.length}.`
+      };
+    }
+  } else {
+    if (!isSafeTrackSlug(pick)) {
+      return {
+        ok: false,
+        userMessage: `Invalid track slug "${displayUntrusted(pick)}".`
+      };
+    }
+    slug = pick;
+    if (!candidates.some(
+      (c) => !!c && typeof c === "object" && !Array.isArray(c) && c.slug === slug
+    )) {
+      return {
+        ok: false,
+        userMessage: `Unknown slug "${displayUntrusted(pick)}".`
+      };
+    }
   }
-  const patterns = parseAutopilotIgnore(text);
-  ignoreCache.set(root, { mtimeMs: st.mtimeMs, patterns });
-  return patterns;
-}
-
-// ../core/src/code-edit-detector.ts
-function isUntrackedGitIgnored(projectRoot, relativePath) {
-  if (!relativePath || relativePath.includes("\0")) return false;
-  try {
-    const r = spawnSync(
-      "git",
-      ["check-ignore", "-q", "--", relativePath],
-      {
-        cwd: projectRoot,
-        encoding: "utf8",
-        timeout: 5e3,
-        windowsHide: true,
-        shell: false
-      }
-    );
-    return r.status === 0;
-  } catch {
-    return false;
+  if (pending === "replan") {
+    return applyReplan(store, conversationId, projectRoot, {
+      slug,
+      config: opts?.config,
+      platform: opts?.platform
+    });
   }
-}
-function isProductCodeEdit(filePath, opts) {
-  const relative = toProjectRelativePath(filePath, opts?.projectRoot);
-  if (!relative) return false;
-  const patterns = opts?.projectRoot?.trim() ? loadAutopilotIgnorePatterns(opts.projectRoot) : DEFAULT_AUTOPILOT_IGNORE_PATTERNS;
-  if (isAutopilotIgnoredPath(relative, patterns)) return false;
-  const root = opts?.projectRoot?.trim();
-  if (root && isUntrackedGitIgnored(root, relative)) return false;
-  return true;
+  return applyRun(store, conversationId, projectRoot, {
+    slug,
+    config: opts?.config,
+    platform: opts?.platform
+  });
 }
 
 // ../ports/cursor/src/index.ts