@rallycry/conveyor-agent 10.2.1 → 10.2.4

package/dist/{chunk-YGLTLUGA.js → chunk-DEMRCBJN.js}

@@ -1,3 +1,7 @@
+import {
+  LoopLagMonitor
+} from "./chunk-7TQO4ZF4.js";
+
 // src/setup/bootstrap.ts
 var BOOTSTRAP_TIMEOUT_MS = 3e4;
 var RETRY_DELAYS_MS = [5e3, 1e4, 2e4];
@@ -115,6 +119,9 @@ function applyBootstrapToEnv(config) {
 }
 
 // src/connection/agent-connection.ts
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { Worker } from "worker_threads";
 import { io } from "socket.io-client";
 
 // src/setup/bootstrap-poll.ts
@@ -188,6 +195,8 @@ var AgentConnection = class _AgentConnection {
   finalizeSnapshotCallback = null;
   runStartCommandCallback = null;
   earlyPullBranches = [];
+  spawnReviewCallback = null;
+  earlySpawnReviews = [];
   // PTY relay (S5 terminal). Single-slot callbacks, set per PtySession run.
   ptyInputCallback = null;
   ptyResizeCallback = null;
@@ -391,6 +400,10 @@ var AgentConnection = class _AgentConnection {
         if (this.pullBranchCallback) this.pullBranchCallback(data);
         else this.earlyPullBranches.push(data);
       });
+      this.socket.on("session:spawnReview", (data) => {
+        if (this.spawnReviewCallback) this.spawnReviewCallback(data);
+        else this.earlySpawnReviews.push(data);
+      });
       this.socket.on("session:finalizeSnapshot", () => {
         this.finalizeSnapshotCallback?.();
       });
@@ -445,8 +458,12 @@ var AgentConnection = class _AgentConnection {
         void this.refreshTaskTokenFromBootstrap().catch(() => {
         });
       });
-      this.socket.io.on("reconnect", () => {
-        process.stderr.write("[conveyor-agent] Reconnected\n");
+      this.socket.io.on("reconnect", (reconnectAttempts) => {
+        process.stderr.write(
+          `[conveyor-agent] Reconnected (attempts: ${reconnectAttempts}, ${(/* @__PURE__ */ new Date()).toISOString()})
+`
+        );
+        this.sendHeartbeat();
         void this.reconnectToSession();
       });
       this.socket.io.on("reconnect_attempt", () => {
@@ -456,6 +473,7 @@ var AgentConnection = class _AgentConnection {
   disconnect() {
     this.stopProactiveTokenRefresh();
     this.clearSocketRecycle();
+    this.stopHeartbeatWorker();
     void this.flushEvents();
     if (this.socket) {
       this.socket.io.reconnection(false);
@@ -621,6 +639,26 @@ var AgentConnection = class _AgentConnection {
     for (const data of this.earlyPullBranches) callback(data);
     this.earlyPullBranches = [];
   }
+  onSpawnReview(callback) {
+    this.spawnReviewCallback = callback;
+    for (const data of this.earlySpawnReviews) callback(data);
+    this.earlySpawnReviews = [];
+  }
+  /**
+   * Report that a same-pod review child failed to spawn (fire-and-forget).
+   * The server Ends the orphaned review session and falls back to a dedicated
+   * review pod. sessionId is OUR (builder) session — the SEC-9 guard runs on
+   * it; the review session is identified separately.
+   */
+  reportReviewSpawnFailure(reviewSessionId, error) {
+    if (!this.socket) return;
+    void this.call("reportReviewSpawnFailure", {
+      sessionId: this.config.sessionId,
+      reviewSessionId,
+      ...error ? { error: error.slice(0, 2e3) } : {}
+    }).catch(() => {
+    });
+  }
   onFinalizeSnapshot(callback) {
     this.finalizeSnapshotCallback = callback;
   }
@@ -642,6 +680,19 @@ var AgentConnection = class _AgentConnection {
     }).catch(() => {
     });
   }
+  /**
+   * Forward one compact chat-proxy event derived from the transcript JSONL to
+   * the relay (fire-and-forget). Feeds the experimental chat PTY proxy ring.
+   * Old servers that don't know the method reject harmlessly.
+   */
+  sendPtyChatEvent(event) {
+    if (!this.socket) return;
+    void this.call("ptyChatEvent", {
+      sessionId: this.config.sessionId,
+      event
+    }).catch(() => {
+    });
+  }
   /**
    * Report that the interactive CLI process for this session has died and no
    * respawn is imminent (fire-and-forget). The server clears the scrollback
@@ -751,7 +802,7 @@ var AgentConnection = class _AgentConnection {
     if (this.recentMessages.length > 3) this.recentMessages.shift();
     return { duplicate: false };
   }
-  sendHeartbeat() {
+  sendHeartbeat(loopLagMs) {
     if (!this.socket) return;
     const statusMap = {
       running: "active",
@@ -764,10 +815,67 @@ var AgentConnection = class _AgentConnection {
     void this.call("heartbeat", {
       sessionId: this.config.sessionId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      status: heartbeatStatus
+      status: heartbeatStatus,
+      ...loopLagMs !== void 0 && loopLagMs > 0 ? { loopLagMs: Math.round(loopLagMs) } : {}
     }).catch(() => {
     });
   }
+  // ── Starvation-proof heartbeat worker ────────────────────────────────
+  //
+  // A worker thread with its own event loop + Socket.IO connection keeps the
+  // v3 session lease renewed even when the MAIN loop is stalled (the failure
+  // mode where a heavy gate got the session declared stranded and restarted
+  // mid-run). Best-effort by design: any spawn/runtime failure just degrades
+  // heartbeats to main-loop-only. See heartbeat-worker.ts for the policy.
+  heartbeatWorker = null;
+  startHeartbeatWorker(sharedBuffer, intervalMs = 3e4) {
+    if (this.heartbeatWorker) return;
+    try {
+      const workerUrl = new URL("./heartbeat-worker.js", import.meta.url);
+      if (!existsSync(fileURLToPath(workerUrl))) {
+        process.stderr.write(
+          "[conveyor-agent] heartbeat worker bundle not found \u2014 main-loop heartbeat only\n"
+        );
+        return;
+      }
+      const worker = new Worker(workerUrl, {
+        workerData: {
+          apiUrl: this.config.apiUrl,
+          taskToken: this.config.taskToken,
+          sessionId: this.config.sessionId,
+          runnerMode: this.config.runnerMode ?? "task",
+          sharedBuffer,
+          intervalMs
+        }
+      });
+      worker.unref();
+      worker.on("error", (err) => {
+        process.stderr.write(`[conveyor-agent] heartbeat worker error: ${err.message}
+`);
+        this.heartbeatWorker = null;
+      });
+      worker.on("exit", (code) => {
+        if (code !== 0) {
+          process.stderr.write(`[conveyor-agent] heartbeat worker exited (code ${code})
+`);
+        }
+        this.heartbeatWorker = null;
+      });
+      this.heartbeatWorker = worker;
+      process.stderr.write("[conveyor-agent] heartbeat worker started\n");
+    } catch (err) {
+      process.stderr.write(
+        `[conveyor-agent] heartbeat worker failed to start: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      this.heartbeatWorker = null;
+    }
+  }
+  stopHeartbeatWorker() {
+    const worker = this.heartbeatWorker;
+    this.heartbeatWorker = null;
+    if (worker) void worker.terminate();
+  }
   emitModeChanged(agentMode) {
     this.sendEvent({ type: "mode_changed", agentMode });
   }
@@ -901,6 +1009,7 @@ ${q.question}${q.options.length ? "\n" + q.options.map((o) => `- ${o.label}: ${o
           auth.taskToken = result.config.taskToken;
         }
       }
+      this.heartbeatWorker?.postMessage({ taskToken: result.config.taskToken });
     }
     const refreshedClaude = Boolean(result.config.envVars?.CLAUDE_CODE_OAUTH_TOKEN);
     return { refreshedClaude, refreshedTaskToken };
@@ -933,6 +1042,7 @@ ${q.question}${q.options.length ? "\n" + q.options.map((o) => `- ${o.label}: ${o
           auth.taskToken = bundle.sessionJwt;
         }
       }
+      this.heartbeatWorker?.postMessage({ taskToken: bundle.sessionJwt });
     }
     const refreshedClaude = Boolean(bundle.envVars?.CLAUDE_CODE_OAUTH_TOKEN);
     return { refreshedClaude, refreshedTaskToken };
@@ -1014,14 +1124,25 @@ function createServiceLogger(service) {
 }
 
 // src/runner/git-utils.ts
-import { execSync, exec } from "child_process";
+import { execFile } from "child_process";
 import { realpathSync } from "fs";
 import { promisify } from "util";
-var execAsync = promisify(exec);
-function syncWithBaseBranch(cwd, baseBranch) {
+var execFileAsync = promisify(execFile);
+var GIT_TIMEOUT_MS = 6e4;
+var GIT_SLOW_TIMEOUT_MS = 12e4;
+var GIT_MAX_BUFFER = 16 * 1024 * 1024;
+async function git(cwd, args, timeoutMs = GIT_TIMEOUT_MS) {
+  const { stdout } = await execFileAsync("git", args, {
+    cwd,
+    timeout: timeoutMs,
+    maxBuffer: GIT_MAX_BUFFER
+  });
+  return stdout.toString().trim();
+}
+async function syncWithBaseBranch(cwd, baseBranch) {
   if (!baseBranch) return true;
   try {
-    execSync(`git fetch origin ${baseBranch}`, { cwd, stdio: "ignore", timeout: 6e4 });
+    await git(cwd, ["fetch", "origin", baseBranch]);
   } catch {
     process.stderr.write(
       `[conveyor-agent] Warning: git fetch origin ${baseBranch} failed, continuing with current base
@@ -1030,14 +1151,14 @@ function syncWithBaseBranch(cwd, baseBranch) {
     return false;
   }
   try {
-    execSync(`git merge origin/${baseBranch} --no-edit`, { cwd, stdio: "ignore", timeout: 3e4 });
+    await git(cwd, ["merge", `origin/${baseBranch}`, "--no-edit"], 3e4);
   } catch {
     process.stderr.write(
       `[conveyor-agent] Warning: merge origin/${baseBranch} failed, aborting merge and continuing
 `
     );
     try {
-      execSync("git merge --abort", { cwd, stdio: "ignore" });
+      await git(cwd, ["merge", "--abort"], 3e4);
     } catch {
     }
     return false;
@@ -1046,23 +1167,19 @@ function syncWithBaseBranch(cwd, baseBranch) {
 `);
   return true;
 }
-function ensureOnTaskBranch(cwd, taskBranch) {
+async function ensureOnTaskBranch(cwd, taskBranch) {
   if (!taskBranch) return true;
-  const current = getCurrentBranch(cwd);
+  const current = await getCurrentBranch(cwd);
   if (current === taskBranch) return true;
   try {
-    execSync(`git fetch origin ${taskBranch}`, { cwd, stdio: "ignore", timeout: 6e4 });
+    await git(cwd, ["fetch", "origin", taskBranch]);
   } catch {
     process.stderr.write(`[conveyor-agent] Warning: git fetch origin ${taskBranch} failed
 `);
     return false;
   }
   try {
-    execSync(`git checkout -B ${taskBranch} origin/${taskBranch}`, {
-      cwd,
-      stdio: "ignore",
-      timeout: 3e4
-    });
+    await git(cwd, ["checkout", "-B", taskBranch, `origin/${taskBranch}`], 3e4);
   } catch {
     process.stderr.write(`[conveyor-agent] Warning: git checkout ${taskBranch} failed
 `);
@@ -1072,74 +1189,62 @@ function ensureOnTaskBranch(cwd, taskBranch) {
 `);
   return true;
 }
-function hasUncommittedChanges(cwd) {
-  const status = execSync("git status --porcelain", {
-    cwd,
-    stdio: ["ignore", "pipe", "ignore"]
-  }).toString().trim();
+async function hasUncommittedChanges(cwd) {
+  const status = await git(cwd, ["status", "--porcelain"], GIT_SLOW_TIMEOUT_MS);
   return status.length > 0;
 }
-function getCurrentBranch(cwd) {
+async function getCurrentBranch(cwd) {
   try {
-    const branch = execSync("git branch --show-current", {
-      cwd,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().trim();
+    const branch = await git(cwd, ["branch", "--show-current"]);
     return branch || null;
   } catch {
     return null;
   }
 }
-function hasUnpushedCommits(cwd) {
+async function hasUnpushedCommits(cwd) {
   try {
-    const currentBranch = getCurrentBranch(cwd);
+    const currentBranch = await getCurrentBranch(cwd);
     if (!currentBranch) return false;
     try {
-      execSync(`git rev-parse origin/${currentBranch}`, {
-        cwd,
-        stdio: ["ignore", "pipe", "ignore"]
-      });
+      await git(cwd, ["rev-parse", `origin/${currentBranch}`]);
     } catch {
       try {
-        execSync("git rev-parse HEAD", { cwd, stdio: ["ignore", "pipe", "ignore"] });
+        await git(cwd, ["rev-parse", "HEAD"]);
         return true;
       } catch {
         return false;
       }
     }
-    const ahead = execSync(`git rev-list --count HEAD --not origin/${currentBranch}`, {
-      cwd,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().trim();
+    const ahead = await git(cwd, [
+      "rev-list",
+      "--count",
+      "HEAD",
+      "--not",
+      `origin/${currentBranch}`
+    ]);
     return parseInt(ahead, 10) > 0;
   } catch {
     return false;
   }
 }
-function stageAndCommit(cwd, message) {
+async function stageAndCommit(cwd, message) {
   try {
-    execSync("git add -A", { cwd, stdio: ["ignore", "pipe", "ignore"] });
-    if (!hasUncommittedChanges(cwd)) return null;
-    execSync(`git commit -m ${JSON.stringify(message)}`, {
-      cwd,
-      stdio: ["ignore", "pipe", "ignore"]
-    });
-    return execSync("git rev-parse HEAD", { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    await git(cwd, ["add", "-A"], GIT_SLOW_TIMEOUT_MS);
+    if (!await hasUncommittedChanges(cwd)) return null;
+    await git(cwd, ["commit", "-m", message], GIT_SLOW_TIMEOUT_MS);
+    return await git(cwd, ["rev-parse", "HEAD"]);
   } catch {
     return null;
   }
 }
 async function tryPush(cwd, branch, skipVerify = false) {
-  const noVerify = skipVerify ? "--no-verify " : "";
+  const noVerify = skipVerify ? ["--no-verify"] : [];
   try {
-    await execAsync(`git push ${noVerify}origin ${branch}`, { cwd, timeout: 3e4 });
+    await git(cwd, ["push", ...noVerify, "origin", branch], 3e4);
     return true;
   } catch {
     try {
-      await execAsync(`git push ${noVerify}--force-with-lease origin ${branch}`, {
-        cwd,
-        timeout: 3e4
-      });
+      await git(cwd, ["push", ...noVerify, "--force-with-lease", "origin", branch], 3e4);
       return true;
     } catch {
       return false;
@@ -1148,7 +1253,7 @@ async function tryPush(cwd, branch, skipVerify = false) {
 }
 async function isAuthError(cwd) {
   try {
-    await execAsync("git push --dry-run", { cwd, timeout: 3e4 });
+    await git(cwd, ["push", "--dry-run"], 3e4);
     return false;
   } catch (err) {
     if (err.killed) return true;
@@ -1158,16 +1263,18 @@ async function isAuthError(cwd) {
     return /authentication|authorization|403|401|token/i.test(msg);
   }
 }
-function updateRemoteToken(cwd, token) {
+async function updateRemoteToken(cwd, token) {
   try {
-    const url = execSync("git remote get-url origin", { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    const url = await git(cwd, ["remote", "get-url", "origin"]);
     const match = url.match(/github\.com[/:]([^/]+\/[^/.]+)/);
     if (match) {
       const repo = match[1].replace(/\.git$/, "");
-      execSync(
-        `git remote set-url origin "https://x-access-token:${token}@github.com/${repo}.git"`,
-        { cwd, stdio: ["ignore", "pipe", "ignore"] }
-      );
+      await git(cwd, [
+        "remote",
+        "set-url",
+        "origin",
+        `https://x-access-token:${token}@github.com/${repo}.git`
+      ]);
     }
   } catch {
   }
@@ -1176,30 +1283,24 @@ function wipRefForBranch(branch) {
   return `conveyor-wip/${branch}`;
 }
 var wipRefPushed = /* @__PURE__ */ new Set();
-function createWipSnapshot(cwd, message) {
+async function createWipSnapshot(cwd, message) {
   try {
-    execSync("git add -A", { cwd, stdio: ["ignore", "pipe", "ignore"] });
-    const sha = execSync(`git stash create ${JSON.stringify(message)}`, {
-      cwd,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().trim();
+    await git(cwd, ["add", "-A"], GIT_SLOW_TIMEOUT_MS);
+    const sha = await git(cwd, ["stash", "create", message], GIT_SLOW_TIMEOUT_MS);
     return sha || null;
   } catch {
     return null;
   } finally {
     try {
-      execSync("git reset -q", { cwd, stdio: ["ignore", "pipe", "ignore"] });
+      await git(cwd, ["reset", "-q"], GIT_SLOW_TIMEOUT_MS);
     } catch {
     }
   }
 }
-function tryPushRefspec(cwd, refspec, force = false) {
+async function tryPushRefspec(cwd, refspec, force = false) {
   try {
-    execSync(`git push --no-verify ${force ? "--force " : ""}origin ${JSON.stringify(refspec)}`, {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 3e4
-    });
+    const forceArgs = force ? ["--force"] : [];
+    await git(cwd, ["push", "--no-verify", ...forceArgs, "origin", refspec], 3e4);
     return true;
   } catch {
     return false;
@@ -1210,49 +1311,39 @@ async function refreshRemoteToken(cwd, refreshToken) {
   try {
     const token = await refreshToken();
     if (token) {
-      updateRemoteToken(cwd, token);
+      await updateRemoteToken(cwd, token);
       process.env.GITHUB_TOKEN = token;
       process.env.GH_TOKEN = token;
     }
   } catch {
   }
 }
-function restoreWipSnapshot(cwd, branch) {
+async function restoreWipSnapshot(cwd, branch) {
   if (!branch) return "none";
   const ref = wipRefForBranch(branch);
   try {
-    execSync(`git fetch origin +refs/heads/${ref}:refs/remotes/origin/${ref}`, {
-      cwd,
-      stdio: "ignore",
-      timeout: 6e4
-    });
+    await git(cwd, ["fetch", "origin", `+refs/heads/${ref}:refs/remotes/origin/${ref}`]);
   } catch {
     return "none";
   }
   wipRefPushed.add(cwd);
   try {
-    const sha = execSync(`git rev-parse refs/remotes/origin/${ref}`, {
-      cwd,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().trim();
-    const parent = execSync(`git rev-parse "${sha}^"`, {
-      cwd,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().trim();
-    const head = execSync("git rev-parse HEAD", { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    const sha = await git(cwd, ["rev-parse", `refs/remotes/origin/${ref}`]);
+    const parent = await git(cwd, ["rev-parse", `${sha}^`]);
+    const head = await git(cwd, ["rev-parse", "HEAD"]);
     if (parent !== head) {
       try {
-        execSync(`git stash apply ${sha}`, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        await git(cwd, ["stash", "apply", sha], GIT_SLOW_TIMEOUT_MS);
         return "applied";
       } catch {
         try {
-          execSync("git reset --merge", { cwd, stdio: "ignore" });
+          await git(cwd, ["reset", "--merge"], GIT_SLOW_TIMEOUT_MS);
         } catch {
         }
         return "stale";
       }
     }
-    execSync(`git stash apply ${sha}`, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+    await git(cwd, ["stash", "apply", sha], GIT_SLOW_TIMEOUT_MS);
     return "applied";
   } catch {
     return "failed";
@@ -1263,10 +1354,10 @@ async function flushPendingChanges(cwd, opts) {
   let pushed = false;
   let hadWork = false;
   try {
-    const branch = getCurrentBranch(cwd);
+    const branch = await getCurrentBranch(cwd);
     if (!branch) return { committed, pushed, hadWork };
-    const dirty = hasUncommittedChanges(cwd);
-    const unpushed = hasUnpushedCommits(cwd);
+    const dirty = await hasUncommittedChanges(cwd);
+    const unpushed = await hasUnpushedCommits(cwd);
     if (!dirty && !unpushed) {
       await dropStaleWipRef(cwd, branch, opts?.refreshToken);
       return { committed, pushed, hadWork };
@@ -1278,9 +1369,9 @@ async function flushPendingChanges(cwd, opts) {
     }
     if (dirty) {
       const message = opts?.wipMessage ?? "WIP: conveyor-agent snapshot";
-      const sha = createWipSnapshot(cwd, message);
+      const sha = await createWipSnapshot(cwd, message);
       if (sha) {
-        committed = tryPushRefspec(cwd, `${sha}:refs/heads/${wipRefForBranch(branch)}`, true);
+        committed = await tryPushRefspec(cwd, `${sha}:refs/heads/${wipRefForBranch(branch)}`, true);
         if (committed) wipRefPushed.add(cwd);
       }
     }
@@ -1291,19 +1382,19 @@ async function flushPendingChanges(cwd, opts) {
 async function dropStaleWipRef(cwd, branch, refreshToken) {
   if (!wipRefPushed.has(cwd)) return;
   await refreshRemoteToken(cwd, refreshToken);
-  if (tryPushRefspec(cwd, `:refs/heads/${wipRefForBranch(branch)}`)) {
+  if (await tryPushRefspec(cwd, `:refs/heads/${wipRefForBranch(branch)}`)) {
     wipRefPushed.delete(cwd);
   }
 }
 async function pushToOrigin(cwd, refreshToken, skipVerify = false) {
   try {
-    const currentBranch = getCurrentBranch(cwd);
+    const currentBranch = await getCurrentBranch(cwd);
     if (!currentBranch) return false;
     if (refreshToken) {
       try {
         const token = await refreshToken();
         if (token) {
-          updateRemoteToken(cwd, token);
+          await updateRemoteToken(cwd, token);
           process.env.GITHUB_TOKEN = token;
           process.env.GH_TOKEN = token;
         }
@@ -1314,7 +1405,7 @@ async function pushToOrigin(cwd, refreshToken, skipVerify = false) {
     if (refreshToken && await isAuthError(cwd)) {
       const token = await refreshToken();
       if (token) {
-        updateRemoteToken(cwd, token);
+        await updateRemoteToken(cwd, token);
         process.env.GITHUB_TOKEN = token;
         process.env.GH_TOKEN = token;
         return await tryPush(cwd, currentBranch, skipVerify);
@@ -1328,12 +1419,9 @@ async function pushToOrigin(cwd, refreshToken, skipVerify = false) {
 function branchBackupRef(branch) {
   return `conveyor-wip/branches/${branch}`;
 }
-function listWorktrees(cwd) {
+async function listWorktrees(cwd) {
   try {
-    const out = execSync("git worktree list --porcelain", {
-      cwd,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString();
+    const out = await git(cwd, ["worktree", "list", "--porcelain"]);
     const result = [];
     for (const entry of out.split("\n\n")) {
       const lines = entry.trim().split("\n");
@@ -1350,22 +1438,17 @@ function listWorktrees(cwd) {
     return [];
   }
 }
-function listLocalBranches(cwd) {
+async function listLocalBranches(cwd) {
   try {
-    return execSync("git for-each-ref --format='%(refname:short)' refs/heads/", {
-      cwd,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().split("\n").map((s) => s.trim()).filter(Boolean);
+    const out = await git(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/heads/"]);
+    return out.split("\n").map((s) => s.trim()).filter(Boolean);
   } catch {
     return [];
   }
 }
-function branchUnpushedCount(cwd, branch) {
+async function branchUnpushedCount(cwd, branch) {
   try {
-    const n = execSync(`git rev-list --count ${JSON.stringify(branch)} --not --remotes=origin`, {
-      cwd,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).toString().trim();
+    const n = await git(cwd, ["rev-list", "--count", branch, "--not", "--remotes=origin"]);
     return Number.parseInt(n, 10) || 0;
   } catch {
     return 0;
@@ -1378,392 +1461,56 @@ function samePath(a, b) {
     return a === b;
   }
 }
-async function flushAllPendingWork(cwd, opts) {
-  try {
-    const primary = await flushPendingChanges(cwd, opts);
-    await refreshRemoteToken(cwd, opts?.refreshToken);
-    const currentBranch = getCurrentBranch(cwd);
-    const worktreesSnapshotted = snapshotOtherWorktrees(cwd, opts?.wipMessage);
-    const branchesBackedUp = backupOtherBranches(cwd, currentBranch);
-    return {
-      hadWork: primary.hadWork || worktreesSnapshotted > 0 || branchesBackedUp > 0,
-      branchesBackedUp,
-      worktreesSnapshotted
-    };
-  } catch {
-    return { hadWork: false, branchesBackedUp: 0, worktreesSnapshotted: 0 };
-  }
-}
-function snapshotOtherWorktrees(cwd, wipMessage) {
-  let count = 0;
-  for (const wt of listWorktrees(cwd)) {
-    if (samePath(wt.path, cwd) || !wt.branch) continue;
-    try {
-      if (!hasUncommittedChanges(wt.path)) continue;
-      const sha = createWipSnapshot(wt.path, wipMessage ?? "WIP: conveyor-agent snapshot");
-      if (sha && tryPushRefspec(wt.path, `${sha}:refs/heads/${wipRefForBranch(wt.branch)}`, true)) {
-        wipRefPushed.add(wt.path);
-        count++;
-      }
-    } catch {
-    }
-  }
-  return count;
-}
-function backupOtherBranches(cwd, currentBranch) {
-  let count = 0;
-  for (const branch of listLocalBranches(cwd)) {
-    if (branch === currentBranch || branch.startsWith("conveyor-wip/")) continue;
-    try {
-      if (branchUnpushedCount(cwd, branch) === 0) continue;
-      if (tryPushRefspec(cwd, `refs/heads/${branch}:refs/heads/${branchBackupRef(branch)}`, true)) {
-        count++;
-      }
-    } catch {
-    }
-  }
-  return count;
-}
-
-// src/runner/plan-sync.ts
-import { readdirSync, statSync, readFileSync } from "fs";
-import { join as join2 } from "path";
-
-// src/harness/pty/settings.ts
-import { mkdir, writeFile, chmod } from "fs/promises";
-import { homedir } from "os";
-import { join } from "path";
-function claudeConfigHome() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
-}
-function projectSlug(cwd) {
-  return cwd.replace(/\//g, "-");
-}
-function sessionTranscriptPath(cwd, sessionId) {
-  return join(claudeConfigHome(), "projects", projectSlug(cwd), `${sessionId}.jsonl`);
-}
-function configHomePlansDir() {
-  return join(claudeConfigHome(), "plans");
-}
-var ALLOW_RULES = [
-  "Bash",
-  "BashOutput",
-  "Edit",
-  "Write",
-  "Read",
-  "Glob",
-  "Grep",
-  "WebFetch",
-  "WebSearch",
-  "NotebookEdit",
-  "Task",
-  "TodoWrite",
-  "ToolSearch",
-  "KillShell",
-  "SlashCommand",
-  "Skill",
-  "mcp__conveyor__*"
-];
-var HOOK_HELPER_SOURCE = `"use strict";
-const net = require("node:net");
-const crypto = require("node:crypto");
-
-const PRE_TOOL_USE_TIMEOUT_MS = 110000;
-const ASK_USER_QUESTION_TIMEOUT_MS = 5000;
-
-let raw = "";
-process.stdin.setEncoding("utf8");
-process.stdin.on("data", (chunk) => {
-  raw += chunk;
-});
-process.stdin.on("end", () => {
-  let payload = {};
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object") payload = parsed;
-  } catch {
-    payload = {};
-  }
-  if (payload.hook_event_name === "PreToolUse") {
-    preToolUse(payload);
-  } else {
-    relayProgress(typeof payload.tool_name === "string" ? payload.tool_name : "");
-  }
-});
-
-function relayProgress(toolName) {
-  const socketPath = process.env.CONVEYOR_HOOK_SOCKET;
-  let done = false;
-  const finish = () => {
-    if (done) return;
-    done = true;
-    process.stdout.write(JSON.stringify({ continue: true }));
-    process.exit(0);
-  };
-  const fallback = setTimeout(finish, 250);
-  if (!socketPath) {
-    clearTimeout(fallback);
-    finish();
-    return;
-  }
-  const client = net.connect(socketPath, () => {
-    // PostToolUse does not supply tool duration, so elapsed_time_seconds is
-    // omitted rather than reported as a misleading 0 (the field is optional).
-    const line = JSON.stringify({ tool_name: toolName }) + "\\n";
-    client.write(line, () => {
-      client.end();
-    });
-  });
-  client.on("close", () => {
-    clearTimeout(fallback);
-    finish();
-  });
-  client.on("error", () => {
-    clearTimeout(fallback);
-    finish();
-  });
-}
-
-function preToolUse(payload) {
-  const socketPath = process.env.CONVEYOR_HOOK_SOCKET;
-  let done = false;
-  const respond = (decision, reason) => {
-    if (done) return;
-    done = true;
-    process.stdout.write(
-      JSON.stringify({
-        hookSpecificOutput: {
-          hookEventName: "PreToolUse",
-          permissionDecision: decision,
-          ...(reason ? { permissionDecisionReason: reason } : {}),
-        },
-      }),
-    );
-    process.exit(0);
-  };
-  // MCP tools are auto-allowed locally \u2014 no socket round trip, no fail-mode.
-  // Plan mode prompts for them despite permissions.allow (the CLI can't
-  // classify MCP tools as read-only), and the pod is the sandbox.
-  if (typeof payload.tool_name === "string" && payload.tool_name.startsWith("mcp__")) {
-    respond("allow");
-    return;
-  }
-  // AskUserQuestion is observe-only (status reporting) \u2014 fail OPEN so a
-  // missing/slow socket never denies the questionnaire. Everything else
-  // (ExitPlanMode) is a Conveyor gate \u2014 fail CLOSED.
-  const failOpen = payload.tool_name === "AskUserQuestion";
-  const respondUnavailable = () =>
-    failOpen
-      ? respond("allow")
-      : respond(
-          "deny",
-          "Conveyor validation is unavailable right now. Wait a moment and call the tool again.",
-        );
-  if (!socketPath) {
-    respondUnavailable();
-    return;
-  }
-  const id = crypto.randomBytes(8).toString("hex");
-  const timer = setTimeout(
-    respondUnavailable,
-    failOpen ? ASK_USER_QUESTION_TIMEOUT_MS : PRE_TOOL_USE_TIMEOUT_MS,
-  );
-  const client = net.connect(socketPath, () => {
-    client.write(
-      JSON.stringify({
-        kind: "pre_tool_use",
-        id,
-        tool_name: typeof payload.tool_name === "string" ? payload.tool_name : "",
-        tool_input:
-          payload.tool_input && typeof payload.tool_input === "object" ? payload.tool_input : {},
-      }) + "\\n",
-    );
-  });
-  let buffer = "";
-  client.on("data", (chunk) => {
-    buffer += chunk.toString("utf8");
-    let index = buffer.indexOf("\\n");
-    while (index >= 0) {
-      const line = buffer.slice(0, index);
-      buffer = buffer.slice(index + 1);
-      try {
-        const verdict = JSON.parse(line);
-        if (verdict && verdict.id === id) {
-          clearTimeout(timer);
-          client.end();
-          respond(verdict.decision === "allow" ? "allow" : "deny", verdict.reason);
-          return;
-        }
-      } catch {
-        /* keep scanning */
-      }
-      index = buffer.indexOf("\\n");
-    }
-  });
-  client.on("error", () => {
-    clearTimeout(timer);
-    respondUnavailable();
-  });
-  client.on("close", () => {
-    clearTimeout(timer);
-    respondUnavailable();
-  });
-}
-`;
-async function writeHookSettings(dir) {
-  const helperPath = join(dir, "hook-helper.cjs");
-  const settingsPath = join(dir, "settings.json");
-  await mkdir(dir, { recursive: true });
-  await writeFile(helperPath, HOOK_HELPER_SOURCE, "utf8");
-  await chmod(helperPath, 493);
-  const settings = {
-    // Pre-accept Claude Code's "Bypass Permissions mode" disclaimer. Build-capable
-    // spawns pass `--dangerously-skip-permissions`; on a real PTY the CLI otherwise
-    // parks on the interactive "Yes, I accept / No, exit" dialog whose default focus
-    // is "No, exit" — so it cannot be auto-dismissed by an Enter nudge and the run
-    // stalls until the auto-nudge watchdog shuts it down. The CLI reads this key
-    // from the `--settings` (flagSettings) layer via its bypass-mode gate, so
-    // setting it here suppresses the dialog deterministically on every spawn —
-    // independent of the `bypassPermissionsModeAccepted` seed in credentials.ts,
-    // which the CLI's one-time migration consumes and which is subject to
-    // persistence races on the codespace user-home.
-    skipDangerousModePermissionPrompt: true,
-    // Auto-approve tool calls so the interactive (PTY) agent never stops to
-    // prompt the viewer. This only suppresses per-tool approval prompts — it
-    // does NOT relax the planning gate: in discovery/plan mode the spawn passes
-    // `--permission-mode plan`, which keeps the agent read-only (no edits/commits
-    // until it exits plan mode) regardless of this allow-list. In build mode the
-    // spawn already bypasses prompts via `--dangerously-skip-permissions`.
-    // NOTE: a bare "*" rule is INVALID (the CLI rejects it and parks the TUI on
-    // a Settings Warning dialog at boot) — hence the explicit ALLOW_RULES list.
-    permissions: {
-      allow: ALLOW_RULES
-    },
-    hooks: {
-      PreToolUse: [
-        {
-          matcher: "ExitPlanMode",
-          hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}`, timeout: 120 }]
-        },
-        {
-          // Observe-only: lets the session report waiting_for_input the moment
-          // the planning questionnaire renders. The helper fails open for this
-          // tool, so the questionnaire is never blocked by Conveyor.
-          matcher: "AskUserQuestion",
-          hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}`, timeout: 30 }]
-        },
-        {
-          // Plan-permission spawns prompt for MCP tools even when they're in
-          // permissions.allow — the CLI can't classify them as read-only. A
-          // hook allow bypasses the permission engine in every mode. Loose by
-          // design: the pod is the sandbox, and planning agents must call
-          // update_task etc. The helper answers locally (no socket).
-          matcher: "mcp__.*",
-          hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}`, timeout: 30 }]
-        }
-      ],
-      PostToolUse: [
-        {
-          matcher: "*",
-          hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}` }]
-        }
-      ]
-    }
-  };
-  await writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf8");
-  return { settingsPath, helperPath };
-}
-
-// src/runner/plan-sync.ts
-var PlanSync = class {
-  planFileSnapshot = /* @__PURE__ */ new Map();
-  lockedPlanFile = null;
-  workspaceDir;
-  connection;
-  constructor(workspaceDir, connection) {
-    this.workspaceDir = workspaceDir;
-    this.connection = connection;
-  }
-  updateWorkspaceDir(workspaceDir) {
-    this.workspaceDir = workspaceDir;
-  }
-  getPlanDirs() {
-    return [join2(this.workspaceDir, ".claude", "plans"), configHomePlansDir()];
-  }
-  snapshotPlanFiles() {
-    this.planFileSnapshot.clear();
-    this.lockedPlanFile = null;
-    for (const plansDir of this.getPlanDirs()) {
-      try {
-        for (const file of readdirSync(plansDir).filter((f) => f.endsWith(".md"))) {
-          try {
-            const fullPath = join2(plansDir, file);
-            const stat6 = statSync(fullPath);
-            this.planFileSnapshot.set(fullPath, stat6.mtimeMs);
-          } catch {
-            continue;
-          }
-        }
-      } catch {
-      }
-    }
+async function flushAllPendingWork(cwd, opts) {
+  try {
+    const primary = await flushPendingChanges(cwd, opts);
+    await refreshRemoteToken(cwd, opts?.refreshToken);
+    const currentBranch = await getCurrentBranch(cwd);
+    const worktreesSnapshotted = await snapshotOtherWorktrees(cwd, opts?.wipMessage);
+    const branchesBackedUp = await backupOtherBranches(cwd, currentBranch);
+    return {
+      hadWork: primary.hadWork || worktreesSnapshotted > 0 || branchesBackedUp > 0,
+      branchesBackedUp,
+      worktreesSnapshotted
+    };
+  } catch {
+    return { hadWork: false, branchesBackedUp: 0, worktreesSnapshotted: 0 };
   }
-  findNewestPlanFile() {
-    let newest = null;
-    for (const plansDir of this.getPlanDirs()) {
-      let files;
-      try {
-        files = readdirSync(plansDir).filter((f) => f.endsWith(".md"));
-      } catch {
-        continue;
-      }
-      for (const file of files) {
-        const fullPath = join2(plansDir, file);
-        try {
-          const stat6 = statSync(fullPath);
-          const prevMtime = this.planFileSnapshot.get(fullPath);
-          const isNew = prevMtime === void 0 || stat6.mtimeMs > prevMtime;
-          if (isNew && (!newest || stat6.mtimeMs > newest.mtime)) {
-            newest = { path: fullPath, mtime: stat6.mtimeMs };
-          }
-        } catch {
-          continue;
-        }
+}
+async function snapshotOtherWorktrees(cwd, wipMessage) {
+  let count = 0;
+  for (const wt of await listWorktrees(cwd)) {
+    if (samePath(wt.path, cwd) || !wt.branch) continue;
+    try {
+      if (!await hasUncommittedChanges(wt.path)) continue;
+      const sha = await createWipSnapshot(wt.path, wipMessage ?? "WIP: conveyor-agent snapshot");
+      if (sha && await tryPushRefspec(wt.path, `${sha}:refs/heads/${wipRefForBranch(wt.branch)}`, true)) {
+        wipRefPushed.add(wt.path);
+        count++;
       }
+    } catch {
     }
-    return newest;
   }
-  async syncPlanFile() {
-    const isInitialDetection = this.lockedPlanFile === null;
-    const target = this.lockedPlanFile ?? this.findNewestPlanFile()?.path ?? null;
-    if (!target) return;
-    if (isInitialDetection) {
-      this.lockedPlanFile = target;
-    }
-    const fileName = target.split("/").pop() ?? "plan";
-    let content;
+  return count;
+}
+async function backupOtherBranches(cwd, currentBranch) {
+  let count = 0;
+  for (const branch of await listLocalBranches(cwd)) {
+    if (branch === currentBranch || branch.startsWith("conveyor-wip/")) continue;
     try {
-      content = readFileSync(target, "utf-8").trim();
-    } catch (err) {
-      const reason = err instanceof Error ? err.message : String(err);
-      this.connection.postChatMessage(
-        `Plan sync warning: could not read local plan file (${fileName}): ${reason}. The task plan was not updated.`
-      );
-      return;
-    }
-    if (!content) return;
-    const result = await this.connection.updateTaskFields({ plan: content });
-    if (!result.ok) {
-      this.connection.postChatMessage(
-        `Plan sync failed: the local plan file (${fileName}) was not persisted to the task (${result.error ?? "unknown error"}). Retry update_task_plan or re-run ExitPlanMode.`
-      );
-      return;
+      if (await branchUnpushedCount(cwd, branch) === 0) continue;
+      if (await tryPushRefspec(
+        cwd,
+        `refs/heads/${branch}:refs/heads/${branchBackupRef(branch)}`,
+        true
+      )) {
+        count++;
+      }
+    } catch {
     }
-    const verb = isInitialDetection ? "Detected local plan file" : "Synced local plan file";
-    const suffix = isInitialDetection ? " and synced it to the task plan." : " to the task plan.";
-    this.connection.postChatMessage(`${verb} (${fileName})${suffix}`);
   }
-};
+  return count;
+}
 
 // src/setup/git-ready.ts
 import { access, stat } from "fs/promises";
@@ -1814,69 +1561,6 @@ async function pollForMarkers(markerPath, failedPath, timeoutMs, pollMs, onLog)
 // src/runner/work-preservation/index.ts
 import { rm as rm3 } from "fs/promises";
 
-// src/runner/work-preservation/pg-dump.ts
-import { execSync as execSync2 } from "child_process";
-import { randomUUID } from "crypto";
-import { tmpdir } from "os";
-import path from "path";
-var PG_DUMP_FILENAME = ".conveyor-pgdump.sql";
-function connectionDefaults(opts) {
-  return {
-    host: opts.host ?? "localhost",
-    port: opts.port ?? 5432,
-    db: opts.db ?? "conveyor"
-  };
-}
-function buildPgDumpCommand(opts) {
-  const { host, port, db } = connectionDefaults(opts);
-  return `pg_dump -h ${host} -p ${port} -U postgres ${db} -f ${JSON.stringify(
-    opts.outputPath
-  )} --no-owner --no-privileges`;
-}
-function buildPsqlRestoreCommand(opts) {
-  const { host, port, db } = connectionDefaults(opts);
-  return `psql -h ${host} -p ${port} -U postgres -d ${db} -f ${JSON.stringify(opts.dumpPath)}`;
-}
-function hasPostgresDep() {
-  return (process.env.CONVEYOR_DEPS ?? "").split(",").map((dep) => dep.trim()).includes("postgresql");
-}
-function execErrorDetail(err) {
-  const withStreams = err;
-  const stderr = withStreams.stderr instanceof Buffer ? withStreams.stderr.toString("utf8").trim() : typeof withStreams.stderr === "string" ? withStreams.stderr.trim() : "";
-  const message = withStreams.message ?? String(err);
-  return stderr ? `${message} \u2014 stderr: ${stderr}` : message;
-}
-function dumpPostgresIfPresent(exec2 = execSync2) {
-  if (!hasPostgresDep()) return Promise.resolve({ dumped: false });
-  const outputPath = path.join(tmpdir(), `conveyor-pgdump-${randomUUID()}.sql`);
-  try {
-    exec2(buildPgDumpCommand({ outputPath }), {
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 6e4
-    });
-    return Promise.resolve({ dumped: true, path: outputPath });
-  } catch (err) {
-    process.stderr.write(`[conveyor-agent] pg_dump failed: ${execErrorDetail(err)}
-`);
-    return Promise.resolve({ dumped: false });
-  }
-}
-function applyPgDumpIfConfigured(dumpPath, exec2 = execSync2) {
-  if (!hasPostgresDep()) return false;
-  try {
-    exec2(buildPsqlRestoreCommand({ dumpPath }), {
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: 12e4
-    });
-    process.stderr.write("[conveyor-agent] Restored postgres state from snapshot pg dump\n");
-    return true;
-  } catch (err) {
-    process.stderr.write(`[conveyor-agent] psql dump restore failed: ${execErrorDetail(err)}
-`);
-    return false;
-  }
-}
-
 // src/runner/work-preservation/restore-precedence.ts
 function selectRestoreSource(probe) {
   if (probe.gcsAvailable) return "gcs";
@@ -1885,25 +1569,27 @@ function selectRestoreSource(probe) {
 }
 
 // src/runner/work-preservation/snapshot-tar.ts
-import { execSync as execSync3 } from "child_process";
-import { createReadStream, createWriteStream, mkdtempSync } from "fs";
-import { copyFile, mkdtemp, rm, stat as stat2, writeFile as writeFile2 } from "fs/promises";
-import { tmpdir as tmpdir2 } from "os";
-import path2 from "path";
+import { execFile as execFile2 } from "child_process";
+import { createReadStream, createWriteStream } from "fs";
+import { mkdtemp, rm, stat as stat2, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
 import { pipeline } from "stream/promises";
+import { promisify as promisify2 } from "util";
 import { createGzip } from "zlib";
 import * as tar from "tar";
 
 // src/runner/work-preservation/snapshot-artifact.ts
-function planSnapshotFiles(git) {
-  const include = git.trackedAndUntracked();
+function planSnapshotFiles(git2) {
+  const include = git2.trackedAndUntracked();
   const includeSet = new Set(include);
-  const deletions = [...new Set(git.deletedSinceHead())].filter((path4) => !includeSet.has(path4));
+  const deletions = [...new Set(git2.deletedSinceHead())].filter((path4) => !includeSet.has(path4));
   return { include, deletions };
 }
 
 // src/runner/work-preservation/snapshot-tar.ts
 var SNAPSHOT_MANIFEST_NAME = ".conveyor-snapshot-manifest.json";
+var LEGACY_PG_DUMP_FILENAME = ".conveyor-pgdump.sql";
 var STATUS_MAX_BUFFER = 64 * 1024 * 1024;
 function parseStatusPorcelainZ(raw) {
   const includes = [];
@@ -1926,60 +1612,55 @@ function parseStatusPorcelainZ(raw) {
   }
   return { includes, deletions };
 }
-function realGitSurface(cwd) {
-  let cached = null;
-  const load = () => {
-    if (!cached) {
-      const out = execSync3("git status --porcelain=v1 -z -uall", {
-        cwd,
-        stdio: ["ignore", "pipe", "ignore"],
-        maxBuffer: STATUS_MAX_BUFFER
-      }).toString("utf8");
-      cached = parseStatusPorcelainZ(out);
-    }
-    return cached;
-  };
+var execFileAsync2 = promisify2(execFile2);
+var GIT_TIMEOUT_MS2 = 12e4;
+async function realGitSurface(cwd) {
+  const { stdout } = await execFileAsync2("git", ["status", "--porcelain=v1", "-z", "-uall"], {
+    cwd,
+    timeout: GIT_TIMEOUT_MS2,
+    maxBuffer: STATUS_MAX_BUFFER
+  });
+  const cached = parseStatusPorcelainZ(stdout.toString());
   return {
-    trackedAndUntracked: () => load().includes,
-    deletedSinceHead: () => load().deletions
+    trackedAndUntracked: () => cached.includes,
+    deletedSinceHead: () => cached.deletions
   };
 }
-function gitHead(cwd) {
+async function gitHead(cwd) {
   try {
-    return execSync3("git rev-parse HEAD", { cwd, stdio: ["ignore", "pipe", "ignore"] }).toString().trim() || null;
+    const { stdout } = await execFileAsync2("git", ["rev-parse", "HEAD"], {
+      cwd,
+      timeout: GIT_TIMEOUT_MS2
+    });
+    return stdout.toString().trim() || null;
   } catch {
     return null;
   }
 }
-async function buildSnapshotTar(cwd, opts) {
-  const staging = await mkdtemp(path2.join(tmpdir2(), "conveyor-snapshot-"));
+async function buildSnapshotTar(cwd) {
+  const staging = await mkdtemp(path.join(tmpdir(), "conveyor-snapshot-"));
   const cleanup = async () => {
     await rm(staging, { recursive: true, force: true }).catch(() => {
     });
   };
   try {
-    const plan = planSnapshotFiles(realGitSurface(cwd));
-    const head = gitHead(cwd);
+    const plan = planSnapshotFiles(await realGitSurface(cwd));
+    const head = await gitHead(cwd);
     if (!head) throw new Error("cannot snapshot a repo without a resolvable HEAD");
     const capturedAt = Date.now();
     const manifest = {
       head,
       deletions: plan.deletions,
-      capturedAt,
-      pgDump: Boolean(opts?.pgDumpPath)
+      capturedAt
     };
-    await writeFile2(path2.join(staging, SNAPSHOT_MANIFEST_NAME), JSON.stringify(manifest), "utf8");
+    await writeFile(path.join(staging, SNAPSHOT_MANIFEST_NAME), JSON.stringify(manifest), "utf8");
     const stagedEntries = [SNAPSHOT_MANIFEST_NAME];
-    if (opts?.pgDumpPath) {
-      await copyFile(opts.pgDumpPath, path2.join(staging, PG_DUMP_FILENAME));
-      stagedEntries.push(PG_DUMP_FILENAME);
-    }
-    const rawTarPath = path2.join(staging, "snapshot.tar");
+    const rawTarPath = path.join(staging, "snapshot.tar");
     await tar.create({ cwd: staging, file: rawTarPath, portable: true }, stagedEntries);
     if (plan.include.length > 0) {
       await tar.replace({ file: rawTarPath, cwd, portable: true }, plan.include);
     }
-    const tarPath = path2.join(staging, "snapshot.tar.gz");
+    const tarPath = path.join(staging, "snapshot.tar.gz");
     await pipeline(createReadStream(rawTarPath), createGzip(), createWriteStream(tarPath));
     await rm(rawTarPath, { force: true });
     const { size } = await stat2(tarPath);
@@ -1997,20 +1678,13 @@ async function buildSnapshotTar(cwd, opts) {
   }
 }
 function isWithinWorkspace(cwd, rel) {
-  if (!rel || path2.isAbsolute(rel)) return false;
-  const root = path2.resolve(cwd);
-  const abs = path2.resolve(root, rel);
-  return abs !== root && abs.startsWith(root + path2.sep);
+  if (!rel || path.isAbsolute(rel)) return false;
+  const root = path.resolve(cwd);
+  const abs = path.resolve(root, rel);
+  return abs !== root && abs.startsWith(root + path.sep);
 }
 async function readSnapshotArchive(tarPath) {
   let manifestRaw = null;
-  let pgDumpDir = null;
-  let pgDumpPath;
-  let pgDumpWritten = Promise.resolve();
-  const cleanup = async () => {
-    if (pgDumpDir) await rm(pgDumpDir, { recursive: true, force: true }).catch(() => {
-    });
-  };
   try {
     await tar.list({
       file: tarPath,
@@ -2021,86 +1695,59 @@ async function readSnapshotArchive(tarPath) {
           entry.on("end", () => {
             manifestRaw = Buffer.concat(chunks);
           });
-        } else if (entry.path === PG_DUMP_FILENAME) {
-          pgDumpDir = mkdtempSync(path2.join(tmpdir2(), "conveyor-pgdump-restore-"));
-          pgDumpPath = path2.join(pgDumpDir, "dump.sql");
-          const dest = createWriteStream(pgDumpPath);
-          pgDumpWritten = new Promise((resolve, reject) => {
-            dest.on("finish", () => resolve());
-            dest.on("error", reject);
-          });
-          entry.pipe(dest);
         }
       }
     });
-    await pgDumpWritten;
   } catch {
-    await cleanup();
-    return null;
-  }
-  if (!manifestRaw) {
-    await cleanup();
     return null;
   }
+  if (!manifestRaw) return null;
   try {
     const parsed = JSON.parse(manifestRaw.toString("utf8"));
-    if (typeof parsed.head !== "string" || !parsed.head) {
-      await cleanup();
-      return null;
-    }
+    if (typeof parsed.head !== "string" || !parsed.head) return null;
     return {
-      manifest: {
-        head: parsed.head,
-        deletions: Array.isArray(parsed.deletions) ? parsed.deletions : [],
-        capturedAt: typeof parsed.capturedAt === "number" ? parsed.capturedAt : 0,
-        pgDump: parsed.pgDump === true
-      },
-      ...pgDumpPath ? { pgDumpPath } : {},
-      cleanup
+      head: parsed.head,
+      deletions: Array.isArray(parsed.deletions) ? parsed.deletions : [],
+      capturedAt: typeof parsed.capturedAt === "number" ? parsed.capturedAt : 0
     };
   } catch {
-    await cleanup();
     return null;
   }
 }
-async function extractSnapshotTar(cwd, tarPath, opts) {
-  const read = await readSnapshotArchive(tarPath);
-  if (!read) return { status: "invalid" };
-  try {
-    const { manifest, pgDumpPath } = read;
-    const currentHead = gitHead(cwd);
-    if (manifest.head !== currentHead) {
-      return { status: "stale-head", snapshotHead: manifest.head, currentHead };
-    }
-    let filesExtracted = 0;
-    await tar.extract({
-      file: tarPath,
-      cwd,
-      filter: (entryPath) => {
-        if (entryPath === SNAPSHOT_MANIFEST_NAME || entryPath === PG_DUMP_FILENAME) return false;
-        filesExtracted++;
-        return true;
+async function extractSnapshotTar(cwd, tarPath) {
+  const manifest = await readSnapshotArchive(tarPath);
+  if (!manifest) return { status: "invalid" };
+  const currentHead = await gitHead(cwd);
+  if (manifest.head !== currentHead) {
+    return { status: "stale-head", snapshotHead: manifest.head, currentHead };
+  }
+  let filesExtracted = 0;
+  await tar.extract({
+    file: tarPath,
+    cwd,
+    filter: (entryPath) => {
+      if (entryPath === SNAPSHOT_MANIFEST_NAME || entryPath === LEGACY_PG_DUMP_FILENAME) {
+        return false;
       }
-    });
-    let deletionsApplied = 0;
-    for (const rel of manifest.deletions) {
-      if (typeof rel !== "string" || !isWithinWorkspace(cwd, rel)) continue;
-      await rm(path2.resolve(cwd, rel), { recursive: true, force: true });
-      deletionsApplied++;
-    }
-    const pgDumpApplied = manifest.pgDump && pgDumpPath ? applyPgDumpIfConfigured(pgDumpPath, opts?.pgExec) : false;
-    return { status: "extracted", filesExtracted, deletionsApplied, pgDumpApplied };
-  } finally {
-    await read.cleanup();
+      filesExtracted++;
+      return true;
+    }
+  });
+  let deletionsApplied = 0;
+  for (const rel of manifest.deletions) {
+    if (typeof rel !== "string" || !isWithinWorkspace(cwd, rel)) continue;
+    await rm(path.resolve(cwd, rel), { recursive: true, force: true });
+    deletionsApplied++;
   }
+  return { status: "extracted", filesExtracted, deletionsApplied };
 }
 
 // src/runner/work-preservation/snapshot-transfer.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID } from "crypto";
 import { createReadStream as createReadStream2, createWriteStream as createWriteStream2 } from "fs";
 import { rm as rm2 } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import path3 from "path";
+import { tmpdir as tmpdir2 } from "os";
+import path2 from "path";
 import { Readable } from "stream";
 import { pipeline as pipeline2 } from "stream/promises";
 var SNAPSHOT_HTTP_TIMEOUT_MS = 6e4;
@@ -2125,7 +1772,7 @@ async function putSnapshotToGcs(url, tarResult) {
   }
 }
 async function downloadSnapshotToTemp(url) {
-  const tmpTar = path3.join(tmpdir3(), `conveyor-snapshot-restore-${randomUUID2()}.tar.gz`);
+  const tmpTar = path2.join(tmpdir2(), `conveyor-snapshot-restore-${randomUUID()}.tar.gz`);
   try {
     const res = await fetch(url, {
       method: "GET",
@@ -2152,13 +1799,12 @@ var EMPTY_GCS_RESULT = {
   uploaded: false,
   fileCount: 0,
   deletionCount: 0,
-  sizeBytes: 0,
-  pgDumped: false
+  sizeBytes: 0
 };
 async function doUploadSnapshotToGcs(cwd, uploadUrl, opts) {
   let tarResult;
   try {
-    tarResult = await buildSnapshotTar(cwd, { pgDumpPath: opts?.pgDumpPath });
+    tarResult = await buildSnapshotTar(cwd);
   } catch {
     return EMPTY_GCS_RESULT;
   }
@@ -2168,8 +1814,7 @@ async function doUploadSnapshotToGcs(cwd, uploadUrl, opts) {
       uploaded,
       fileCount: tarResult.fileCount,
       deletionCount: tarResult.deletionCount,
-      sizeBytes: tarResult.sizeBytes,
-      pgDumped: Boolean(opts?.pgDumpPath)
+      sizeBytes: tarResult.sizeBytes
     };
   } finally {
     await tarResult.cleanup();
@@ -2191,7 +1836,6 @@ async function uploadSnapshotToGcs(cwd, uploadUrl, opts) {
 }
 async function captureSnapshot(ctx) {
   const gcs = await uploadSnapshotToGcs(ctx.cwd, ctx.snapshotUploadUrl, {
-    pgDumpPath: ctx.pgDumpPath,
     forceUpload: ctx.forceUpload
   });
   const wipResult = await flushPendingChanges(ctx.cwd, {
@@ -2203,8 +1847,7 @@ async function captureSnapshot(ctx) {
     deletionCount: gcs.deletionCount,
     sizeBytes: gcs.sizeBytes,
     gcsUploaded: gcs.uploaded,
-    wipPushed: wipResult.committed || wipResult.pushed,
-    pgDumped: gcs.pgDumped
+    wipPushed: wipResult.committed || wipResult.pushed
   };
 }
 function startPeriodic(intervalMs, ctx) {
@@ -2229,21 +1872,13 @@ async function finalizeForSleep(ctx) {
   stop();
   if (inFlightCapture) await inFlightCapture.catch(() => {
   });
-  const dump = await dumpPostgresIfPresent();
-  try {
-    const artifact = await captureSnapshot({
-      ...ctx,
-      pgDumpPath: dump.path,
-      wipMessage: ctx.wipMessage ?? "WIP: WorkPreservation sleep finalize snapshot",
-      // Always stamp snapshotAt on sleep — even an empty workspace must confirm
-      // the finalize so teardown doesn't wait out the reconciler's cap.
-      forceUpload: true
-    });
-    return { ...artifact, pgDumped: dump.dumped };
-  } finally {
-    if (dump.path) await rm3(dump.path, { force: true }).catch(() => {
-    });
-  }
+  return captureSnapshot({
+    ...ctx,
+    wipMessage: ctx.wipMessage ?? "WIP: WorkPreservation sleep finalize snapshot",
+    // Always stamp snapshotAt on sleep — even an empty workspace must confirm
+    // the finalize so teardown doesn't wait out the reconciler's cap.
+    forceUpload: true
+  });
 }
 async function restoreOnBoot(bundle, cwd) {
   let gcsAvailable = false;
@@ -2265,7 +1900,7 @@ async function restoreOnBoot(bundle, cwd) {
       }
     }
   }
-  const wipRestoreResult = gcsAvailable ? "none" : restoreWipSnapshot(cwd, bundle.gitPlan.branch);
+  const wipRestoreResult = gcsAvailable ? "none" : await restoreWipSnapshot(cwd, bundle.gitPlan.branch);
   const source = selectRestoreSource({ gcsAvailable, wipRestoreResult });
   return source === "gcs" ? { source, fileCount: gcsFileCount } : { source };
 }
@@ -2282,7 +1917,9 @@ var AgentHeartbeatSchema = z.object({
   sessionId: z.string().optional(),
   timestamp: z.string(),
   status: z.enum(["active", "idle", "building"]),
-  currentAction: z.string().optional()
+  currentAction: z.string().optional(),
+  /** Sender-observed main event-loop lag (ms) — see AgentHeartbeat.loopLagMs. */
+  loopLagMs: z.number().nonnegative().optional()
 });
 var CreatePRInputSchema = z.object({
   title: z.string().min(1),
@@ -2564,6 +2201,10 @@ var ListActivePtySessionsRequestSchema = z.object({
 var SendSoftStopRequestSchema = z.object({
   taskId: z.string()
 });
+var StopTaskSessionRequestSchema = z.object({
+  taskId: z.string(),
+  sessionId: z.string()
+});
 var FlushTaskQueueRequestSchema = z.object({
   taskId: z.string(),
   softStop: z.boolean().optional()
@@ -2612,6 +2253,11 @@ var EmitAgentEventRequestSchema = z.object({
 var RefreshGithubTokenRequestSchema = z.object({
   sessionId: z.string()
 });
+var ReportReviewSpawnFailureRequestSchema = z.object({
+  sessionId: z.string(),
+  reviewSessionId: z.string(),
+  error: z.string().max(2e3).optional()
+});
 var RefreshGithubTokenResponseSchema = z.object({
   token: z.string()
 });
@@ -2638,6 +2284,29 @@ var PtyResizeRequestSchema = z.object({
 var PtyAttachRequestSchema = z.object({
   sessionId: z.string()
 });
+var PtyChatEventPayloadSchema = z.discriminatedUnion("kind", [
+  z.object({
+    kind: z.literal("init"),
+    model: z.string().max(200),
+    claudeSessionId: z.string().max(100).optional()
+  }),
+  z.object({ kind: z.literal("user_text"), text: z.string().max(16384) }),
+  z.object({ kind: z.literal("assistant_text"), text: z.string().max(16384) }),
+  z.object({
+    kind: z.literal("tool_use"),
+    name: z.string().max(200),
+    // Compact preview: JSON.stringify(input) truncated agent-side.
+    input: z.string().max(2e3)
+  }),
+  z.object({ kind: z.literal("turn_end") })
+]);
+var PtyChatEventRequestSchema = z.object({
+  sessionId: z.string(),
+  event: PtyChatEventPayloadSchema
+});
+var PtyChatAttachRequestSchema = z.object({
+  sessionId: z.string()
+});
 var CreatePRResponseSchema = z.object({
   prNumber: z.number().int().positive(),
   prUrl: z.string().url()
@@ -2778,6 +2447,13 @@ var ListMyLiveSessionsRequestSchema = z2.object({
 var StartAdhocSessionRequestSchema = z2.object({
   projectId: z2.string(),
   label: z2.string().max(200).optional(),
+  /**
+   * Session role. Constrained: other task-less modes fall through to the pm
+   * runner in the pod entrypoint, and "review" would crash without a task.
+   */
+  mode: z2.enum(["adhoc", "pm"]).optional(),
+  /** Base branch to check out (defaults to the project's dev branch). */
+  branch: z2.string().max(300).optional(),
   requestingUserId: z2.string().optional()
 });
 var StopAdhocSessionRequestSchema = z2.object({
@@ -3302,8 +2978,8 @@ var ClaudeCodeHarness = class {
 
 // src/harness/pty/session.ts
 import { mkdtemp as mkdtemp2, mkdir as mkdir2, rm as rm4 } from "fs/promises";
-import { tmpdir as tmpdir4 } from "os";
-import { join as join4, dirname } from "path";
+import { tmpdir as tmpdir3 } from "os";
+import { join as join3, dirname } from "path";
 
 // src/harness/pty/event-queue.ts
 var AsyncEventQueue = class {
@@ -3584,12 +3260,14 @@ function mapTranscriptRecord(raw) {
 // src/harness/pty/jsonl-tailer.ts
 var POLL_INTERVAL_MS = 25;
 var JsonlTailer = class {
-  constructor(path4, onEvent) {
+  constructor(path4, onEvent, onRawRecord) {
     this.path = path4;
     this.onEvent = onEvent;
+    this.onRawRecord = onRawRecord;
   }
   path;
   onEvent;
+  onRawRecord;
   offset = 0;
   buffer = "";
   timer = null;
@@ -3661,11 +3339,109 @@ var JsonlTailer = class {
     } catch {
       return;
     }
+    this.onRawRecord?.(parsed);
     const event = mapTranscriptRecord(parsed);
     if (event) this.onEvent(event);
   }
 };
 
+// src/harness/pty/chat-record-mapper.ts
+var TEXT_MAX = 16e3;
+var TOOL_INPUT_MAX = 1900;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isUnknownArray2(value) {
+  return Array.isArray(value);
+}
+function stringField2(record, ...keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string") return value;
+  }
+  return void 0;
+}
+function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+function isCommandWrapperText(text) {
+  const trimmed = text.trimStart();
+  return trimmed.startsWith("<command-name>") || trimmed.startsWith("<local-command-");
+}
+function mapSystem2(record) {
+  if (record.subtype === "init") {
+    const event = {
+      kind: "init",
+      model: stringField2(record, "model") ?? ""
+    };
+    const sessionId = stringField2(record, "session_id", "sessionId");
+    if (sessionId !== void 0) event.claudeSessionId = sessionId;
+    return [event];
+  }
+  if (record.subtype === "turn_duration") return [{ kind: "turn_end" }];
+  return [];
+}
+function mapAssistant2(record) {
+  const message = record.message;
+  if (!isRecord2(message)) return [];
+  const content = isUnknownArray2(message.content) ? message.content : [];
+  const events = [];
+  for (const raw of content) {
+    if (!isRecord2(raw)) continue;
+    if (raw.type === "text") {
+      const text = stringField2(raw, "text");
+      if (text && text.length > 0) {
+        events.push({ kind: "assistant_text", text: truncate(text, TEXT_MAX) });
+      }
+    } else if (raw.type === "tool_use") {
+      const name = stringField2(raw, "name");
+      if (name) {
+        const input = "input" in raw ? raw.input : void 0;
+        events.push({
+          kind: "tool_use",
+          name: truncate(name, 200),
+          input: JSON.stringify(input ?? {}).slice(0, TOOL_INPUT_MAX)
+        });
+      }
+    }
+  }
+  return events;
+}
+function mapUser(record) {
+  const message = record.message;
+  if (!isRecord2(message)) return [];
+  const content = message.content;
+  let text;
+  if (typeof content === "string") {
+    text = content;
+  } else if (isUnknownArray2(content)) {
+    const hasToolResult = content.some((b) => isRecord2(b) && b.type === "tool_result");
+    if (hasToolResult) return [];
+    text = content.filter((b) => isRecord2(b) && b.type === "text").map((b) => typeof b.text === "string" ? b.text : "").filter((t) => t.length > 0).join("\n");
+  } else {
+    return [];
+  }
+  const trimmed = text.trim();
+  if (trimmed.length === 0 || isCommandWrapperText(trimmed)) return [];
+  return [{ kind: "user_text", text: truncate(trimmed, TEXT_MAX) }];
+}
+function mapChatRecords(raw) {
+  if (!isRecord2(raw)) return [];
+  if (raw.isSidechain === true || raw.isMeta === true) return [];
+  switch (raw.type) {
+    case "system":
+      return mapSystem2(raw);
+    case "assistant":
+      return mapAssistant2(raw);
+    case "user":
+      return mapUser(raw);
+    case "result":
+      return [{ kind: "turn_end" }];
+    default:
+      return [];
+  }
+}
+
 // src/harness/pty/spawn-args.ts
 function resolveClaudeBinary() {
   return process.env.CONVEYOR_CLAUDE_BIN ?? "claude";
@@ -3714,26 +3490,268 @@ function cleanTerminalOutput(raw, maxChars = 1200) {
     else if (code < 32 || code === 127) continue;
     else out += ch;
   }
-  const lines = out.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim().length > 0);
-  const text = lines.join("\n").trim();
-  return text.length > maxChars ? `\u2026${text.slice(-maxChars)}` : text;
-}
-function isMissingBinaryFailure(tail) {
-  return /execvp\(\d+\) failed|no such file or directory|command not found/i.test(tail);
+  const lines = out.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim().length > 0);
+  const text = lines.join("\n").trim();
+  return text.length > maxChars ? `\u2026${text.slice(-maxChars)}` : text;
+}
+function isMissingBinaryFailure(tail) {
+  return /execvp\(\d+\) failed|no such file or directory|command not found/i.test(tail);
+}
+function buildExitErrors(exitCode, rawOutput, binary) {
+  const errors = [`claude exited (code ${exitCode}) without a result`];
+  const tail = cleanTerminalOutput(rawOutput);
+  if (isMissingBinaryFailure(tail)) {
+    errors.push(
+      `The \`${binary}\` CLI could not be started \u2014 it is not installed or not on PATH. Install the Claude Code CLI in this environment (npm i -g @anthropic-ai/claude-code) or set CONVEYOR_CLAUDE_BIN to its absolute path.`
+    );
+  }
+  if (tail) {
+    errors.push(`Last terminal output before exit:
+${tail}`);
+  }
+  return errors;
+}
+
+// src/harness/pty/settings.ts
+import { mkdir, writeFile as writeFile2, chmod } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+function claudeConfigHome() {
+  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+}
+function projectSlug(cwd) {
+  return cwd.replace(/\//g, "-");
+}
+function sessionTranscriptPath(cwd, sessionId) {
+  return join(claudeConfigHome(), "projects", projectSlug(cwd), `${sessionId}.jsonl`);
+}
+var ALLOW_RULES = [
+  "Bash",
+  "BashOutput",
+  "Edit",
+  "Write",
+  "Read",
+  "Glob",
+  "Grep",
+  "WebFetch",
+  "WebSearch",
+  "NotebookEdit",
+  "Task",
+  "TodoWrite",
+  "ToolSearch",
+  "KillShell",
+  "SlashCommand",
+  "Skill",
+  "mcp__conveyor__*"
+];
+var HOOK_HELPER_SOURCE = `"use strict";
+const net = require("node:net");
+const crypto = require("node:crypto");
+
+const PRE_TOOL_USE_TIMEOUT_MS = 110000;
+const ASK_USER_QUESTION_TIMEOUT_MS = 5000;
+
+let raw = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  raw += chunk;
+});
+process.stdin.on("end", () => {
+  let payload = {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object") payload = parsed;
+  } catch {
+    payload = {};
+  }
+  if (payload.hook_event_name === "PreToolUse") {
+    preToolUse(payload);
+  } else {
+    relayProgress(typeof payload.tool_name === "string" ? payload.tool_name : "");
+  }
+});
+
+function relayProgress(toolName) {
+  const socketPath = process.env.CONVEYOR_HOOK_SOCKET;
+  let done = false;
+  const finish = () => {
+    if (done) return;
+    done = true;
+    process.stdout.write(JSON.stringify({ continue: true }));
+    process.exit(0);
+  };
+  const fallback = setTimeout(finish, 250);
+  if (!socketPath) {
+    clearTimeout(fallback);
+    finish();
+    return;
+  }
+  const client = net.connect(socketPath, () => {
+    // PostToolUse does not supply tool duration, so elapsed_time_seconds is
+    // omitted rather than reported as a misleading 0 (the field is optional).
+    const line = JSON.stringify({ tool_name: toolName }) + "\\n";
+    client.write(line, () => {
+      client.end();
+    });
+  });
+  client.on("close", () => {
+    clearTimeout(fallback);
+    finish();
+  });
+  client.on("error", () => {
+    clearTimeout(fallback);
+    finish();
+  });
 }
-function buildExitErrors(exitCode, rawOutput, binary) {
-  const errors = [`claude exited (code ${exitCode}) without a result`];
-  const tail = cleanTerminalOutput(rawOutput);
-  if (isMissingBinaryFailure(tail)) {
-    errors.push(
-      `The \`${binary}\` CLI could not be started \u2014 it is not installed or not on PATH. Install the Claude Code CLI in this environment (npm i -g @anthropic-ai/claude-code) or set CONVEYOR_CLAUDE_BIN to its absolute path.`
+
+function preToolUse(payload) {
+  const socketPath = process.env.CONVEYOR_HOOK_SOCKET;
+  let done = false;
+  const respond = (decision, reason) => {
+    if (done) return;
+    done = true;
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: decision,
+          ...(reason ? { permissionDecisionReason: reason } : {}),
+        },
+      }),
     );
+    process.exit(0);
+  };
+  // MCP tools are auto-allowed locally \u2014 no socket round trip, no fail-mode.
+  // Plan mode prompts for them despite permissions.allow (the CLI can't
+  // classify MCP tools as read-only), and the pod is the sandbox.
+  if (typeof payload.tool_name === "string" && payload.tool_name.startsWith("mcp__")) {
+    respond("allow");
+    return;
   }
-  if (tail) {
-    errors.push(`Last terminal output before exit:
-${tail}`);
+  // AskUserQuestion is observe-only (status reporting) \u2014 fail OPEN so a
+  // missing/slow socket never denies the questionnaire. Everything else
+  // (ExitPlanMode) is a Conveyor gate \u2014 fail CLOSED.
+  const failOpen = payload.tool_name === "AskUserQuestion";
+  const respondUnavailable = () =>
+    failOpen
+      ? respond("allow")
+      : respond(
+          "deny",
+          "Conveyor validation is unavailable right now. Wait a moment and call the tool again.",
+        );
+  if (!socketPath) {
+    respondUnavailable();
+    return;
   }
-  return errors;
+  const id = crypto.randomBytes(8).toString("hex");
+  const timer = setTimeout(
+    respondUnavailable,
+    failOpen ? ASK_USER_QUESTION_TIMEOUT_MS : PRE_TOOL_USE_TIMEOUT_MS,
+  );
+  const client = net.connect(socketPath, () => {
+    client.write(
+      JSON.stringify({
+        kind: "pre_tool_use",
+        id,
+        tool_name: typeof payload.tool_name === "string" ? payload.tool_name : "",
+        tool_input:
+          payload.tool_input && typeof payload.tool_input === "object" ? payload.tool_input : {},
+      }) + "\\n",
+    );
+  });
+  let buffer = "";
+  client.on("data", (chunk) => {
+    buffer += chunk.toString("utf8");
+    let index = buffer.indexOf("\\n");
+    while (index >= 0) {
+      const line = buffer.slice(0, index);
+      buffer = buffer.slice(index + 1);
+      try {
+        const verdict = JSON.parse(line);
+        if (verdict && verdict.id === id) {
+          clearTimeout(timer);
+          client.end();
+          respond(verdict.decision === "allow" ? "allow" : "deny", verdict.reason);
+          return;
+        }
+      } catch {
+        /* keep scanning */
+      }
+      index = buffer.indexOf("\\n");
+    }
+  });
+  client.on("error", () => {
+    clearTimeout(timer);
+    respondUnavailable();
+  });
+  client.on("close", () => {
+    clearTimeout(timer);
+    respondUnavailable();
+  });
+}
+`;
+async function writeHookSettings(dir) {
+  const helperPath = join(dir, "hook-helper.cjs");
+  const settingsPath = join(dir, "settings.json");
+  await mkdir(dir, { recursive: true });
+  await writeFile2(helperPath, HOOK_HELPER_SOURCE, "utf8");
+  await chmod(helperPath, 493);
+  const settings = {
+    // Pre-accept Claude Code's "Bypass Permissions mode" disclaimer. Build-capable
+    // spawns pass `--dangerously-skip-permissions`; on a real PTY the CLI otherwise
+    // parks on the interactive "Yes, I accept / No, exit" dialog whose default focus
+    // is "No, exit" — so it cannot be auto-dismissed by an Enter nudge and the run
+    // stalls until the auto-nudge watchdog shuts it down. The CLI reads this key
+    // from the `--settings` (flagSettings) layer via its bypass-mode gate, so
+    // setting it here suppresses the dialog deterministically on every spawn —
+    // independent of the `bypassPermissionsModeAccepted` seed in credentials.ts,
+    // which the CLI's one-time migration consumes and which is subject to
+    // persistence races on the codespace user-home.
+    skipDangerousModePermissionPrompt: true,
+    // Auto-approve tool calls so the interactive (PTY) agent never stops to
+    // prompt the viewer. This only suppresses per-tool approval prompts — it
+    // does NOT relax the planning gate: in discovery/plan mode the spawn passes
+    // `--permission-mode plan`, which keeps the agent read-only (no edits/commits
+    // until it exits plan mode) regardless of this allow-list. In build mode the
+    // spawn already bypasses prompts via `--dangerously-skip-permissions`.
+    // NOTE: a bare "*" rule is INVALID (the CLI rejects it and parks the TUI on
+    // a Settings Warning dialog at boot) — hence the explicit ALLOW_RULES list.
+    permissions: {
+      allow: ALLOW_RULES
+    },
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: "ExitPlanMode",
+          hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}`, timeout: 120 }]
+        },
+        {
+          // Observe-only: lets the session report waiting_for_input the moment
+          // the planning questionnaire renders. The helper fails open for this
+          // tool, so the questionnaire is never blocked by Conveyor.
+          matcher: "AskUserQuestion",
+          hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}`, timeout: 30 }]
+        },
+        {
+          // Plan-permission spawns prompt for MCP tools even when they're in
+          // permissions.allow — the CLI can't classify them as read-only. A
+          // hook allow bypasses the permission engine in every mode. Loose by
+          // design: the pod is the sandbox, and planning agents must call
+          // update_task etc. The helper answers locally (no socket).
+          matcher: "mcp__.*",
+          hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}`, timeout: 30 }]
+        }
+      ],
+      PostToolUse: [
+        {
+          matcher: "*",
+          hooks: [{ type: "command", command: `node ${JSON.stringify(helperPath)}` }]
+        }
+      ]
+    }
+  };
+  await writeFile2(settingsPath, JSON.stringify(settings, null, 2), "utf8");
+  return { settingsPath, helperPath };
 }
 
 // src/harness/pty/output-coalescer.ts
@@ -3791,7 +3809,7 @@ var PtyOutputCoalescer = class {
 // src/harness/pty/tool-server.ts
 import { createServer as createServer2 } from "http";
 import { writeFile as writeFile3 } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 import { randomBytes } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -3959,7 +3977,7 @@ async function startToolServers(mcpServers, tempDir) {
     config[name] = { type: "http", url, headers: { Authorization: `Bearer ${token}` } };
   }
   if (Object.keys(config).length === 0) return { servers, mcpConfigPath: null };
-  const mcpConfigPath = join3(tempDir, "mcp-config.json");
+  const mcpConfigPath = join2(tempDir, "mcp-config.json");
   await writeFile3(mcpConfigPath, JSON.stringify({ mcpServers: config }, null, 2), "utf8");
   return { servers, mcpConfigPath };
 }
@@ -3978,6 +3996,18 @@ var PLAN_DIALOG_INTERVAL_MS = 1500;
 var PLAN_DIALOG_SLOW_INTERVAL_MS = 5e3;
 var PLAN_DIALOG_FAST_WINDOW_MS = 1e4;
 var PLAN_DIALOG_WINDOW_MS = 9e4;
+function resolveSubmitNudgeTiming() {
+  const envMs = (name, fallback) => {
+    const raw = Number(process.env[name]);
+    return Number.isFinite(raw) && raw > 0 ? raw : fallback;
+  };
+  return {
+    intervalMs: envMs("CONVEYOR_PTY_NUDGE_INTERVAL_MS", SUBMIT_NUDGE_INTERVAL_MS),
+    slowIntervalMs: envMs("CONVEYOR_PTY_NUDGE_SLOW_INTERVAL_MS", SUBMIT_NUDGE_SLOW_INTERVAL_MS),
+    maxPresses: SUBMIT_NUDGE_MAX_PRESSES,
+    windowMs: envMs("CONVEYOR_PTY_NUDGE_WINDOW_MS", SUBMIT_NUDGE_WINDOW_MS)
+  };
+}
 function turnOptionsFrom(options) {
   return {
     canUseTool: options.canUseTool,
@@ -3986,14 +4016,14 @@ function turnOptionsFrom(options) {
     abortController: options.abortController
   };
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function extractSpawn(mod) {
-  if (!isRecord2(mod)) return null;
+  if (!isRecord3(mod)) return null;
   if (typeof mod.spawn === "function") return mod.spawn;
   const def = mod.default;
-  if (isRecord2(def) && typeof def.spawn === "function") return def.spawn;
+  if (isRecord3(def) && typeof def.spawn === "function") return def.spawn;
   return null;
 }
 async function loadPtySpawn() {
@@ -4015,6 +4045,16 @@ function inheritedEnv(socketPath) {
 function buildPromptBytes(text) {
   return `\x1B[200~${text}\x1B[201~`;
 }
+function renderPromptContentText(content) {
+  return content.map((block) => {
+    const b = block;
+    if (b?.type === "text" && typeof b.text === "string") return b.text;
+    if (b?.type === "image") {
+      return `[Image attachment \u2014 use list_task_files / get_attachment to view]`;
+    }
+    return JSON.stringify(block);
+  }).join("\n\n");
+}
 function sleep3(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
@@ -4031,9 +4071,9 @@ function parseUserQuestions(input) {
   if (!Array.isArray(input.questions)) return [];
   const questions = [];
   for (const entry of input.questions) {
-    if (!isRecord2(entry)) continue;
+    if (!isRecord3(entry)) continue;
     if (typeof entry.question !== "string") continue;
-    const options = Array.isArray(entry.options) ? entry.options.filter(isRecord2).filter((o) => typeof o.label === "string").map((o) => ({
+    const options = Array.isArray(entry.options) ? entry.options.filter(isRecord3).filter((o) => typeof o.label === "string").map((o) => ({
       label: o.label,
       description: typeof o.description === "string" ? o.description : ""
     })) : [];
@@ -4281,8 +4321,8 @@ var PtySession = class {
       return;
     }
     try {
-      this.tempDir = await mkdtemp2(join4(tmpdir4(), "conveyor-pty-"));
-      const socketPath = join4(this.tempDir, "hook.sock");
+      this.tempDir = await mkdtemp2(join3(tmpdir3(), "conveyor-pty-"));
+      const socketPath = join3(this.tempDir, "hook.sock");
       this.socket = new HookSocketServer(
         socketPath,
         (progress) => this.handleProgress(progress),
@@ -4294,7 +4334,14 @@ var PtySession = class {
       const transcriptPath = sessionTranscriptPath(this.options.cwd, sessionId);
       await mkdir2(dirname(transcriptPath), { recursive: true });
       const startOffset = this.resume ? await transcriptSize(transcriptPath) : 0;
-      this.tailer = new JsonlTailer(transcriptPath, (event) => this.handleTranscriptEvent(event));
+      const sendChat = this.bridge?.sendChatEvent?.bind(this.bridge);
+      this.tailer = new JsonlTailer(
+        transcriptPath,
+        (event) => this.handleTranscriptEvent(event),
+        sendChat ? (raw) => {
+          for (const chatEvent of mapChatRecords(raw)) sendChat(chatEvent);
+        } : void 0
+      );
       this.tailer.start(startOffset);
       await this.spawn(settingsPath, socketPath);
       if (signal) {
@@ -4454,7 +4501,7 @@ var PtySession = class {
     }
     for await (const message of this.turnPrompt) {
       const content = message.message.content;
-      const text = typeof content === "string" ? content : JSON.stringify(content);
+      const text = typeof content === "string" ? content : renderPromptContentText(content);
       await this.deliverPrompt(text);
     }
   }
@@ -4477,20 +4524,21 @@ var PtySession = class {
     if (this.submitNudgeTimer) return;
     this.pendingSubmitNudge = true;
     const startedAt = Date.now();
+    const { intervalMs, slowIntervalMs, maxPresses, windowMs } = resolveSubmitNudgeTiming();
     let presses = 0;
     const press = () => {
-      if (this._toreDown || !this.pendingSubmitNudge || Date.now() - startedAt >= SUBMIT_NUDGE_WINDOW_MS) {
+      if (this._toreDown || !this.pendingSubmitNudge || Date.now() - startedAt >= windowMs) {
         this.disarmSubmitNudge();
         return;
       }
       presses++;
       this.writeStdin("\r");
-      if (presses === SUBMIT_NUDGE_MAX_PRESSES && this.submitNudgeTimer) {
+      if (presses === maxPresses && this.submitNudgeTimer) {
         clearInterval(this.submitNudgeTimer);
-        this.submitNudgeTimer = setInterval(press, SUBMIT_NUDGE_SLOW_INTERVAL_MS);
+        this.submitNudgeTimer = setInterval(press, slowIntervalMs);
       }
     };
-    this.submitNudgeTimer = setInterval(press, SUBMIT_NUDGE_INTERVAL_MS);
+    this.submitNudgeTimer = setInterval(press, intervalMs);
   }
   disarmSubmitNudge() {
     this.pendingSubmitNudge = false;
@@ -4617,11 +4665,11 @@ var PtySession = class {
 // src/harness/pty/credentials.ts
 import { chmod as chmod2, mkdir as mkdir3, readFile, rm as rm5, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 var SYNTH_TOKEN_TTL_MS = 365 * 24 * 60 * 60 * 1e3;
 var REFRESH_SKEW_MS = 30 * 24 * 60 * 60 * 1e3;
 function claudeCredentialsPath() {
-  return join5(claudeConfigHome(), ".credentials.json");
+  return join4(claudeConfigHome(), ".credentials.json");
 }
 function isConveyorCloudEnv(env = process.env) {
   return Boolean(env.CLAUDESPACE_NAME || env.CODESPACE_NAME || env.CODESPACES);
@@ -4695,7 +4743,7 @@ async function ensureClaudeCredentials(env = process.env) {
 }
 function claudeJsonPath() {
   const configDir = process.env.CLAUDE_CONFIG_DIR;
-  return configDir ? join5(configDir, ".claude.json") : join5(homedir2(), ".claude.json");
+  return configDir ? join4(configDir, ".claude.json") : join4(homedir2(), ".claude.json");
 }
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
@@ -4951,7 +4999,7 @@ function createHarness(kind = "sdk", ptyBridge) {
 
 // src/execution/query-executor.ts
 import { createHash } from "crypto";
-import { existsSync, readFileSync as readFileSync2, truncateSync } from "fs";
+import { existsSync as existsSync2, readFileSync, truncateSync } from "fs";
 
 // src/execution/pack-runner-prompt.ts
 function findLastAgentMessageIndex(history) {
@@ -5106,8 +5154,9 @@ function formatChatFile(file) {
     return [`[Attached: ${file.fileName} (${file.mimeType}${sizeStr})]: ${file.downloadUrl}`];
   }
   if (file.content && file.contentEncoding === "base64") {
+    const link = file.downloadUrl ? ` or download: ${file.downloadUrl}` : "";
     return [
-      `[Attached image: ${file.fileName} (${file.mimeType}${sizeStr}) \u2014 use get_attachment("${file.fileId}") to view]`
+      `[Attached image: ${file.fileName} (${file.mimeType}${sizeStr}) \u2014 use get_attachment("${file.fileId}") to view${link}]`
     ];
   }
   return [`[Attached: ${file.fileName} (${file.mimeType}${sizeStr})]`];
@@ -5119,8 +5168,9 @@ function formatTaskFile(file) {
   }
   if (file.content && file.contentEncoding === "base64") {
     const size = formatFileSize(file.fileSize);
+    const link = file.downloadUrl ? ` or download: ${file.downloadUrl}` : "";
     return [
-      `- [Attached image: ${file.fileName} (${file.mimeType}${size ? `, ${size}` : ""}) \u2014 use get_attachment("${file.fileId}") to view]`
+      `- [Attached image: ${file.fileName} (${file.mimeType}${size ? `, ${size}` : ""}) \u2014 use get_attachment("${file.fileId}") to view${link}]`
     ];
   }
   if (!file.content) {
@@ -5603,7 +5653,7 @@ function buildDiscoveryPrompt(context, runnerMode) {
 ## Mode: Discovery`,
     `You are in Discovery mode \u2014 helping plan and scope this task.`,
     `- You have read-only codebase access (can read files, run git commands, search code)`,
-    `- You can write plan files in .claude/plans/ only \u2014 no other file writes`,
+    `- You can write plan files in .claude/plans/ only \u2014 no other file writes. Plan files on disk are NOT synced to the task; save the plan via update_task_plan`,
     `- Do NOT attempt to edit, write, or modify source code files \u2014 these operations will be denied`,
     `- If you identify code changes needed, describe them in the plan instead of implementing them`,
     `- You can create and manage subtasks`,
@@ -5653,7 +5703,7 @@ function buildDiscoveryPrompt(context, runnerMode) {
     ``,
     `### Plan Verification Requirements`,
     `Every plan MUST include a **Testing / Verification** section so the build agent has a clear definition of "done". Enumerate:`,
-    `- The quality gates the build agent should run: \`bun run lint\`, \`bun run typecheck\`, \`bun run test\` (or scoped equivalents)`,
+    `- The scoped verification for the change: \`bun run check\` (lint + typecheck) plus \`bun run test:affected\` \u2014 name the specific package suites the diff will touch. Docs-only plans should state that no local gates are needed (CI validates on the PR).`,
     `- Any task-specific end-to-end checks (manual UI walk-through, API smoke test, migration dry-run, etc.)`,
     `You are NOT expected to run these gates yourself \u2014 discovery is read-only. Just describe them in the plan.`,
     ``,
@@ -5732,14 +5782,14 @@ function buildModePrompt(agentMode, context, runnerMode) {
           `- Goal: coordinate child task execution and ensure all children complete successfully`
         ] : [
           `- If this is a leaf task (no children): execute the plan directly`,
-          `- Goal: implement the plan, verify quality gates, open a PR when done`,
+          `- Goal: implement the plan, run scoped verification, open a PR when done`,
           ``,
           `### Pre-PR Verification Checklist`,
-          `Before calling \`mcp__conveyor__create_pull_request\`, verify ALL of the following pass:`,
-          `1. \`bun run lint\` \u2014 no new lint errors`,
-          `2. \`bun run typecheck\` \u2014 no new type errors`,
-          `3. \`bun run test\` \u2014 relevant suites pass (scope to the affected package if the full run is prohibitively slow, and state the scope in the PR description)`,
-          `If a gate fails, fix it before opening the PR. Do NOT open PRs with known failing gates.`,
+          `CI runs the FULL suite (lint, typecheck, all test shards) on every PR \u2014 do not duplicate it locally. Before calling \`mcp__conveyor__create_pull_request\`, scope verification to your diff:`,
+          `1. \`bun run check\` \u2014 lint + typecheck (fast; run whenever you changed code)`,
+          `2. \`bun run test:affected\` \u2014 runs only the tests your diff can affect (docs-only diffs run nothing; apps/api diffs run unit tests only since CI covers the int shards; shared/db diffs escalate to the full suite automatically)`,
+          `Docs/markdown/.claude-only changes need NO local gates \u2014 open the PR and let CI validate.`,
+          `If a gate fails, fix it before opening the PR. Do NOT open PRs with known failing gates. Never run the full \`bun run test\` for a diff confined to one package.`,
           `For refactors: also run \`git diff ${context?.baseBranch ?? "dev"}..HEAD\` and confirm the public API surface (exports, function signatures) has no unintended breaking changes.`
         ]
       ];
@@ -5840,12 +5890,13 @@ function buildPmPreamble(context) {
     `
 Environment (ready, no setup required):`,
     `- Repository is cloned at your current working directory.`,
+    `- The shell cwd resets between Bash calls \u2014 always use absolute paths (or \`git -C\`); never spend a tool call on a bare \`cd\`.`,
     `- You can read files and run git commands to understand the codebase before writing task plans.`,
     `- Check the dev branch (e.g. run: git fetch && git checkout dev || git checkout main) to understand the current state of the codebase that agents will branch off of.`,
     `
 Workflow:`,
-    `- You can draft and iterate on plans in .claude/plans/*.md \u2014 these files are automatically synced to the task.`,
-    `- You can also use update_task_plan directly to save the plan to the task.`,
+    `- You can draft and iterate on plans in .claude/plans/*.md, but files on disk are NOT synced to the task.`,
+    `- Save the plan to the task with update_task_plan \u2014 this is the only way the plan is persisted.`,
     `- After saving the plan, call post_to_chat with a short summary for the team (your turn output is NOT posted to chat \u2014 they only see what you post), then end your turn. Do NOT attempt to execute the plan yourself.`,
     `- A separate task agent will handle execution after the team reviews and approves your plan.`
   ];
@@ -5878,6 +5929,7 @@ Environment (ready, no setup required):`,
     `- Repository is cloned at your current working directory.`,
     `- You can read, write, and edit files directly.`,
     `- You can run shell commands including git, build tools, and test runners.`,
+    `- The shell cwd resets between Bash calls \u2014 always use absolute paths (or \`git -C\`, \`bun run --cwd\`); never spend a tool call on a bare \`cd\`.`,
     context.githubBranch ? `- You are working on branch: \`${context.githubBranch}\`` : "",
     `
 Safety rules:`,
@@ -5902,6 +5954,10 @@ Environment (fully ready \u2014 do NOT verify or set up):`,
     `- Branch \`${context.githubBranch}\` is already checked out.`,
     `- All dependencies are installed, database is migrated, and the dev server is running.`,
     `- Git is configured. Commit and push directly to this branch.`,
+    `- The shell cwd resets between Bash calls \u2014 always use absolute paths (or \`git -C\`, \`bun run --cwd\`); never spend a tool call on a bare \`cd\`.`,
+    `- When a build/lint/test run fails, capture its output to a file once and grep the file \u2014 never re-run the suite just to re-filter the same output. Don't poll background jobs with sleep/ps/tail loops.`,
+    `- The \`gh\` CLI may not be installed \u2014 use the mcp__conveyor__* tools for PR and task state.`,
+    `- Read a file before your first Write/Edit to it, and batch multiple changes to the same file into a single call instead of many sequential edits.`,
     `
 IMPORTANT \u2014 Skip all environment verification. Do NOT run any of the following:`,
     `- bun/npm install, pip install, or any dependency installation`,
@@ -6164,7 +6220,7 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
     `Your FIRST action should be reading the relevant source files mentioned in the plan, then writing code. Do NOT run install, build, lint, test, or dev server commands first \u2014 the environment is already set up.`,
     `Work on the git branch "${context.githubBranch}". Stay on this branch for the entire task. Do not checkout or create other branches.`,
     `Use post_to_chat to keep the team informed (your turn output is NOT shown in chat \u2014 post_to_chat is the only way they see it): briefly post what you're doing when you begin meaningful implementation, and again when the PR is ready.`,
-    `Before opening the PR, run the quality gates: \`bun run lint && bun run typecheck && bun run test\`. Fix any failures. Do NOT open a PR with known failing gates \u2014 scope the test run to affected packages if the full suite is prohibitively slow, and state the scope in the PR body.`,
+    `Before opening the PR, verify with \`bun run check\` (lint + typecheck) and \`bun run test:affected\` (tests scoped to your diff \u2014 docs-only changes need no local gates). Fix any failures. Do NOT open a PR with known failing gates. CI runs the full suite on the PR \u2014 never run the full \`bun run test\` for a diff confined to one package.`,
     `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
   ];
   if (isAutoMode) {
@@ -6236,7 +6292,7 @@ New messages since your last run:`,
     ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
     `
 Address the requested changes directly. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 go straight to implementing the feedback.`,
-    `Before pushing or opening a PR, re-run the quality gates: \`bun run lint && bun run typecheck && bun run test\`. Fix any failures \u2014 relaunches are the most common place verification gets skipped.`,
+    `Before pushing or opening a PR, re-verify with \`bun run check\` and \`bun run test:affected\`. Fix any failures \u2014 relaunches are the most common place verification gets skipped. CI runs the full suite on the PR; keep local runs scoped to your diff.`,
     `Implement your updates and open a PR when finished.`
   ];
   if (context.githubPRUrl) {
@@ -6679,11 +6735,11 @@ function buildCreatePullRequestTool(connection, config) {
     async ({ title, body, branch, baseBranch, commitMessage, skipVerify }) => {
       try {
         const cwd = config.workspaceDir;
-        if (hasUncommittedChanges(cwd)) {
+        if (await hasUncommittedChanges(cwd)) {
           const message = commitMessage || `${title}
 
 Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>`;
-          const commitHash = stageAndCommit(cwd, message);
+          const commitHash = await stageAndCommit(cwd, message);
           if (commitHash) {
             connection.sendEvent({
               type: "message",
@@ -6695,7 +6751,7 @@ Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>`;
             );
           }
         }
-        if (hasUnpushedCommits(cwd)) {
+        if (await hasUnpushedCommits(cwd)) {
           const pushSuccess = await pushToOrigin(
             cwd,
             async () => {
@@ -6894,7 +6950,7 @@ function buildMutationTools(connection, config) {
 
 // src/tools/attachment-tools.ts
 import { readFile as readFile3, stat as stat5 } from "fs/promises";
-import { basename, extname, isAbsolute, join as join6 } from "path";
+import { basename, extname, isAbsolute, join as join5 } from "path";
 import { z as z6 } from "zod";
 var IMAGE_MIME_BY_EXT = {
   ".png": "image/png",
@@ -6913,7 +6969,7 @@ function buildUploadAttachmentTool(connection, config) {
     },
     async ({ path: path4, title }) => {
       try {
-        const filePath = isAbsolute(path4) ? path4 : join6(config.workspaceDir, path4);
+        const filePath = isAbsolute(path4) ? path4 : join5(config.workspaceDir, path4);
         const mimeType = IMAGE_MIME_BY_EXT[extname(filePath).toLowerCase()];
         if (!mimeType) {
           return textResult(
@@ -8048,7 +8104,6 @@ async function handleExitPlanMode(host, input) {
     return { behavior: "allow", updatedInput: input };
   }
   try {
-    await host.syncPlanFile();
     const taskProps = await host.connection.getTaskProperties();
     const missingProps = collectMissingProps(taskProps);
     if (host.isParentTask) {
@@ -8318,7 +8373,7 @@ function sessionLineageKey(taskId, agentMode, runnerMode) {
 }
 function sessionFileExists(sessionUuid, cwd) {
   try {
-    return existsSync(sessionTranscriptPath(cwd, sessionUuid));
+    return existsSync2(sessionTranscriptPath(cwd, sessionUuid));
   } catch {
     return false;
   }
@@ -8327,10 +8382,18 @@ function hasExistingSessionFile(taskId, cwd, lineage) {
   const key = sessionLineageKey(taskId, lineage.agentMode, lineage.runnerMode);
   return sessionFileExists(taskIdToSessionUuid(key), cwd);
 }
+function resolveSessionStart(lineageKey, cwd) {
+  const sessionUuid = taskIdToSessionUuid(lineageKey);
+  if (sessionFileExists(sessionUuid, cwd)) {
+    repairTornSessionFile(sessionTranscriptPath(cwd, sessionUuid));
+    return { resume: sessionUuid };
+  }
+  return { sessionId: sessionUuid };
+}
 function repairTornSessionFile(path4) {
   try {
-    if (!existsSync(path4)) return false;
-    const content = readFileSync2(path4, "utf8");
+    if (!existsSync2(path4)) return false;
+    const content = readFileSync(path4, "utf8");
     if (content.length === 0) return false;
     let keepEnd = content.length;
     if (!content.endsWith("\n")) {
@@ -8474,14 +8537,21 @@ async function buildFollowUpPrompt(host, context, followUpContent) {
 
 The team says:
 ${followUpText}` : followUpText;
+  const isPty = host.harnessKind === "pty";
   if (isPmMode) {
-    const prompt = buildMultimodalPrompt(textPrompt, context);
+    const prompt = buildMultimodalPrompt(textPrompt, context, isPty);
     if (followUpImages.length > 0 && Array.isArray(prompt)) {
       prompt.push(...followUpImages);
     }
     return prompt;
   }
   if (followUpImages.length > 0) {
+    if (isPty) {
+      const refs = followUpImages.map(
+        () => `[Image attachment \u2014 use list_task_files / get_attachment to view]`
+      );
+      return [textPrompt, ...refs].join("\n");
+    }
     return [{ type: "text", text: textPrompt }, ...followUpImages];
   }
   return textPrompt;
@@ -8522,17 +8592,11 @@ async function runSdkQuery(host, context, followUpContent, promptDeliveryOverrid
   if (host.isStopped()) return;
   const mode = host.agentMode;
   const isDiscoveryLike = mode === "discovery" || mode === "help";
-  const needsPlanSync = isDiscoveryLike || mode === "auto" && !host.hasExitedPlanMode;
-  if (needsPlanSync) {
-    host.snapshotPlanFiles();
-  }
-  const sessionUuid = taskIdToSessionUuid(
-    sessionLineageKey(context.taskId, mode, host.config.mode)
+  const sessionStart = resolveSessionStart(
+    sessionLineageKey(context.taskId, mode, host.config.mode),
+    host.config.workspaceDir
   );
-  const hasExistingSession = sessionFileExists(sessionUuid, host.config.workspaceDir);
-  if (hasExistingSession) {
-    repairTornSessionFile(sessionTranscriptPath(host.config.workspaceDir, sessionUuid));
-  }
+  const hasExistingSession = !!sessionStart.resume;
   const promptDelivery = promptDeliveryOverride ?? resolvePromptDelivery({
     harnessKind: host.harnessKind,
     runnerMode: host.config.mode,
@@ -8544,19 +8608,17 @@ async function runSdkQuery(host, context, followUpContent, promptDeliveryOverrid
   const options = {
     ...buildQueryOptions(host, context),
     promptDelivery,
-    ...hasExistingSession ? {} : { sessionId: sessionUuid }
+    ...sessionStart.sessionId ? { sessionId: sessionStart.sessionId } : {}
   };
-  const resume = hasExistingSession ? sessionUuid : void 0;
+  const resume = sessionStart.resume;
   if (followUpContent) {
     await runFollowUpQuery(host, context, options, resume, followUpContent);
-  } else if (isDiscoveryLike && promptDelivery !== "prefill") {
     return;
-  } else {
-    await runInitialQuery(host, context, options, resume, promptDelivery);
   }
-  if (needsPlanSync) {
-    await host.syncPlanFile();
+  if (isDiscoveryLike && promptDelivery !== "prefill") {
+    return;
   }
+  await runInitialQuery(host, context, options, resume, promptDelivery);
 }
 async function runFollowUpQuery(host, context, options, resume, followUpContent) {
   if (options.promptDelivery === "prefill") {
@@ -8625,7 +8687,7 @@ function latestUserMessageText(context) {
   }
   return null;
 }
-function selectInitialPromptInput(promptDelivery, initialPrompt, context, baseAppendSystemPrompt) {
+function selectInitialPromptInput(promptDelivery, initialPrompt, context, baseAppendSystemPrompt, harnessKind) {
   if (promptDelivery === "prefill") {
     return {
       prompt: latestUserMessageText(context) ?? "",
@@ -8633,7 +8695,9 @@ function selectInitialPromptInput(promptDelivery, initialPrompt, context, baseAp
     };
   }
   return {
-    prompt: buildMultimodalPrompt(initialPrompt, context),
+    // On the PTY harness image blocks would be pasted into the TUI as text —
+    // the prompt body already links each image (get_attachment / downloadUrl).
+    prompt: buildMultimodalPrompt(initialPrompt, context, harnessKind === "pty"),
     appendSystemPrompt: baseAppendSystemPrompt
   };
 }
@@ -8648,7 +8712,8 @@ async function runInitialQuery(host, context, options, resume, promptDelivery) {
     promptDelivery,
     initialPrompt,
     context,
-    options.appendSystemPrompt
+    options.appendSystemPrompt,
+    host.harnessKind
   );
   const queryOptions = { ...options, appendSystemPrompt };
   let agentQuery = host.harness.executeQuery({
@@ -8673,7 +8738,7 @@ async function buildRetryQuery(host, context, options, lastErrorWasImage) {
   const retryPrompt = buildMultimodalPrompt(
     await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
     context,
-    lastErrorWasImage
+    lastErrorWasImage || host.harnessKind === "pty"
   );
   return host.harness.executeQuery({
     prompt: host.createInputStream(retryPrompt),
@@ -8701,7 +8766,8 @@ async function handleAuthError(context, host, options) {
   host.connection.storeSessionId("");
   const freshPrompt = buildMultimodalPrompt(
     await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
-    context
+    context,
+    host.harnessKind === "pty"
   );
   const freshQuery = host.harness.executeQuery({
     prompt: host.createInputStream(freshPrompt),
@@ -8715,7 +8781,8 @@ async function handleStaleSession(context, host, options) {
   host.connection.storeSessionId("");
   const freshPrompt = buildMultimodalPrompt(
     await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
-    context
+    context,
+    host.harnessKind === "pty"
   );
   const freshQuery = host.harness.executeQuery({
     prompt: host.createInputStream(freshPrompt),
@@ -8941,13 +9008,14 @@ function resolveHarnessKind() {
 function buildPtyBridge(connection) {
   return {
     sendOutput: (data, dims) => connection.sendPtyOutput(data, dims),
+    sendChatEvent: (event) => connection.sendPtyChatEvent(event),
     sendEnded: () => connection.sendPtyEnded(),
     onInput: (handler) => connection.onPtyInput(handler),
     onResize: (handler) => connection.onPtyResize(handler)
   };
 }
 var QueryBridge = class {
-  constructor(connection, mode, runnerConfig, callbacks, workspaceDir) {
+  constructor(connection, mode, runnerConfig, callbacks) {
     this.connection = connection;
     this.mode = mode;
     this.runnerConfig = runnerConfig;
@@ -8958,7 +9026,6 @@ var QueryBridge = class {
       harnessKind,
       harnessKind === "pty" ? buildPtyBridge(connection) : void 0
     );
-    this.planSync = new PlanSync(workspaceDir, connection);
   }
   connection;
   mode;
@@ -8968,7 +9035,6 @@ var QueryBridge = class {
   /** Which harness drives this bridge ("pty" task chat; "sdk" only under the
    *  CONVEYOR_FORCE_SDK_CARDS maintainer override). */
   harnessKind;
-  planSync;
   sessionIds = /* @__PURE__ */ new Map();
   activeQuery = null;
   pendingToolOutputs = [];
@@ -9169,8 +9235,6 @@ var QueryBridge = class {
         if (bridge.onSoftStop) bridge.onSoftStop();
       },
       createInputStream: (prompt) => bridge.createInputStream(prompt),
-      snapshotPlanFiles: () => bridge.planSync.snapshotPlanFiles(),
-      syncPlanFile: () => bridge.planSync.syncPlanFile(),
       onModeTransition: bridge.onModeTransition
     };
   }
@@ -9186,9 +9250,9 @@ var QueryBridge = class {
 };
 
 // src/runner/session-runner-helpers.ts
-import { readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname2, join as join7 } from "path";
-import { fileURLToPath } from "url";
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join6 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function mapChatHistory(messages) {
   if (!messages) return [];
   return messages.map((m) => ({
@@ -9213,10 +9277,10 @@ function mapChatHistory(messages) {
 }
 function readAgentVersion() {
   try {
-    const here = dirname2(fileURLToPath(import.meta.url));
+    const here = dirname2(fileURLToPath2(import.meta.url));
     for (const rel of ["../package.json", "../../package.json"]) {
       try {
-        const pkg = JSON.parse(readFileSync3(join7(here, rel), "utf-8"));
+        const pkg = JSON.parse(readFileSync2(join6(here, rel), "utf-8"));
         if (pkg.version) return pkg.version;
       } catch {
       }
@@ -9302,7 +9366,7 @@ async function sampleKeyUsage(token) {
 
 // src/runner/port-discovery.ts
 import { readFile as readFile4 } from "fs/promises";
-import { execFile } from "child_process";
+import { execFile as execFile3 } from "child_process";
 var PROC_TCP_LISTEN_STATE = "0A";
 function parseProcNetTcpListeners(content) {
   const ports = [];
@@ -9337,7 +9401,7 @@ async function readProcListeningPorts(procPaths = DEFAULT_PROC_PATHS) {
 }
 async function readNetstatListeningPorts() {
   const output = await new Promise((resolve) => {
-    execFile("netstat", ["-an", "-p", "tcp"], { timeout: 5e3 }, (err, stdout) => {
+    execFile3("netstat", ["-an", "-p", "tcp"], { timeout: 5e3 }, (err, stdout) => {
       resolve(err ? null : stdout);
     });
   });
@@ -9488,10 +9552,12 @@ var PortDiscovery = class {
 };
 
 // src/runner/parent-pull-handler.ts
-import { execSync as execSync4 } from "child_process";
-function handlePullBranch(workDir, branch) {
+import { execFile as execFile4 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile4);
+async function handlePullBranch(workDir, branch) {
   if (!branch) return;
-  const current = getCurrentBranch(workDir);
+  const current = await getCurrentBranch(workDir);
   if (current !== branch) {
     process.stderr.write(
       `[conveyor-agent] pull_branch ignored \u2014 current branch ${current ?? "(detached)"} != ${branch}
@@ -9499,7 +9565,7 @@ function handlePullBranch(workDir, branch) {
     );
     return;
   }
-  if (hasUncommittedChanges(workDir)) {
+  if (await hasUncommittedChanges(workDir)) {
     process.stderr.write(
       `[conveyor-agent] pull_branch ignored \u2014 uncommitted changes on ${branch}
 `
@@ -9507,16 +9573,15 @@ function handlePullBranch(workDir, branch) {
     return;
   }
   try {
-    execSync4(`git fetch origin ${branch}`, { cwd: workDir, stdio: "ignore", timeout: 6e4 });
+    await execFileAsync3("git", ["fetch", "origin", branch], { cwd: workDir, timeout: 6e4 });
   } catch {
     process.stderr.write(`[conveyor-agent] pull_branch: fetch failed for ${branch}
 `);
     return;
   }
   try {
-    execSync4(`git pull --ff-only origin ${branch}`, {
+    await execFileAsync3("git", ["pull", "--ff-only", "origin", branch], {
       cwd: workDir,
-      stdio: "ignore",
       timeout: 6e4
     });
     process.stderr.write(`[conveyor-agent] pull_branch: pulled origin/${branch}
@@ -9529,6 +9594,33 @@ function handlePullBranch(workDir, branch) {
   }
 }
 
+// src/runner/heavy-gate.ts
+import { readFileSync as readFileSync3 } from "fs";
+import path3 from "path";
+var GATE_KEYS = ["heavy", "test", "typecheck", "build"];
+function runDir() {
+  return process.env.CONVEYOR_RUN_DIR ?? "/tmp/conveyor-run";
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isHeavyGateActive() {
+  for (const key of GATE_KEYS) {
+    try {
+      const raw = readFileSync3(path3.join(runDir(), `${key}.pid`), "utf8").trim();
+      const pid = Number.parseInt(raw, 10);
+      if (Number.isInteger(pid) && pid > 0 && pidAlive(pid)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+
 // src/runner/session-runner.ts
 function isPostToChatTool(name) {
   return typeof name === "string" && (name === "post_to_chat" || name.endsWith("__post_to_chat"));
@@ -9566,8 +9658,14 @@ var SessionRunner = class _SessionRunner {
   agentSpokeThisTurn = false;
   /** Guards overlapping runs of the periodic git flush. */
   periodicFlushInFlight = false;
+  /** Consecutive flush ticks skipped because a heavy gate was running. */
+  gateSkipCount = 0;
+  /** Max consecutive gate-deferred ticks (~2 min each) before flushing anyway. */
+  static MAX_GATE_SKIPS = 10;
   /** Runtime preview-port poller (v3 dynamic port discovery). */
   portDiscovery = null;
+  /** Main event-loop lag measurement, shared with the heartbeat worker. */
+  loopLag = new LoopLagMonitor();
   constructor(config, callbacks) {
     this.config = config;
     this.callbacks = callbacks;
@@ -9576,7 +9674,7 @@ var SessionRunner = class _SessionRunner {
     this.mode = new ModeController(initialMode, config.runnerMode, config.isAuto);
     const lifecycleConfig = { ...DEFAULT_LIFECYCLE_CONFIG, ...config.lifecycle };
     this.lifecycle = new Lifecycle(lifecycleConfig, {
-      onHeartbeat: () => this.connection.sendHeartbeat(),
+      onHeartbeat: () => this.connection.sendHeartbeat(this.loopLag.takeMaxLagMs()),
       onIdleTimeout: () => {
         process.stderr.write("[conveyor-agent] Idle timeout reached, stopping agent\n");
         this.stopped = true;
@@ -9624,6 +9722,8 @@ var SessionRunner = class _SessionRunner {
     this.connection.sendEvent({ type: "connected", sessionId: this.sessionId });
     this.wireConnectionCallbacks();
     this.lifecycle.startHeartbeat();
+    this.loopLag.start();
+    this.connection.startHeartbeatWorker(this.loopLag.sharedBuffer);
     this.lifecycle.startTokenRefresh();
     this.lifecycle.startUsageSample();
     const { pendingMessages: serverMessages } = await this.connection.call("connectAgent", {
@@ -9686,10 +9786,10 @@ var SessionRunner = class _SessionRunner {
     }
     if (process.env.CONVEYOR_GIT_READY !== "1") {
       if (this.fullContext?.githubBranch) {
-        ensureOnTaskBranch(this.config.workspaceDir, this.fullContext.githubBranch);
+        await ensureOnTaskBranch(this.config.workspaceDir, this.fullContext.githubBranch);
       }
       if (this.fullContext?.baseBranch) {
-        syncWithBaseBranch(this.config.workspaceDir, this.fullContext.baseBranch);
+        await syncWithBaseBranch(this.config.workspaceDir, this.fullContext.baseBranch);
       }
     }
     if (!this.stopped) {
@@ -9709,7 +9809,7 @@ var SessionRunner = class _SessionRunner {
           );
         }
       } else {
-        const restored = restoreWipSnapshot(
+        const restored = await restoreWipSnapshot(
           this.config.workspaceDir,
           this.fullContext.githubBranch
         );
@@ -10052,6 +10152,14 @@ var SessionRunner = class _SessionRunner {
    *  clean tree. Guarded so two ticks can't overlap. Never throws. */
   async periodicGitFlush() {
     if (this.periodicFlushInFlight || this.stopped) return;
+    if (isHeavyGateActive() && this.gateSkipCount < _SessionRunner.MAX_GATE_SKIPS) {
+      this.gateSkipCount++;
+      if (this.gateSkipCount === 1) {
+        process.stderr.write("[conveyor-agent] Periodic git flush deferred \u2014 heavy gate running\n");
+      }
+      return;
+    }
+    this.gateSkipCount = 0;
     this.periodicFlushInFlight = true;
     try {
       const result = await flushAllPendingWork(this.config.workspaceDir, {
@@ -10150,6 +10258,7 @@ var SessionRunner = class _SessionRunner {
     void this.queryBridge?.dispose().catch(() => {
     });
     this.portDiscovery?.stop();
+    this.loopLag.stop();
     this.lifecycle.destroy();
     this.connection.disconnect();
     if (this.inputResolver) {
@@ -10169,23 +10278,41 @@ var SessionRunner = class _SessionRunner {
   }
   // ── Auto-mode stuck detection & nudge ───────────────────────────────
   static MAX_STUCK_NUDGES = 3;
-  /** The prompt delivered into the live TUI when an auto agent looks stuck. It
-   *  must offer BOTH escape routes so the agent never just goes idle. */
+  /** The build-phase nudge (In Progress, no PR). Offers BOTH escape routes so
+   *  the agent never just goes idle. */
   static STUCK_PROMPT = "You are in Auto mode, your task is still In Progress, and there is no open pull request. Do ONE of these right now: (1) open a pull request with the create_pull_request tool, OR (2) call post_to_chat to explain exactly where you are stuck and what you need from a human. Do not finish or go idle silently.";
+  /** The planning-phase nudge (still Planning, identification/plan unfinished).
+   *  Same two-escape-route shape, aimed at finishing discovery instead of a PR. */
+  static STUCK_PROMPT_PLANNING = "You are in Auto mode and still in the Planning phase \u2014 identification and/or the plan are not finished. Do ONE of these right now: (1) finish identifying the task (set the story points) and save the plan with the update_task_plan tool, then call ExitPlanMode to begin building, OR (2) call post_to_chat to explain exactly where you are stuck and what you need from a human. Do not finish or go idle silently.";
   /**
-   * An auto task is "stuck" when its last turn ended (the call sites run
-   * post-turn, so the TUI is no longer actively working), it has no open PR,
-   * AND the agent did not communicate in chat this turn. If the agent posted a
-   * message (explained itself / asked for help) it is waiting on a human, not
-   * silently stuck, so we leave it attached instead of nudging.
+   * Classify how an auto task is "stuck" after its turn ended (call sites run
+   * post-turn, so the TUI is no longer working), or null if it isn't. Shared
+   * guards: only auto, not rate-limited, under the nudge cap, and the agent
+   * stayed silent this turn — if it posted to chat (explained itself / asked for
+   * help) it's waiting on a human, not silently stuck.
+   *
+   * - "pr":       In Progress with no open PR (build finished without shipping).
+   * - "planning": still Planning without (identified + saved plan). A fresh auto
+   *   agent that finishes its plan turn WITHOUT ExitPlanMode would otherwise idle
+   *   → clean-exit → its session Ends → the workspace is reaped "agent_gone"
+   *   before a plan ever landed. Nudging (and, on exhaustion, going dormant)
+   *   keeps the session Active so the pod is never prematurely slept.
    */
+  autoStuckKind() {
+    if (!this.mode.isAuto || this.stopped) return null;
+    if (this.queryBridge?.wasRateLimited) return null;
+    if (this.prNudgeCount > _SessionRunner.MAX_STUCK_NUDGES) return null;
+    if (this.agentSpokeThisTurn) return null;
+    if (!this.taskContext) return null;
+    const { status, storyPointId, plan, githubPRUrl } = this.taskContext;
+    if (status === "InProgress" && !githubPRUrl) return "pr";
+    if (status === "Planning" && !(storyPointId !== null && !!plan?.trim())) {
+      return "planning";
+    }
+    return null;
+  }
   isAutoStuck() {
-    if (!this.mode.isAuto || this.stopped) return false;
-    if (this.queryBridge?.wasRateLimited) return false;
-    if (this.prNudgeCount > _SessionRunner.MAX_STUCK_NUDGES) return false;
-    if (this.agentSpokeThisTurn) return false;
-    if (!this.taskContext) return false;
-    return this.taskContext.status === "InProgress" && !this.taskContext.githubPRUrl;
+    return this.autoStuckKind() !== null;
   }
   /**
    * Stop driving the agent and route the core loop into dormant idle —
@@ -10221,6 +10348,16 @@ var SessionRunner = class _SessionRunner {
     } catch {
     }
   }
+  /** Prompt + chat-message label for a stuck-nudge of the given kind. */
+  stuckNudgeContent(kind) {
+    if (kind === "planning") {
+      return {
+        prompt: _SessionRunner.STUCK_PROMPT_PLANNING,
+        situation: "still Planning with no identified plan"
+      };
+    }
+    return { prompt: _SessionRunner.STUCK_PROMPT, situation: "still no PR" };
+  }
   async maybeHandleStuckAuto() {
     await this.refreshTaskContext();
     if (!this.isAutoStuck()) return;
@@ -10228,17 +10365,18 @@ var SessionRunner = class _SessionRunner {
       this.prNudgeCount++;
       if (this.prNudgeCount > _SessionRunner.MAX_STUCK_NUDGES) {
         this.enterDormantForHumanTakeover(
-          `Auto-mode: I couldn't open a PR or get unstuck after ${_SessionRunner.MAX_STUCK_NUDGES} attempts. Staying connected \u2014 reply here or in the terminal and I'll keep working.`
+          `Auto-mode: I couldn't finish or get unstuck after ${_SessionRunner.MAX_STUCK_NUDGES} attempts. Staying connected \u2014 reply here or in the terminal and I'll keep working.`
         );
         return;
       }
+      const { prompt, situation } = this.stuckNudgeContent(this.autoStuckKind());
       const attempt = this.prNudgeCount;
-      const chatMsg = attempt === 1 ? "Auto-nudge: still In Progress with no PR \u2014 prompting the agent to finish or explain where it's stuck..." : `Auto-nudge (attempt ${attempt}/${_SessionRunner.MAX_STUCK_NUDGES}): still no PR \u2014 prompting the agent again...`;
+      const chatMsg = attempt === 1 ? `Auto-nudge: ${situation} \u2014 prompting the agent to finish or explain where it's stuck...` : `Auto-nudge (attempt ${attempt}/${_SessionRunner.MAX_STUCK_NUDGES}): ${situation} \u2014 prompting the agent again...`;
       this.connection.postChatMessage(chatMsg);
       await this.setState("running");
-      await this.callbacks.onEvent({ type: "pr_nudge", prompt: _SessionRunner.STUCK_PROMPT });
+      await this.callbacks.onEvent({ type: "pr_nudge", prompt });
       if (this.interrupted || this.stopped) return;
-      await this.executeQuery(_SessionRunner.STUCK_PROMPT);
+      await this.executeQuery(prompt);
       if (this.interrupted || this.stopped) return;
       await this.refreshTaskContext();
       if (this.agentSpokeThisTurn && !this.taskContext?.githubPRUrl) {
@@ -10296,32 +10434,26 @@ var SessionRunner = class _SessionRunner {
       mode: this.config.runnerMode,
       isAuto: this.config.isAuto
     };
-    const bridge = new QueryBridge(
-      this.connection,
-      this.mode,
-      runnerConfig,
-      {
-        onStatusChange: (status) => {
-          if (status === "running" && this._state === "waiting_for_input") {
-            this._state = "running";
-            this.lifecycle.cancelIdleTimer();
-          }
-          return this.callbacks.onStatusChange(status);
-        },
-        onEvent: (event) => {
-          const evt = event;
-          if (evt.type === "tool_use" && isPostToChatTool(evt.tool)) {
-            this.agentSpokeThisTurn = true;
-          }
-          if (event.type === "completed") {
-            this.completedThisTurn = true;
-            void this.connection.sendHeartbeat();
-          }
-          return this.callbacks.onEvent(event);
+    const bridge = new QueryBridge(this.connection, this.mode, runnerConfig, {
+      onStatusChange: (status) => {
+        if (status === "running" && this._state === "waiting_for_input") {
+          this._state = "running";
+          this.lifecycle.cancelIdleTimer();
         }
+        return this.callbacks.onStatusChange(status);
       },
-      this.config.workspaceDir
-    );
+      onEvent: (event) => {
+        const evt = event;
+        if (evt.type === "tool_use" && isPostToChatTool(evt.tool)) {
+          this.agentSpokeThisTurn = true;
+        }
+        if (event.type === "completed") {
+          this.completedThisTurn = true;
+          void this.connection.sendHeartbeat();
+        }
+        return this.callbacks.onEvent(event);
+      }
+    });
     bridge.isParentTask = this.fullContext?.isParentTask ?? false;
     bridge.onSoftStop = () => {
       process.stderr.write("[conveyor-agent] Soft stop requested (discovery ExitPlanMode)\n");
@@ -10374,15 +10506,16 @@ var SessionRunner = class _SessionRunner {
       }
     });
     this.connection.onPullBranch(({ branch }) => {
-      handlePullBranch(this.config.workspaceDir, branch);
+      void handlePullBranch(this.config.workspaceDir, branch);
     });
     this.connection.onFinalizeSnapshot(() => void this.finalizeSnapshotNow());
   }
   /** Eager finalize snapshot triggered by the reconciler's sleep signal
-   *  (session:finalizeSnapshot). Runs pg_dump + a full capture and uploads it
+   *  (session:finalizeSnapshot). Runs a full workspace capture and uploads it
    *  NOW so the sleep confirms on this snapshot instead of waiting for the
-   *  ~2min periodic flush — and so sidecar DB state (which ONLY finalizeForSleep
-   *  captures via pg_dump) actually lands. Best-effort: on failure the
+   *  ~2min periodic flush. Sidecar DB state is intentionally NOT captured — it
+   *  is no longer durable across sleep/wake (#2623); only the agent's
+   *  /workspace rides the snapshot. Best-effort: on failure the
    *  periodic/shutdown path stays the fallback. No-op on non-v3 pods. */
   async finalizeSnapshotNow() {
     const uploadUrl = process.env.CONVEYOR_SNAPSHOT_UPLOAD_URL;
@@ -10403,9 +10536,7 @@ var SessionRunner = class _SessionRunner {
           }
         }
       });
-      process.stderr.write(
-        "[conveyor-agent] Finalize snapshot (pg_dump) uploaded on sleep signal\n"
-      );
+      process.stderr.write("[conveyor-agent] Finalize snapshot uploaded on sleep signal\n");
     } catch {
     }
   }
@@ -10415,7 +10546,7 @@ var SessionRunner = class _SessionRunner {
       const res = await this.connection.call("refreshGithubToken", {
         sessionId: this.connection.sessionId
       });
-      updateRemoteToken(this.config.workspaceDir, res.token);
+      await updateRemoteToken(this.config.workspaceDir, res.token);
       process.env.GITHUB_TOKEN = res.token;
       process.env.GH_TOKEN = res.token;
       process.stderr.write("[conveyor-agent] Proactively refreshed GitHub token\n");
@@ -10434,7 +10565,7 @@ var SessionRunner = class _SessionRunner {
       });
       if (ctx?.githubBranch && this.fullContext) {
         this.fullContext.githubBranch = ctx.githubBranch;
-        ensureOnTaskBranch(this.config.workspaceDir, ctx.githubBranch);
+        await ensureOnTaskBranch(this.config.workspaceDir, ctx.githubBranch);
       }
     } catch {
       process.stderr.write(
@@ -10444,6 +10575,8 @@ var SessionRunner = class _SessionRunner {
   }
   async setState(status) {
     this._state = status;
+    const loopStatus = status === "idle" ? "idle" : "active";
+    this.loopLag.setStatus(loopStatus);
     await this.connection.emitStatus(status);
     await this.callbacks.onStatusChange(status);
   }
@@ -10452,6 +10585,7 @@ var SessionRunner = class _SessionRunner {
 `);
     this.connection.sendEvent({ type: "shutdown", reason: finalState });
     this.portDiscovery?.stop();
+    this.loopLag.stop();
     this.lifecycle.destroy();
     try {
       await this.queryBridge?.dispose();
@@ -10501,12 +10635,12 @@ var SessionRunner = class _SessionRunner {
 
 // src/setup/config.ts
 import { readFile as readFile5 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join7 } from "path";
 var DEVCONTAINER_PATH = ".devcontainer/conveyor/devcontainer.json";
 var DEVCONTAINER_PORT_DENY_LIST = /* @__PURE__ */ new Set([5432, 6379, 9200]);
 async function loadForwardPorts(workspaceDir) {
   try {
-    const raw = await readFile5(join8(workspaceDir, DEVCONTAINER_PATH), "utf-8");
+    const raw = await readFile5(join7(workspaceDir, DEVCONTAINER_PATH), "utf-8");
     const parsed = JSON.parse(raw);
     const ports = (parsed.forwardPorts ?? []).filter(
       (p) => typeof p === "number" && !DEVCONTAINER_PORT_DENY_LIST.has(p)
@@ -10538,19 +10672,17 @@ function buildSessionPreviewPorts(result) {
 function loadConveyorConfig() {
   const envSetup = process.env.CONVEYOR_SETUP_COMMAND;
   const envStart = process.env.CONVEYOR_START_COMMAND;
-  const envPort = process.env.CONVEYOR_PREVIEW_PORT;
   if (envSetup || envStart) {
     return {
       setupCommand: envSetup,
-      startCommand: envStart,
-      previewPort: envPort ? Number(envPort) : void 0
+      startCommand: envStart
     };
   }
   return null;
 }
 
 // src/setup/commands.ts
-import { spawn, execSync as execSync5 } from "child_process";
+import { spawn, execSync } from "child_process";
 function runSetupCommand(cmd, cwd, onOutput) {
   return new Promise((resolve, reject) => {
     const child = spawn("sh", ["-c", cmd], {
@@ -10579,7 +10711,7 @@ function runSetupCommand(cmd, cwd, onOutput) {
 var AUTH_TOKEN_TIMEOUT_MS = 3e4;
 function runAuthTokenCommand(cmd, userEmail, cwd) {
   try {
-    const output = execSync5(`${cmd} ${JSON.stringify(userEmail)}`, {
+    const output = execSync(`${cmd} ${JSON.stringify(userEmail)}`, {
       cwd,
       timeout: AUTH_TOKEN_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "ignore"],
@@ -10609,10 +10741,10 @@ function runStartCommand(cmd, cwd, onOutput) {
 }
 
 // src/setup/codespace.ts
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync2 } from "child_process";
 function unshallowRepo(workspaceDir) {
   try {
-    execSync6("git fetch --unshallow", {
+    execSync2("git fetch --unshallow", {
       cwd: workspaceDir,
       timeout: 6e4,
       stdio: "ignore"
@@ -10622,10 +10754,10 @@ function unshallowRepo(workspaceDir) {
 }
 
 export {
-  DEFAULT_SONNET_MODEL,
   fetchBootstrap,
   applyBootstrapToEnv,
   AgentConnection,
+  DEFAULT_SONNET_MODEL,
   DEFAULT_LIFECYCLE_CONFIG,
   Lifecycle,
   PtyHarness,
@@ -10637,7 +10769,7 @@ export {
   updateRemoteToken,
   flushPendingChanges,
   pushToOrigin,
-  PlanSync,
+  resolveSessionStart,
   sampleKeyUsage,
   awaitGitReady,
   uploadSnapshotToGcs,
@@ -10655,4 +10787,4 @@ export {
   runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-YGLTLUGA.js.map
+//# sourceMappingURL=chunk-DEMRCBJN.js.map