@gethmy/agent 1.10.8 → 1.11.0

package/dist/cli.js

@@ -385,11 +385,12 @@ var DEFAULT_AGENT_CONFIG, IN_PROGRESS_COLUMN = "In Progress", NEED_REVIEW_LABEL
 var init_types = __esm(() => {
   init_plan_phase();
   DEFAULT_AGENT_CONFIG = {
-    poolSize: 3,
+    poolSize: 6,
     maxTimeout: 1800000,
     pickupColumns: ["To Do"],
     priorityLabels: { urgent: 100, critical: 90, bug: 50 },
     columnBoost: true,
+    runner: "cli",
     completion: {
       createPR: false,
       moveToColumn: "Review",
@@ -424,13 +425,14 @@ var init_types = __esm(() => {
       autoFix: true,
       maxFixAttempts: 1,
       deepReview: false,
+      revertGuard: true,
       devServerBasePort: 4200,
       timeout: 120000,
       failColumn: "To Do"
     },
     review: {
       enabled: true,
-      poolSize: 2,
+      poolSize: 3,
       pickupColumns: ["Review"],
       moveToColumn: "Done",
       failColumn: "To Do",
@@ -562,6 +564,9 @@ function loadDaemonConfig() {
       ...agentOverrides.planning ?? {}
     }
   };
+  if (agent.runner !== "cli" && agent.runner !== "sdk") {
+    agent.runner = "cli";
+  }
   return {
     apiKey,
     apiUrl,
@@ -1209,6 +1214,23 @@ var init_pm = __esm(() => {
 import { execFileSync as execFileSync3, execSync as execSync2 } from "node:child_process";
 import { existsSync as existsSync2, rmSync } from "node:fs";
 import { resolve } from "node:path";
+function fetchBaseBranch(repoRoot, baseBranch, attempts = 3, fetchImpl = (root, branch) => execFileSync3("git", ["fetch", "origin", branch], {
+  cwd: root,
+  stdio: "pipe"
+})) {
+  let lastErr;
+  for (let attempt = 1;attempt <= attempts; attempt++) {
+    try {
+      fetchImpl(repoRoot, baseBranch);
+      return;
+    } catch (err) {
+      lastErr = err;
+      log.warn(TAG5, `fetch origin ${baseBranch} failed (attempt ${attempt}/${attempts})`);
+    }
+  }
+  const detail = lastErr instanceof Error ? lastErr.message : String(lastErr);
+  throw new WorktreeBaseError(`Could not fetch origin/${baseBranch} after ${attempts} attempts — ` + `refusing to build on a stale base. ${detail}`);
+}
 function createWorktree(basePath, baseBranch, branchName) {
   const repoRoot = execFileSync3("git", ["rev-parse", "--show-toplevel"], {
     encoding: "utf-8"
@@ -1224,14 +1246,7 @@ function createWorktree(basePath, baseBranch, branchName) {
       stdio: "pipe"
     });
   } catch {}
-  try {
-    execFileSync3("git", ["fetch", "origin", baseBranch], {
-      cwd: repoRoot,
-      stdio: "pipe"
-    });
-  } catch {
-    log.warn(TAG5, "Failed to fetch latest — continuing with local state");
-  }
+  fetchBaseBranch(repoRoot, baseBranch);
   log.info(TAG5, `Creating worktree: ${worktreeDir} (branch: ${branchName})`);
   try {
     execFileSync3("git", [
@@ -1319,10 +1334,16 @@ function makeBranchName(shortId, title, prefix = "agent-attempts/") {
   const slug = title.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
   return `${prefix}${shortId}-${slug || "task"}`;
 }
-var TAG5 = "worktree";
+var TAG5 = "worktree", WorktreeBaseError;
 var init_worktree = __esm(() => {
   init_log();
   init_pm();
+  WorktreeBaseError = class WorktreeBaseError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "WorktreeBaseError";
+    }
+  };
 });
 
 // src/review-worktree.ts
@@ -2200,41 +2221,91 @@ var init_project_type = __esm(() => {
   _cache = new Map;
 });
 
+// src/revert-guard.ts
+import { execFileSync as execFileSync7 } from "node:child_process";
+function isTestFile(path) {
+  return TEST_FILE.test(path);
+}
+function filterTestFiles(paths) {
+  return paths.filter(isTestFile);
+}
+function refetchBase(worktreePath, baseBranch) {
+  try {
+    execFileSync7("git", ["fetch", "origin", baseBranch], {
+      cwd: worktreePath,
+      stdio: "pipe"
+    });
+  } catch {
+    log.warn(TAG12, "Failed to re-fetch base for revert guard — using last fetch");
+  }
+}
+function listDeletedFilesAgainstBase(worktreePath, baseBranch) {
+  try {
+    const out = execFileSync7("git", ["diff", "--diff-filter=D", "--name-only", `origin/${baseBranch}...HEAD`], { cwd: worktreePath, encoding: "utf-8" });
+    return out.split(`
+`).map((l) => l.trim()).filter((l) => l.length > 0);
+  } catch (err) {
+    log.warn(TAG12, `Failed to list deleted files: ${err instanceof Error ? err.message : err}`);
+    return [];
+  }
+}
+function findDeletedTestFiles(worktreePath, baseBranch) {
+  refetchBase(worktreePath, baseBranch);
+  return filterTestFiles(listDeletedFilesAgainstBase(worktreePath, baseBranch));
+}
+var TAG12 = "revert-guard", TEST_FILE;
+var init_revert_guard = __esm(() => {
+  init_log();
+  TEST_FILE = /(?:^|\/)__tests__\/|\.(?:test|spec)\.[cm]?[jt]sx?$/;
+});
+
 // src/verification.ts
-import { execFileSync as execFileSync7, spawn } from "node:child_process";
+import { execFileSync as execFileSync8, spawn } from "node:child_process";
 async function runVerification(worktreePath, config, workerId) {
   const result = {
     passed: true,
     buildErrors: [],
     lintWarnings: [],
-    reviewFindings: []
+    reviewFindings: [],
+    revertWarnings: []
   };
+  if (config.verification.revertGuard) {
+    log.info(TAG13, `[worker:${workerId}] Checking for reverted merged work...`);
+    const deletedTests = findDeletedTestFiles(worktreePath, config.worktree.baseBranch);
+    if (deletedTests.length > 0) {
+      result.revertWarnings = deletedTests.map((f) => `Branch deletes test file '${f}' relative to current ${config.worktree.baseBranch} — ` + "likely an accidental revert of already-merged work. Restore the test or rebase on current main.");
+      log.warn(TAG13, `[worker:${workerId}] Revert guard tripped: ${deletedTests.length} deleted test file(s)`);
+      result.passed = false;
+    } else {
+      log.info(TAG13, `[worker:${workerId}] Revert guard passed`);
+    }
+  }
   if (config.verification.build) {
-    log.info(TAG12, `[worker:${workerId}] Running build...`);
+    log.info(TAG13, `[worker:${workerId}] Running build...`);
     result.buildErrors = runBuild(worktreePath, config.verification.timeout);
     if (result.buildErrors.length > 0) {
-      log.warn(TAG12, `[worker:${workerId}] Build failed with ${result.buildErrors.length} error(s)`);
+      log.warn(TAG13, `[worker:${workerId}] Build failed with ${result.buildErrors.length} error(s)`);
       result.passed = false;
     } else {
-      log.info(TAG12, `[worker:${workerId}] Build passed`);
+      log.info(TAG13, `[worker:${workerId}] Build passed`);
     }
   }
   if (config.verification.lint) {
-    log.info(TAG12, `[worker:${workerId}] Running lint...`);
+    log.info(TAG13, `[worker:${workerId}] Running lint...`);
     result.lintWarnings = runLint(worktreePath, config.verification.timeout);
     if (result.lintWarnings.length > 0) {
-      log.warn(TAG12, `[worker:${workerId}] Lint found ${result.lintWarnings.length} issue(s)`);
+      log.warn(TAG13, `[worker:${workerId}] Lint found ${result.lintWarnings.length} issue(s)`);
     } else {
-      log.info(TAG12, `[worker:${workerId}] Lint passed`);
+      log.info(TAG13, `[worker:${workerId}] Lint passed`);
     }
   }
   if (config.verification.deepReview) {
-    log.info(TAG12, `[worker:${workerId}] Running deep review...`);
+    log.info(TAG13, `[worker:${workerId}] Running deep review...`);
     result.reviewFindings = await runDeepReview(worktreePath, config, workerId);
     if (result.reviewFindings.length > 0) {
-      log.warn(TAG12, `[worker:${workerId}] Deep review found ${result.reviewFindings.length} finding(s)`);
+      log.warn(TAG13, `[worker:${workerId}] Deep review found ${result.reviewFindings.length} finding(s)`);
     } else {
-      log.info(TAG12, `[worker:${workerId}] Deep review passed`);
+      log.info(TAG13, `[worker:${workerId}] Deep review passed`);
     }
   }
   return result;
@@ -2242,11 +2313,11 @@ async function runVerification(worktreePath, config, workerId) {
 function runBuild(worktreePath, timeout) {
   const command = buildCommand(worktreePath);
   if (!command) {
-    log.warn(TAG12, `No known build toolchain for ${worktreePath} — skipping build`);
+    log.warn(TAG13, `No known build toolchain for ${worktreePath} — skipping build`);
     return [];
   }
   try {
-    execFileSync7(command.cmd, command.args, {
+    execFileSync8(command.cmd, command.args, {
       cwd: worktreePath,
       timeout,
       stdio: "pipe"
@@ -2259,11 +2330,11 @@ function runBuild(worktreePath, timeout) {
 function runLint(worktreePath, timeout) {
   const command = lintCommand(worktreePath);
   if (!command) {
-    log.info(TAG12, `No lint step for detected toolchain in ${worktreePath} — skipping lint`);
+    log.info(TAG13, `No lint step for detected toolchain in ${worktreePath} — skipping lint`);
     return [];
   }
   try {
-    execFileSync7(command.cmd, command.args, {
+    execFileSync8(command.cmd, command.args, {
       cwd: worktreePath,
       timeout,
       stdio: "pipe"
@@ -2275,7 +2346,7 @@ function runLint(worktreePath, timeout) {
 }
 async function runDeepReview(worktreePath, config, workerId) {
   if (!supportsDevServer(worktreePath)) {
-    log.info(TAG12, `[worker:${workerId}] Detected non-web toolchain — skipping deep review`);
+    log.info(TAG13, `[worker:${workerId}] Detected non-web toolchain — skipping deep review`);
     return [];
   }
   const port = config.verification.devServerBasePort + workerId;
@@ -2290,12 +2361,12 @@ async function runDeepReview(worktreePath, config, workerId) {
       await waitForDevServer(devServer, 30000);
       await probeDevServer(port);
     } catch (err) {
-      log.error(TAG12, `Dev server did not become ready: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG13, `Dev server did not become ready: ${err instanceof Error ? err.message : err}`);
       return [];
     }
     let diff = "";
     try {
-      diff = execFileSync7("git", ["diff", `origin/${config.worktree.baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8", timeout: 30000 });
+      diff = execFileSync8("git", ["diff", `origin/${config.worktree.baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8", timeout: 30000 });
     } catch {
       diff = "(unable to retrieve diff)";
     }
@@ -2312,7 +2383,7 @@ async function runDeepReview(worktreePath, config, workerId) {
     ].join(`
 `);
     const leanSources = config.claude.leanSettingSources;
-    const output = execFileSync7("claude", [
+    const output = execFileSync8("claude", [
       "--print",
       "--model",
       "sonnet",
@@ -2329,7 +2400,7 @@ async function runDeepReview(worktreePath, config, workerId) {
     });
     return parseReviewFindings(output);
   } catch (err) {
-    log.error(TAG12, `Deep review failed: ${err instanceof Error ? err.message : err}`);
+    log.error(TAG13, `Deep review failed: ${err instanceof Error ? err.message : err}`);
     return [];
   } finally {
     if (devServer && !devServer.killed) {
@@ -2365,8 +2436,8 @@ function attemptAutoFix(worktreePath, config, errors) {
     "--",
     fixPrompt
   ];
-  log.info(TAG12, "Spawning Claude for auto-fix...");
-  execFileSync7("claude", args, {
+  log.info(TAG13, "Spawning Claude for auto-fix...");
+  execFileSync8("claude", args, {
     cwd: worktreePath,
     timeout: config.verification.timeout,
     stdio: "pipe"
@@ -2379,6 +2450,9 @@ async function reportFindings(client, cardId, result, recovery) {
     const url = recovery.branchUrl ? ` (${recovery.branchUrl})` : "";
     items.push(`Recovery: \`${cmd}\`${url}`);
   }
+  for (const warn of result.revertWarnings) {
+    items.push(`Revert: ${warn}`);
+  }
   for (const err of result.buildErrors) {
     items.push(`Build: ${err}`);
   }
@@ -2396,7 +2470,7 @@ async function reportFindings(client, cardId, result, recovery) {
     try {
       await client.createSubtask(cardId, title);
     } catch (err) {
-      log.error(TAG12, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG13, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
     }
   }));
   if (overflow > 0) {
@@ -2404,7 +2478,7 @@ async function reportFindings(client, cardId, result, recovery) {
       await client.createSubtask(cardId, `...and ${overflow} more issues`);
     } catch {}
   }
-  log.info(TAG12, `Reported ${Math.min(items.length, maxSubtasks)} finding(s) as subtasks on card ${cardId}`);
+  log.info(TAG13, `Reported ${Math.min(items.length, maxSubtasks)} finding(s) as subtasks on card ${cardId}`);
 }
 function parseErrorOutput(err) {
   const stderr = err?.stderr?.toString() ?? "";
@@ -2488,11 +2562,12 @@ async function probeDevServer(port, timeoutMs = 5000) {
     clearTimeout(timer);
   }
 }
-var TAG12 = "verification", DevServerReadinessError;
+var TAG13 = "verification", DevServerReadinessError;
 var init_verification = __esm(() => {
   init_log();
   init_pm();
   init_project_type();
+  init_revert_guard();
   DevServerReadinessError = class DevServerReadinessError extends Error {
     constructor(message) {
       super(message);
@@ -2502,7 +2577,7 @@ var init_verification = __esm(() => {
 });
 
 // src/completion.ts
-import { execFileSync as execFileSync8 } from "node:child_process";
+import { execFileSync as execFileSync9 } from "node:child_process";
 function formatTokenCount(tokens) {
   if (tokens >= 1e6)
     return `${(tokens / 1e6).toFixed(1)}M`;
@@ -2510,6 +2585,13 @@ function formatTokenCount(tokens) {
     return `${(tokens / 1000).toFixed(1)}k`;
   return String(tokens);
 }
+function describeNoCommitFailure(numTurns, maxTurns) {
+  const maxTurnsExhausted = maxTurns > 0 && numTurns >= maxTurns;
+  return {
+    maxTurnsExhausted,
+    failureSummary: maxTurnsExhausted ? `Agent exhausted its ${maxTurns}-turn budget without committing any changes` : "Agent finished without making any changes to commit"
+  };
+}
 function buildTokenPayload(stats) {
   if (!stats?.cost)
     return {};
@@ -2528,26 +2610,30 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
     passed: true,
     buildErrors: [],
     lintWarnings: [],
-    reviewFindings: []
+    reviewFindings: [],
+    revertWarnings: []
   };
   const hasCommits = checkHasCommits(worktreePath, config.worktree.baseBranch);
   if (!hasCommits) {
-    log.warn(TAG13, `No commits on branch ${branchName} — skipping completion`);
+    const { maxTurnsExhausted, failureSummary } = describeNoCommitFailure(sessionStats?.cost?.numTurns ?? 0, config.claude.maxTurns);
+    log.warn(TAG14, `No commits on branch ${branchName} — ${failureSummary}; counting as a failed attempt`);
+    await moveCardToColumn(client, card, config.pickupColumns[0] ?? "To Do");
     await client.endAgentSession(card.id, {
-      status: "completed",
-      progressPercent: 100,
+      status: "failed",
+      failureReason: maxTurnsExhausted ? "timeout" : "other",
+      failureSummary,
       ...buildTokenPayload(sessionStats)
     });
     cleanupWorktree(worktreePath, branchName);
-    return true;
+    return false;
   }
-  log.info(TAG13, `Pushing branch ${branchName} (pre-verify)...`);
+  log.info(TAG14, `Pushing branch ${branchName} (pre-verify)...`);
   let lastPushedSha = null;
   try {
     pushBranch(branchName, worktreePath);
     lastPushedSha = readHeadSha(worktreePath);
   } catch (err) {
-    log.error(TAG13, `pre-verify push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
+    log.error(TAG14, `pre-verify push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
   }
   const recoveryUrl = lastPushedSha ? getBranchWebUrl(branchName, worktreePath) : null;
   if (config.verification.enabled) {
@@ -2562,7 +2648,7 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
     let autoFixAttempts = 0;
     if (!result.passed && config.verification.autoFix) {
       for (let attempt = 0;attempt < config.verification.maxFixAttempts; attempt++) {
-        log.info(TAG13, `Auto-fix attempt ${attempt + 1}/${config.verification.maxFixAttempts}`);
+        log.info(TAG14, `Auto-fix attempt ${attempt + 1}/${config.verification.maxFixAttempts}`);
         await client.updateAgentProgress(card.id, {
           agentIdentifier: agentIdentifier(workerId),
           agentName: AGENT_NAME,
@@ -2575,14 +2661,14 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
         result = await runVerification(worktreePath, config, workerId);
         autoFixAttempts = attempt + 1;
         if (result.passed) {
-          log.info(TAG13, `Auto-fix succeeded on attempt ${attempt + 1}`);
+          log.info(TAG14, `Auto-fix succeeded on attempt ${attempt + 1}`);
           const sha = readHeadSha(worktreePath);
           if (sha && sha !== lastPushedSha) {
             try {
               pushBranch(branchName, worktreePath);
               lastPushedSha = sha;
             } catch (err) {
-              log.warn(TAG13, `post-fix push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
+              log.warn(TAG14, `post-fix push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
             }
           }
           break;
@@ -2591,14 +2677,14 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
     }
     verificationResult = result;
     if (!result.passed) {
-      log.warn(TAG13, `Verification failed for #${card.short_id} — reporting findings`);
+      log.warn(TAG14, `Verification failed for #${card.short_id} — reporting findings`);
       const failSha = readHeadSha(worktreePath);
       if (failSha && failSha !== lastPushedSha) {
         try {
           pushBranch(branchName, worktreePath);
           lastPushedSha = failSha;
         } catch (err) {
-          log.warn(TAG13, `post-fail push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
+          log.warn(TAG14, `post-fail push failed for ${branchName}: ${err instanceof Error ? err.message : err}`);
         }
       }
       const failureSummary = buildVerificationFailureSummary(result, autoFixAttempts);
@@ -2609,7 +2695,7 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
           recoveryBranch: branchName
         });
       } catch (err) {
-        log.debug(TAG13, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
+        log.debug(TAG14, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
       }
       await reportFindings(client, card.id, result, lastPushedSha ? { branchName, branchUrl: recoveryUrl } : null);
       await moveCardToColumn(client, card, config.verification.failColumn);
@@ -2623,7 +2709,7 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
       cleanupWorktree(worktreePath, branchName);
       return false;
     }
-    log.info(TAG13, `Verification passed for #${card.short_id}`);
+    log.info(TAG14, `Verification passed for #${card.short_id}`);
   }
   let prUrl = null;
   if (config.completion.createPR) {
@@ -2636,7 +2722,7 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
       try {
         await onMovedToCompletion(card);
       } catch (err) {
-        log.warn(TAG13, `successor promotion failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log.warn(TAG14, `successor promotion failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -2670,11 +2756,14 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
     });
   }
   cleanupWorktree(worktreePath, branchName);
-  log.info(TAG13, `Completion done for #${card.short_id}${prUrl ? ` — PR: ${prUrl}` : ""}`);
+  log.info(TAG14, `Completion done for #${card.short_id}${prUrl ? ` — PR: ${prUrl}` : ""}`);
   return true;
 }
 function buildVerificationFailureSummary(result, autoFixAttempts) {
   const counts = [];
+  if (result.revertWarnings.length > 0) {
+    counts.push(`${result.revertWarnings.length} reverted test(s)`);
+  }
   if (result.buildErrors.length > 0) {
     counts.push(`${result.buildErrors.length} build error(s)`);
   }
@@ -2690,7 +2779,7 @@ function buildVerificationFailureSummary(result, autoFixAttempts) {
 }
 function readHeadSha(worktreePath) {
   try {
-    return execFileSync8("git", ["rev-parse", "HEAD"], {
+    return execFileSync9("git", ["rev-parse", "HEAD"], {
       cwd: worktreePath,
       encoding: "utf-8"
     }).trim();
@@ -2700,7 +2789,7 @@ function readHeadSha(worktreePath) {
 }
 function checkHasCommits(worktreePath, baseBranch) {
   try {
-    const count = execFileSync8("git", ["rev-list", "--count", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
+    const count = execFileSync9("git", ["rev-list", "--count", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
     return parseInt(count, 10) > 0;
   } catch {
     return false;
@@ -2709,7 +2798,7 @@ function checkHasCommits(worktreePath, baseBranch) {
 async function postSummary(client, card, branchName, worktreePath, prUrl, baseBranch, sessionStats) {
   let commitLog = "";
   try {
-    commitLog = execFileSync8("git", ["log", "--oneline", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
+    commitLog = execFileSync9("git", ["log", "--oneline", `origin/${baseBranch}..HEAD`], { cwd: worktreePath, encoding: "utf-8" }).trim();
   } catch {}
   const SUMMARY_MARKER = `---
 **Agent completed**`;
@@ -2754,12 +2843,12 @@ ${commitLog}
       description: baseDesc + parts.join(`
 `)
     });
-    log.info(TAG13, `Posted completion summary to #${card.short_id}`);
+    log.info(TAG14, `Posted completion summary to #${card.short_id}`);
   } catch (err) {
-    log.error(TAG13, `Failed to post summary: ${err instanceof Error ? err.message : err}`);
+    log.error(TAG14, `Failed to post summary: ${err instanceof Error ? err.message : err}`);
   }
 }
-var TAG13 = "completion";
+var TAG14 = "completion";
 var init_completion = __esm(() => {
   init_board_helpers();
   init_episode_writer();
@@ -2799,7 +2888,21 @@ function signalGroup(proc, signal) {
   } catch (err) {
     const code = err.code;
     if (code !== "ESRCH") {
-      log.warn(TAG14, `signal ${signal} to pgid ${proc.pid} failed: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG15, `signal ${signal} to pgid ${proc.pid} failed: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+}
+function reapGroup(pgid) {
+  if (!pgid || pgid <= 1 || pgid === process.pid)
+    return;
+  if (process.platform === "win32")
+    return;
+  try {
+    process.kill(-pgid, "SIGKILL");
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ESRCH") {
+      log.warn(TAG15, `reapGroup(${pgid}) failed: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
@@ -2824,7 +2927,7 @@ async function terminateGroup(proc, opts) {
     return;
   signalGroup(proc, "SIGKILL");
 }
-var TAG14 = "pgroup";
+var TAG15 = "pgroup";
 var init_process_group = __esm(() => {
   init_log();
 });
@@ -2854,8 +2957,8 @@ class ProgressTracker {
   filesEdited = new Set;
   filesRead = new Set;
   lastCost = null;
-  logBuffer = [];
-  sessionId = null;
+  runEventSink = null;
+  lastEmittedProgress = -1;
   lastAssistantText = "";
   assistantTextBlocks = [];
   constructor(client, cardId, workerId, subtasks, initialPhase = "exploring") {
@@ -2868,32 +2971,15 @@ class ProgressTracker {
     this.phase = initialPhase;
     this.progress = PHASES[initialPhase].min;
   }
-  setSessionId(id) {
-    this.sessionId = id;
+  setRunEventSink(sink) {
+    this.runEventSink = sink;
   }
   attach(parser) {
     parser.on("tool_start", (name, input) => {
       this.onToolStart(name, input);
-      const desc = this.describeToolAction(name, input);
-      if (desc) {
-        this.pushLogEntry({
-          phase: this.phase,
-          eventType: "tool_start",
-          toolName: name,
-          description: desc,
-          metadata: this.extractToolMetadata(name, input)
-        });
-      }
     });
     parser.on("tool_end", (name, _id, content) => {
       this.onToolEnd(name, content);
-      this.pushLogEntry({
-        phase: this.phase,
-        eventType: "tool_end",
-        toolName: name,
-        description: `Completed: ${name}`,
-        metadata: {}
-      });
     });
     parser.on("text", (content) => {
       this.onText(content);
@@ -2903,6 +2989,37 @@ class ProgressTracker {
     });
     this.startHeartbeat();
   }
+  ingest(draft) {
+    switch (draft.kind) {
+      case "run_started":
+        this.startHeartbeat();
+        break;
+      case "tool_started":
+        this.onToolStart(draft.payload.toolName, draft.payload.input);
+        break;
+      case "tool_ended":
+        this.onToolEnd(draft.payload.toolName, draft.payload.output);
+        break;
+      case "assistant_text":
+        this.onText(draft.payload.text);
+        break;
+      case "cost_updated": {
+        const p = draft.payload;
+        this.lastCost = {
+          totalCostUsd: p.totalCostUsd,
+          totalInputTokens: p.inputTokens,
+          totalOutputTokens: p.outputTokens,
+          totalCacheCreationInputTokens: p.cacheCreationInputTokens,
+          totalCacheReadInputTokens: p.cacheReadInputTokens,
+          durationMs: p.durationMs ?? 0,
+          durationApiMs: 0,
+          numTurns: p.numTurns,
+          modelName: p.modelName
+        };
+        break;
+      }
+    }
+  }
   stop() {
     this.stopped = true;
     if (this.pendingUpdate) {
@@ -2927,7 +3044,7 @@ class ProgressTracker {
   }
   onToolStart(name, input) {
     this.toolCallCount++;
-    log.debug(TAG15, `Tool: ${name} (count: ${this.toolCallCount}, phase: ${this.phase})`);
+    log.debug(TAG16, `Tool: ${name} (count: ${this.toolCallCount}, phase: ${this.phase})`);
     const filePath = this.extractString(input, "file_path");
     if (filePath) {
       if (EDIT_TOOLS.has(name)) {
@@ -2998,17 +3115,12 @@ class ProgressTracker {
   transitionTo(newPhase) {
     if (PHASE_ORDER[newPhase] <= PHASE_ORDER[this.phase])
       return;
-    log.info(TAG15, `Phase: ${this.phase} → ${newPhase}`);
+    log.info(TAG16, `Phase: ${this.phase} → ${newPhase}`);
+    const previousPhase = this.phase;
+    this.runEventSink?.recordPhaseChanged(newPhase, previousPhase);
     this.phase = newPhase;
     this.progress = Math.max(this.progress, PHASES[newPhase].min);
     this.lastAction = "";
-    this.pushLogEntry({
-      phase: newPhase,
-      eventType: "phase_change",
-      toolName: null,
-      description: `Entering ${newPhase} phase`,
-      metadata: {}
-    });
     this.scheduleUpdate(PHASES[newPhase].label);
   }
   incrementProgress() {
@@ -3097,7 +3209,7 @@ class ProgressTracker {
   }
   sendUpdate(currentTask) {
     this.lastUpdateAt = Date.now();
-    log.debug(TAG15, `Progress: ${this.progress}% — ${currentTask}`);
+    log.debug(TAG16, `Progress: ${this.progress}% — ${currentTask}`);
     this.client.updateAgentProgress(this.cardId, {
       agentIdentifier: agentIdentifier(this.workerId),
       agentName: AGENT_NAME,
@@ -3114,9 +3226,17 @@ class ProgressTracker {
       modelName: this.lastCost?.modelName,
       numTurns: this.lastCost?.numTurns ?? 0
     }).catch((err) => {
-      log.warn(TAG15, `Failed to send progress update: ${err}`);
+      log.warn(TAG16, `Failed to send progress update: ${err}`);
     });
-    this.flushActivityLog();
+    if (this.runEventSink && this.progress !== this.lastEmittedProgress) {
+      this.lastEmittedProgress = this.progress;
+      this.runEventSink.recordProgress({
+        progressPercent: this.progress,
+        currentTask: truncate(currentTask, MAX_TASK_LENGTH),
+        phase: this.phase,
+        filesChanged: this.filesEdited.size
+      });
+    }
   }
   startHeartbeat() {
     if (this.heartbeatTimer) {
@@ -3130,55 +3250,6 @@ class ProgressTracker {
       }
     }, HEARTBEAT_MS);
   }
-  flushFinal() {
-    this.flushActivityLog();
-  }
-  pushLogEntry(entry) {
-    this.logBuffer.push({
-      ...entry,
-      createdAt: new Date().toISOString()
-    });
-    if (this.logBuffer.length > MAX_LOG_BUFFER) {
-      this.logBuffer.shift();
-    }
-  }
-  flushActivityLog() {
-    if (!this.sessionId || this.logBuffer.length === 0)
-      return;
-    const raw = [...this.logBuffer];
-    this.logBuffer = [];
-    this.client.flushActivityLog(this.cardId, {
-      sessionId: this.sessionId,
-      entries: raw.map((e) => ({
-        ...e,
-        phase: e.phase ?? undefined,
-        toolName: e.toolName ?? undefined
-      }))
-    }).catch((err) => {
-      log.warn(TAG15, `Failed to flush activity log: ${err}`);
-      this.logBuffer.unshift(...raw);
-      if (this.logBuffer.length > MAX_LOG_BUFFER) {
-        this.logBuffer.length = MAX_LOG_BUFFER;
-      }
-    });
-  }
-  extractToolMetadata(_name, input) {
-    const meta = {};
-    const fp = this.extractString(input, "file_path");
-    if (fp)
-      meta.file_path = fp;
-    const cmd = this.extractString(input, "command");
-    if (cmd)
-      meta.command = cmd.split(`
-`)[0].slice(0, 200);
-    const pattern = this.extractString(input, "pattern");
-    if (pattern)
-      meta.pattern = pattern;
-    const desc = this.extractString(input, "description");
-    if (desc)
-      meta.description = desc;
-    return meta;
-  }
   extractString(input, key) {
     if (typeof input === "object" && input !== null && key in input) {
       return String(input[key]);
@@ -3186,7 +3257,7 @@ class ProgressTracker {
     return null;
   }
 }
-var TAG15 = "progress-tracker", THROTTLE_MS = 5000, HEARTBEAT_MS = 60000, MAX_TASK_LENGTH = 120, MAX_LOG_BUFFER = 500, MAX_TEXT_BLOCKS = 40, SENTENCE_SPLIT, ACTION_PREFIX, GIT_COMMIT_RE, BUILD_CMD_RE, PHASES, PHASE_ORDER, EDIT_TOOLS, FILE_TOOL_VERBS;
+var TAG16 = "progress-tracker", THROTTLE_MS = 5000, HEARTBEAT_MS = 60000, MAX_TASK_LENGTH = 120, MAX_TEXT_BLOCKS = 40, SENTENCE_SPLIT, ACTION_PREFIX, GIT_COMMIT_RE, BUILD_CMD_RE, PHASES, PHASE_ORDER, EDIT_TOOLS, FILE_TOOL_VERBS;
 var init_progress_tracker = __esm(() => {
   init_log();
   init_types();
@@ -3222,6 +3293,41 @@ var init_progress_tracker = __esm(() => {
 
 // src/review-completion.ts
 import { readFileSync as readFileSync2, statSync } from "node:fs";
+function clampSubtaskTitle(title) {
+  return title.length > MAX_SUBTASK_TITLE ? `${title.slice(0, MAX_SUBTASK_TITLE - 3)}...` : title;
+}
+function renderFindingBlock(f) {
+  const locationLine = f.location ? `
+Location: ${f.location}` : "";
+  return `**[${f.severity}] ${f.title}**
+${f.description}${locationLine}`;
+}
+function buildFindingComments(findings) {
+  const header = `**Review findings — ${findings.length} blocking issue(s) to resolve.**`;
+  const sep = `
+
+`;
+  const bodies = [];
+  let current = header;
+  for (const f of findings) {
+    let block = renderFindingBlock(f);
+    const maxBlock = COMMENT_BODY_BUDGET - header.length - sep.length;
+    if (block.length > maxBlock) {
+      const suffix = `
+…[truncated]`;
+      block = `${block.slice(0, Math.max(0, maxBlock - suffix.length))}${suffix}`;
+    }
+    if (current.length + sep.length + block.length > COMMENT_BODY_BUDGET) {
+      bodies.push(current);
+      current = `${header}${sep}${block}`;
+    } else {
+      current = `${current}${sep}${block}`;
+    }
+  }
+  if (current.length > header.length)
+    bodies.push(current);
+  return bodies;
+}
 function tailRunLog(path, bytes = RUN_LOG_TAIL_BYTES) {
   try {
     const size = statSync(path).size;
@@ -3261,7 +3367,7 @@ function parseReviewOutput(stdout) {
     try {
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && "verdict" in parsed) {
-        log.debug(TAG16, "Parsed review output from fenced JSON block");
+        log.debug(TAG17, "Parsed review output from fenced JSON block");
         return extractResult(parsed);
       }
     } catch {}
@@ -3287,21 +3393,21 @@ function parseReviewOutput(stdout) {
     try {
       const parsed = JSON.parse(candidates[i]);
       if (parsed && typeof parsed === "object" && "verdict" in parsed) {
-        log.debug(TAG16, "Parsed review output from raw JSON object");
+        log.debug(TAG17, "Parsed review output from raw JSON object");
         return extractResult(parsed);
       }
     } catch {}
   }
   const verdictMatch = stdout.match(/"verdict"\s*:\s*"(approved|rejected)"/i);
   if (verdictMatch) {
-    log.warn(TAG16, `Parsed verdict via regex fallback — findings lost (${verdictMatch[1]})`);
+    log.warn(TAG17, `Parsed verdict via regex fallback — findings lost (${verdictMatch[1]})`);
     return {
       verdict: verdictMatch[1].toLowerCase(),
       summary: "Parsed via regex fallback — original JSON was malformed. Check run log.",
       findings: []
     };
   }
-  log.warn(TAG16, "Failed to parse review JSON output — returning error verdict (card stays in Review)");
+  log.warn(TAG17, "Failed to parse review JSON output — returning error verdict (card stays in Review)");
   return {
     verdict: "error",
     summary: stdout.slice(0, 500),
@@ -3334,7 +3440,7 @@ async function postReviewComment(client, card, commentType, body) {
   try {
     await client.addComment(card.id, body, { commentType });
   } catch (err) {
-    log.error(TAG16, `Failed to post review comment to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log.error(TAG17, `Failed to post review comment to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
 }
 async function runReviewCompletion(client, card, result, config, worktreePath, branchName, sessionStats, runLogPath, workspaceId, agentSessionId, stateStore) {
@@ -3348,11 +3454,11 @@ async function runReviewCompletion(client, card, result, config, worktreePath, b
   const currentCycle = getReviewCycle(freshDesc) + 1;
   const maxCycles = config.review.maxReviewCycles;
   if (result.verdict === "error") {
-    log.warn(TAG16, `#${card.short_id} review output unparseable — labelling "${NEED_REVIEW_LABEL}" for manual inspection`);
+    log.warn(TAG17, `#${card.short_id} review output unparseable — labelling "${NEED_REVIEW_LABEL}" for manual inspection`);
     try {
       await addLabelByName(client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
     } catch (err) {
-      log.warn(TAG16, `Failed to add "${NEED_REVIEW_LABEL}" label: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG17, `Failed to add "${NEED_REVIEW_LABEL}" label: ${err instanceof Error ? err.message : err}`);
     }
     if (config.review.postFindings) {
       const rawTail = runLogPath ? tailRunLog(runLogPath) : null;
@@ -3395,7 +3501,7 @@ ${runLogTail}
           renameRemoteBranch(branchName, newRef, worktreePath);
           approvedBranch = newRef;
         } catch (err) {
-          log.warn(TAG16, `Branch rename failed (continuing on ${branchName}): ${err instanceof Error ? err.message : err}`);
+          log.warn(TAG17, `Branch rename failed (continuing on ${branchName}): ${err instanceof Error ? err.message : err}`);
         }
       }
       if (config.review.createPR && approvedBranch) {
@@ -3404,6 +3510,21 @@ ${runLogTail}
       }
     }
     await addLabelByName(client, card, config.review.approvedLabel, config.review.approvedLabelColor);
+    if (prUrl) {
+      try {
+        const { card: latest } = await client.getCard(card.id);
+        const desc = latest.description || "";
+        if (!extractPrUrl(desc)) {
+          const separator = desc ? `
+` : "";
+          await client.updateCard(card.id, {
+            description: `${desc}${separator}PR: ${prUrl}`
+          });
+        }
+      } catch (err) {
+        log.warn(TAG17, `Failed to persist PR URL to #${card.short_id} description: ${err instanceof Error ? err.message : err}`);
+      }
+    }
     if (config.review.postFindings) {
       const scopeLine = result.scopeCheck ? `Scope: ${result.scopeCheck.status}${result.scopeCheck.notes ? ` — ${result.scopeCheck.notes}` : ""}` : "";
       const body = [
@@ -3422,14 +3543,14 @@ ${runLogTail}
       progressPercent: 100,
       ...buildTokenPayload(sessionStats)
     });
-    log.info(TAG16, `#${card.short_id} approved${prUrl ? ` — PR: ${prUrl}` : ""} — labeled "${config.review.approvedLabel}"`);
+    log.info(TAG17, `#${card.short_id} approved${prUrl ? ` — PR: ${prUrl}` : ""} — labeled "${config.review.approvedLabel}"`);
   } else {
     const criticalFindings = result.findings.filter((f) => f.severity === "critical").slice(0, MAX_FINDINGS);
     const majorFindings = result.findings.filter((f) => f.severity === "major").slice(0, MAX_FINDINGS);
     const linkedFindings = [...criticalFindings, ...majorFindings];
     const minorFindings = result.findings.filter((f) => f.severity === "minor").slice(0, MAX_FINDINGS);
     if (currentCycle >= maxCycles) {
-      log.warn(TAG16, `#${card.short_id} reached max review cycles (${maxCycles}), moving to Done with note`);
+      log.warn(TAG17, `#${card.short_id} reached max review cycles (${maxCycles}), moving to Done with note`);
       await moveCardToColumn(client, card, config.review.moveToColumn);
       const body = [
         "**Review — needs human review.**",
@@ -3467,28 +3588,21 @@ ${runLogTail}
     if (config.review.postFindings) {
       await Promise.all(linkedFindings.map(async (finding) => {
         try {
-          const locationLine = finding.location ? `
-**Location:** ${finding.location}` : "";
-          const newCard = await client.createCard(card.project_id, {
-            title: `[Review: ${finding.severity}] ${finding.title}`,
-            description: `Found during review of #${card.short_id} (${finding.severity}):
-
-${finding.description}${locationLine}`
-          });
-          const newCardId = newCard?.card?.id;
-          if (newCardId) {
-            await client.addLinkToCard(card.id, newCardId, "relates_to");
-          }
+          await client.createSubtask(card.id, clampSubtaskTitle(`[${finding.severity}] ${finding.title}`));
         } catch (err) {
-          log.error(TAG16, `Failed to create finding card: ${err instanceof Error ? err.message : err}`);
+          log.error(TAG17, `Failed to create finding subtask: ${err instanceof Error ? err.message : err}`);
         }
       }));
+      if (linkedFindings.length > 0) {
+        for (const body2 of buildFindingComments(linkedFindings)) {
+          await postReviewComment(client, card, "finding", body2);
+        }
+      }
       await Promise.all(minorFindings.map(async (finding) => {
         try {
-          const title = finding.title.length > 120 ? `${finding.title.slice(0, 117)}...` : finding.title;
-          await client.createSubtask(card.id, title);
+          await client.createSubtask(card.id, clampSubtaskTitle(finding.title));
         } catch (err) {
-          log.error(TAG16, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
+          log.error(TAG17, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
         }
       }));
       const baseDesc = stripReviewSummary(freshDesc);
@@ -3496,7 +3610,7 @@ ${finding.description}${locationLine}`
       try {
         await client.updateCard(card.id, { description: updatedDesc });
       } catch (err) {
-        log.error(TAG16, `Failed to update review cycle marker: ${err instanceof Error ? err.message : err}`);
+        log.error(TAG17, `Failed to update review cycle marker: ${err instanceof Error ? err.message : err}`);
       }
       const scopeLine = result.scopeCheck ? `Scope: ${result.scopeCheck.status}${result.scopeCheck.notes ? ` — ${result.scopeCheck.notes}` : ""}` : "";
       const body = [
@@ -3512,9 +3626,9 @@ ${finding.description}${locationLine}`
     if (config.planning.enabled && card.plan_id) {
       try {
         await client.updateCard(card.id, { needsPlanRefresh: true });
-        log.info(TAG16, `#${card.short_id} flagged needs_plan_refresh after rejected review`);
+        log.info(TAG17, `#${card.short_id} flagged needs_plan_refresh after rejected review`);
       } catch (err) {
-        log.warn(TAG16, `Failed to flag needs_plan_refresh for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log.warn(TAG17, `Failed to flag needs_plan_refresh for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
     await moveCardToColumn(client, card, config.review.failColumn);
@@ -3528,10 +3642,10 @@ ${finding.description}${locationLine}`
         recoveryBranch
       });
     } catch (err) {
-      log.debug(TAG16, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
+      log.debug(TAG17, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
     }
     if (recoveryBranch) {
-      log.info(TAG16, `#${card.short_id} recovery branch ${recoveryBranch}${recoveryUrl ? ` (${recoveryUrl})` : ""}`);
+      log.info(TAG17, `#${card.short_id} recovery branch ${recoveryBranch}${recoveryUrl ? ` (${recoveryUrl})` : ""}`);
     }
     await client.endAgentSession(card.id, {
       status: "failed",
@@ -3540,7 +3654,7 @@ ${finding.description}${locationLine}`
       recoveryBranch,
       ...buildTokenPayload(sessionStats)
     });
-    log.info(TAG16, `#${card.short_id} rejected (cycle ${currentCycle}/${maxCycles}) — moved to "${config.review.failColumn}"`);
+    log.info(TAG17, `#${card.short_id} rejected (cycle ${currentCycle}/${maxCycles}) — moved to "${config.review.failColumn}"`);
   }
   if (workspaceId && (result.verdict === "approved" || result.verdict === "rejected")) {
     const originalEpisodeId = await findLatestImplementEpisode(client, workspaceId, card.project_id, card.short_id);
@@ -3562,7 +3676,7 @@ ${finding.description}${locationLine}`
     cleanupWorktree(worktreePath, branchName);
   }
 }
-var TAG16 = "review-completion", MAX_FINDINGS = 10, REVIEW_MARKER = `---
+var TAG17 = "review-completion", MAX_FINDINGS = 10, MAX_SUBTASK_TITLE = 120, COMMENT_BODY_BUDGET = 9500, REVIEW_MARKER = `---
 **Review:`, RUN_LOG_TAIL_BYTES = 2048;
 var init_review_completion = __esm(() => {
   init_board_helpers();
@@ -3573,7 +3687,6 @@ var init_review_completion = __esm(() => {
   init_types();
   init_worktree();
 });
-
 // ../harmony-shared/dist/cardLinks.js
 var init_cardLinks = () => {};
 // ../harmony-shared/dist/classification.js
@@ -3975,7 +4088,7 @@ class StateStore {
       const raw = readFileSync3(this.path, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed?.version !== SCHEMA_VERSION) {
-        log.warn(TAG17, `state file has version ${parsed?.version}, expected ${SCHEMA_VERSION} — starting fresh`);
+        log.warn(TAG18, `state file has version ${parsed?.version}, expected ${SCHEMA_VERSION} — starting fresh`);
         return emptyState();
       }
       return {
@@ -3988,7 +4101,7 @@ class StateStore {
         daily: parsed.daily ?? []
       };
     } catch (err) {
-      log.error(TAG17, `failed to read state file: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG18, `failed to read state file: ${err instanceof Error ? err.message : err}`);
       return emptyState();
     }
   }
@@ -4144,7 +4257,7 @@ class StateStore {
     return this.state.daily.find((d) => d.date === key)?.costCents ?? 0;
   }
 }
-var TAG17 = "state-store", SCHEMA_VERSION = 1;
+var TAG18 = "state-store", SCHEMA_VERSION = 1;
 var init_state_store = __esm(() => {
   init_log();
 });
@@ -4171,7 +4284,7 @@ function normalizeToolResultContent(raw) {
     return String(raw);
   }
 }
-var TAG18 = "stream-parser", StreamParser;
+var TAG19 = "stream-parser", StreamParser;
 var init_stream_parser = __esm(() => {
   init_log();
   StreamParser = class StreamParser extends EventEmitter {
@@ -4180,6 +4293,10 @@ var init_stream_parser = __esm(() => {
     toolNames = new Map;
     hasEmittedText = false;
     observedModel;
+    capturedSessionId;
+    get sessionId() {
+      return this.capturedSessionId;
+    }
     attach(stream) {
       if (this.attached) {
         throw new Error("StreamParser already attached to a stream");
@@ -4215,14 +4332,14 @@ var init_stream_parser = __esm(() => {
       try {
         msg = JSON.parse(line);
       } catch {
-        log.debug(TAG18, `Non-JSON line: ${line.slice(0, 100)}`);
+        log.debug(TAG19, `Non-JSON line: ${line.slice(0, 100)}`);
         return;
       }
       try {
         this.handleMessage(msg);
       } catch (err) {
         const errMsg = err instanceof Error ? err.message : String(err);
-        log.warn(TAG18, `Error handling stream event: ${errMsg}`);
+        log.warn(TAG19, `Error handling stream event: ${errMsg}`);
         this.emit("parse_error", errMsg);
       }
     }
@@ -4234,6 +4351,9 @@ var init_stream_parser = __esm(() => {
           this.observedModel = msg.message.model;
         }
       }
+      if (!this.capturedSessionId && typeof msg.session_id === "string") {
+        this.capturedSessionId = msg.session_id;
+      }
       switch (msg.type) {
         case "assistant": {
           const blocks = msg.message?.content;
@@ -4244,10 +4364,11 @@ var init_stream_parser = __esm(() => {
               this.emit("text", block.text);
               this.hasEmittedText = true;
             } else if (block.type === "tool_use" && typeof block.name === "string") {
-              if (typeof block.id === "string") {
-                this.toolNames.set(block.id, block.name);
+              const toolUseId = typeof block.id === "string" ? block.id : undefined;
+              if (toolUseId) {
+                this.toolNames.set(toolUseId, block.name);
               }
-              this.emit("tool_start", block.name, block.input);
+              this.emit("tool_start", block.name, block.input, toolUseId);
             }
           }
           break;
@@ -4304,7 +4425,7 @@ async function withRetry(step, cardShortId, op, attempts, backoffMs) {
       const msg2 = err instanceof Error ? err.message : String(err);
       if (i < attempts - 1) {
         const wait = backoffMs * 2 ** i;
-        log.warn(TAG19, `${step} failed for #${cardShortId} (attempt ${i + 1}/${attempts}): ${msg2} — retrying in ${wait}ms`);
+        log.warn(TAG20, `${step} failed for #${cardShortId} (attempt ${i + 1}/${attempts}): ${msg2} — retrying in ${wait}ms`);
         await new Promise((r) => setTimeout(r, wait));
       }
     }
@@ -4326,10 +4447,10 @@ async function runTransition(client, card, plan, opts = {}) {
       if (opts.strictColumn) {
         throw new TransitionError("move", 1, msg);
       }
-      log.warn(TAG19, `#${shortId}: ${msg} — skipping move`);
+      log.warn(TAG20, `#${shortId}: ${msg} — skipping move`);
     } else if (card.column_id !== target.id) {
       await withRetry("move", shortId, () => client.moveCard(card.id, target.id), attempts, backoffMs);
-      log.info(TAG19, `#${shortId} → "${target.name}"`);
+      log.info(TAG20, `#${shortId} → "${target.name}"`);
       card.column_id = target.id;
     }
   }
@@ -4342,7 +4463,7 @@ async function runTransition(client, card, plan, opts = {}) {
         continue;
       await withRetry("addLabel", shortId, () => client.addLabelToCard(card.id, labelId), attempts, backoffMs);
       existing.add(labelId);
-      log.info(TAG19, `#${shortId} +label "${name}"`);
+      log.info(TAG20, `#${shortId} +label "${name}"`);
     }
     card.labelIds = Array.from(existing);
   }
@@ -4354,17 +4475,17 @@ async function runTransition(client, card, plan, opts = {}) {
         continue;
       await withRetry("removeLabel", shortId, () => client.removeLabelFromCard(card.id, match.id), attempts, backoffMs);
       existing.delete(match.id);
-      log.info(TAG19, `#${shortId} -label "${name}"`);
+      log.info(TAG20, `#${shortId} -label "${name}"`);
     }
     card.labelIds = Array.from(existing);
   }
   if (plan.updateCard) {
     await withRetry("updateCard", shortId, () => client.updateCard(card.id, plan.updateCard), attempts, backoffMs);
-    log.info(TAG19, `#${shortId} updated`);
+    log.info(TAG20, `#${shortId} updated`);
   }
   if (plan.endSession) {
     await withRetry("endSession", shortId, () => client.endAgentSession(card.id, plan.endSession), attempts, backoffMs);
-    log.info(TAG19, `#${shortId} session ended (${plan.endSession.status})`);
+    log.info(TAG20, `#${shortId} session ended (${plan.endSession.status})`);
   }
   if (opts.store && opts.runId) {
     try {
@@ -4377,11 +4498,11 @@ async function ensureLabel(client, projectId, name, color, attempts, backoffMs)
     const result = await withRetry("addLabel", 0, () => client.createLabel(projectId, { name, color: color ?? "#8b5cf6" }), attempts, backoffMs);
     return result?.label?.id ?? null;
   } catch (err) {
-    log.warn(TAG19, `ensureLabel "${name}" failed: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG20, `ensureLabel "${name}" failed: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
-var TAG19 = "transition", TransitionError;
+var TAG20 = "transition", TransitionError;
 var init_transitions = __esm(() => {
   init_log();
   TransitionError = class TransitionError extends Error {
@@ -4399,7 +4520,7 @@ var init_transitions = __esm(() => {
 });
 
 // src/review-worker.ts
-import { execFileSync as execFileSync9 } from "node:child_process";
+import { execFileSync as execFileSync10 } from "node:child_process";
 
 class ReviewWorker {
   config;
@@ -4465,7 +4586,7 @@ class ReviewWorker {
     }
   }
   get tag() {
-    return `${TAG20}:${this.id}`;
+    return `${TAG21}:${this.id}`;
   }
   get isIdle() {
     return this.state === "idle";
@@ -4522,7 +4643,7 @@ class ReviewWorker {
       let localDiff = null;
       if (localMode) {
         log.info(this.tag, `No branch found for #${card.short_id}, attempting local review`);
-        this.worktreePath = execFileSync9("git", ["rev-parse", "--show-toplevel"], {
+        this.worktreePath = execFileSync10("git", ["rev-parse", "--show-toplevel"], {
           encoding: "utf-8",
           timeout: 5000
         }).trim();
@@ -4589,7 +4710,7 @@ class ReviewWorker {
         if (localMode) {
           diff = localDiff ?? "";
         } else {
-          diff = execFileSync9("git", ["diff", `origin/${this.config.worktree.baseBranch}..HEAD`], { cwd, encoding: "utf-8", timeout: 30000 });
+          diff = execFileSync10("git", ["diff", `origin/${this.config.worktree.baseBranch}..HEAD`], { cwd, encoding: "utf-8", timeout: 30000 });
         }
       } catch {
         diff = "(unable to retrieve diff)";
@@ -4869,7 +4990,7 @@ class ReviewWorker {
   }
   resolveLocalChanges(repoRoot, shortId) {
     try {
-      const localChanges = execFileSync9("git", ["diff", "HEAD"], {
+      const localChanges = execFileSync10("git", ["diff", "HEAD"], {
         cwd: repoRoot,
         encoding: "utf-8",
         timeout: 5000
@@ -4881,7 +5002,7 @@ class ReviewWorker {
       log.warn(this.tag, "Failed to check uncommitted changes");
     }
     try {
-      const matchingCommits = execFileSync9("git", ["log", "--format=%H", "-20", `--grep=#${shortId}`], { cwd: repoRoot, encoding: "utf-8", timeout: 1e4 }).trim();
+      const matchingCommits = execFileSync10("git", ["log", "--format=%H", "-20", `--grep=#${shortId}`], { cwd: repoRoot, encoding: "utf-8", timeout: 1e4 }).trim();
       if (matchingCommits) {
         const hashes = matchingCommits.split(`
 `).filter((h) => /^[0-9a-f]{4,40}$/i.test(h));
@@ -4891,7 +5012,7 @@ class ReviewWorker {
         const diffs = [];
         for (const hash of hashes) {
           try {
-            const commitDiff = execFileSync9("git", ["diff", `${hash}~1..${hash}`], { cwd: repoRoot, encoding: "utf-8", timeout: 30000 });
+            const commitDiff = execFileSync10("git", ["diff", `${hash}~1..${hash}`], { cwd: repoRoot, encoding: "utf-8", timeout: 30000 });
             if (commitDiff)
               diffs.push(commitDiff);
           } catch {
@@ -4934,7 +5055,7 @@ class ReviewWorker {
     this.lastSessionStats = null;
   }
 }
-var TAG20 = "review-worker", CANCEL_SIGINT_TIMEOUT = 30000, CANCEL_SIGTERM_TIMEOUT = 1e4;
+var TAG21 = "review-worker", CANCEL_SIGINT_TIMEOUT = 30000, CANCEL_SIGTERM_TIMEOUT = 1e4;
 var init_review_worker = __esm(() => {
   init_board_helpers();
   init_completion();
@@ -4983,7 +5104,7 @@ class SleepGuard {
       if (!this.child.killed)
         this.child.kill("SIGTERM");
       this.child = null;
-      log.info(TAG21, "sleep assertion released");
+      log.info(TAG22, "sleep assertion released");
     }
   }
   start() {
@@ -4998,7 +5119,7 @@ class SleepGuard {
         spawned = true;
       });
       child.on("error", (err) => {
-        log.warn(TAG21, `caffeinate unavailable: ${err.message}`);
+        log.warn(TAG22, `caffeinate unavailable: ${err.message}`);
         if (this.child === child)
           this.child = null;
       });
@@ -5011,13 +5132,13 @@ class SleepGuard {
       });
       child.unref();
       this.child = child;
-      log.info(TAG21, "sleep assertion acquired (caffeinate -i)");
+      log.info(TAG22, "sleep assertion acquired (caffeinate -i)");
     } catch (err) {
-      log.warn(TAG21, `failed to spawn caffeinate: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG22, `failed to spawn caffeinate: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG21 = "sleep-guard";
+var TAG22 = "sleep-guard";
 var init_sleep_guard = __esm(() => {
   init_log();
 });
@@ -5028,7 +5149,7 @@ async function fetchBlocksLinks(client, cardId) {
     const { links } = await client.getCardLinks(cardId);
     return links.filter((l) => l.link_type === "blocks");
   } catch (err) {
-    log.warn(TAG22, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG23, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -5060,31 +5181,175 @@ async function promoteUnblockedSuccessors(completedCard, deps) {
   const successors = links.filter((l) => l.direction === "outgoing" && !l.target_card.done);
   if (successors.length === 0)
     return;
-  log.info(TAG22, `#${completedCard.short_id} completed — checking ${successors.length} chained successor(s)`);
+  log.info(TAG23, `#${completedCard.short_id} completed — checking ${successors.length} chained successor(s)`);
   for (const link of successors) {
     const successorId = link.target_card.id;
     try {
       const { card } = await deps.client.getCard(successorId);
       if (card.assigned_agent_id === deps.agentId) {} else if (card.assigned_agent_id === null && !card.assignee_id) {
-        log.info(TAG22, `successor #${card.short_id} unassigned — auto-assigning to continue chain`);
+        log.info(TAG23, `successor #${card.short_id} unassigned — auto-assigning to continue chain`);
         await deps.client.updateCard(successorId, {
           assignedAgentId: deps.agentId
         });
       } else {
-        log.debug(TAG22, `successor #${card.short_id} assigned to different entity — skipping`);
+        log.debug(TAG23, `successor #${card.short_id} assigned to different entity — skipping`);
         continue;
       }
       await deps.enqueue(successorId);
     } catch (err) {
-      log.warn(TAG22, `promotion failed for successor ${successorId}: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG23, `promotion failed for successor ${successorId}: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG22 = "unblock";
+var TAG23 = "unblock";
 var init_unblock = __esm(() => {
   init_log();
 });
 
+// src/cli-agent-runner.ts
+class CliAgentRunner {
+  client;
+  cardId;
+  sessionId;
+  buffer = [];
+  flushTimer = null;
+  flushing = false;
+  stopped = false;
+  constructor(client, cardId, sessionId) {
+    this.client = client;
+    this.cardId = cardId;
+    this.sessionId = sessionId;
+  }
+  attach(parser) {
+    if (this.stopped)
+      return;
+    parser.on("tool_start", (name, input, toolUseId) => {
+      this.enqueue({
+        kind: "tool_started",
+        source: "agent",
+        payload: { toolName: name, toolUseId, input }
+      });
+    });
+    parser.on("tool_end", (name, toolUseId, content) => {
+      this.enqueue({
+        kind: "tool_ended",
+        source: "agent",
+        payload: {
+          toolName: name,
+          toolUseId,
+          output: content === undefined ? undefined : content.slice(0, MAX_OUTPUT_LEN)
+        }
+      });
+    });
+    parser.on("text", (content) => {
+      const text = content.trim();
+      if (!text)
+        return;
+      this.enqueue({
+        kind: "assistant_text",
+        source: "agent",
+        payload: { text: text.slice(0, MAX_TEXT_LEN) }
+      });
+    });
+    parser.on("cost_update", (cost) => {
+      this.enqueue({
+        kind: "cost_updated",
+        source: "agent",
+        payload: mapCost(cost)
+      });
+    });
+    this.startTimer();
+  }
+  recordRunStarted(payload) {
+    this.enqueue({ kind: "run_started", source: "system", payload });
+    this.startTimer();
+  }
+  recordPhaseChanged(phase, previousPhase) {
+    this.enqueue({
+      kind: "phase_changed",
+      source: "system",
+      payload: { phase, previousPhase }
+    });
+  }
+  recordProgress(payload) {
+    this.enqueue({ kind: "progress", source: "system", payload });
+  }
+  recordError(payload) {
+    this.enqueue({ kind: "error", source: "system", payload });
+  }
+  recordFinished(payload) {
+    this.enqueue({ kind: "run_finished", source: "system", payload });
+  }
+  record(body) {
+    this.enqueue(body);
+    this.startTimer();
+  }
+  enqueue(body) {
+    if (this.stopped)
+      return;
+    this.buffer.push({ ...body, createdAt: new Date().toISOString() });
+    if (this.buffer.length >= MAX_BUFFER)
+      this.flush();
+  }
+  startTimer() {
+    if (this.flushTimer || this.stopped)
+      return;
+    this.flushTimer = setInterval(() => void this.flush(), FLUSH_INTERVAL_MS);
+    this.flushTimer.unref?.();
+  }
+  async flush() {
+    if (this.flushing || this.buffer.length === 0)
+      return;
+    this.flushing = true;
+    const batch = this.buffer.splice(0, MAX_BUFFER);
+    try {
+      await this.client.appendAgentRunEvents(this.cardId, {
+        sessionId: this.sessionId,
+        events: batch
+      });
+    } catch (err) {
+      log.warn(TAG24, `Failed to flush run events: ${err}`);
+      this.buffer.unshift(...batch);
+      if (this.buffer.length > MAX_BUFFER) {
+        this.buffer.length = MAX_BUFFER;
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async flushFinal() {
+    for (let i = 0;this.buffer.length > 0 && i < 5; i++) {
+      const before = this.buffer.length;
+      await this.flush();
+      if (this.buffer.length >= before)
+        break;
+    }
+  }
+  stop() {
+    this.stopped = true;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+}
+function mapCost(cost) {
+  return {
+    totalCostUsd: cost.totalCostUsd,
+    inputTokens: cost.totalInputTokens,
+    outputTokens: cost.totalOutputTokens,
+    cacheCreationInputTokens: cost.totalCacheCreationInputTokens,
+    cacheReadInputTokens: cost.totalCacheReadInputTokens,
+    numTurns: cost.numTurns,
+    modelName: cost.modelName,
+    durationMs: cost.durationMs
+  };
+}
+var TAG24 = "cli-agent-runner", FLUSH_INTERVAL_MS = 2000, MAX_BUFFER = 1000, MAX_TEXT_LEN = 8000, MAX_OUTPUT_LEN = 4000;
+var init_cli_agent_runner = __esm(() => {
+  init_log();
+});
+
 // src/model-tier.ts
 function clampWithdrawn(model) {
   return WITHDRAWN_MODEL.test(model) ? MAX_IMPLEMENT_MODEL : model;
@@ -5135,11 +5400,11 @@ async function buildPrompt(enriched, branchName, worktreePath, client, workspace
 Do NOT push to main. All your work stays on \`${branchName}\`.
 When finished, call harmony_end_agent_session with status="completed".`
     });
-    log.info(TAG23, `Generated prompt for #${card.short_id} — ${result.contextSummary.memoryCount} memories, ${result.tokenEstimate} tokens`);
+    log.info(TAG25, `Generated prompt for #${card.short_id} — ${result.contextSummary.memoryCount} memories, ${result.tokenEstimate} tokens`);
     return result.prompt + pastEpisodesSection;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log.warn(TAG23, `Failed to generate prompt via API, using fallback: ${msg}`);
+    log.warn(TAG25, `Failed to generate prompt via API, using fallback: ${msg}`);
     const commentsSection = await renderCommentsSection(client, card.id);
     return buildFallbackPrompt(enriched, branchName, worktreePath) + commentsSection + pastEpisodesSection;
   }
@@ -5157,7 +5422,7 @@ async function renderCommentsSection(client, cardId) {
 
 ${section}` : "";
   } catch (err) {
-    log.warn(TAG23, "comment-thread fetch failed", {
+    log.warn(TAG25, "comment-thread fetch failed", {
       event: "comment_fetch_failed",
       error: err instanceof Error ? err.message : String(err)
     });
@@ -5207,7 +5472,7 @@ ${description}`.trim();
 ## Similar past tasks
 ${bullets}`;
   } catch (err) {
-    log.warn(TAG23, "past-episodes recall failed", {
+    log.warn(TAG25, "past-episodes recall failed", {
       event: "episode_recall_failed",
       error: err instanceof Error ? err.message : String(err)
     });
@@ -5248,13 +5513,346 @@ ${subtaskStr}
 You are working in a git worktree at \`${worktreePath}\` on branch \`${branchName}\`.
 Do NOT push to main. All your work stays on \`${branchName}\`.`;
 }
-var TAG23 = "prompt";
+var TAG25 = "prompt";
 var init_prompt = __esm(() => {
   init_dist();
   init_log();
 });
 
+// src/sdk-agent-runner.ts
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
+function mapSdkErrorKind(e) {
+  switch (e) {
+    case "authentication_failed":
+    case "oauth_org_not_allowed":
+      return "auth";
+    case "billing_error":
+      return "out_of_credits";
+    case "rate_limit":
+    case "overloaded":
+      return "rate_limit";
+    default:
+      return null;
+  }
+}
+
+class SdkAgentRunner {
+  cfg;
+  abort = null;
+  capturedSessionId;
+  child = null;
+  leaderPid;
+  capturedStderr = "";
+  toolNames = new Map;
+  observedModel;
+  effectiveModel;
+  constructor(cfg = {}) {
+    this.cfg = cfg;
+  }
+  get sessionId() {
+    return this.capturedSessionId;
+  }
+  get capturedStderrText() {
+    return this.capturedStderr;
+  }
+  start(input) {
+    return this.run(input);
+  }
+  resume(input) {
+    return this.run(input, input.resumeSessionId);
+  }
+  async send(_message) {
+    throw new Error("SdkAgentRunner.send() (streaming-input steering) is not wired; the worker steers via stop→resume");
+  }
+  async stop(_reason) {
+    this.abort?.abort();
+    if (this.child) {
+      await terminateGroup(this.child, {
+        sigintTimeoutMs: STOP_SIGINT_MS,
+        sigtermTimeoutMs: STOP_SIGTERM_MS
+      });
+    }
+    reapGroup(this.leaderPid);
+  }
+  async* run(input, resumeSessionId) {
+    this.abort = new AbortController;
+    this.capturedStderr = "";
+    this.child = null;
+    this.leaderPid = undefined;
+    this.toolNames.clear();
+    this.observedModel = undefined;
+    this.effectiveModel = input.model ?? this.cfg.model;
+    yield {
+      kind: "run_started",
+      source: "system",
+      payload: { runner: "sdk", model: input.model }
+    };
+    const allowed = this.cfg.allowedTools ?? SDK_ALLOWED_TOOLS;
+    const builtinTools = allowed.filter((t) => !t.startsWith("mcp__") && !t.includes("*"));
+    const options = {
+      cwd: input.cwd,
+      model: input.model ?? this.cfg.model,
+      allowedTools: allowed,
+      tools: builtinTools,
+      permissionMode: "dontAsk",
+      maxTurns: this.cfg.maxTurns,
+      abortController: this.abort,
+      ...resumeSessionId ? { resume: resumeSessionId } : {},
+      ...this.cfg.maxBudgetUsd ? { maxBudgetUsd: this.cfg.maxBudgetUsd } : {},
+      ...this.cfg.settingSources ? { settingSources: this.cfg.settingSources } : {},
+      ...this.cfg.mcpServers ? { mcpServers: this.cfg.mcpServers } : {},
+      ...this.cfg.strictMcpConfig ? { strictMcpConfig: true } : {},
+      stderr: (data) => {
+        this.capturedStderr += data;
+      },
+      spawnClaudeCodeProcess: (spawnOpts) => this.spawn(spawnOpts)
+    };
+    try {
+      const q = query({ prompt: input.prompt, options });
+      let failureReason = null;
+      for await (const msg of q) {
+        for (const ev of this.mapMessage(msg)) {
+          if (ev.kind === "error") {
+            failureReason = ev.payload.errorKind ?? "crash";
+          }
+          yield ev;
+        }
+      }
+      yield {
+        kind: "run_finished",
+        source: "system",
+        payload: failureReason ? { status: "failed", failureReason } : { status: "completed" }
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const cls = classifyRunError(`${message}
+${this.capturedStderr}`);
+      yield {
+        kind: "error",
+        source: "system",
+        payload: {
+          message,
+          errorKind: cls.kind,
+          retryable: cls.kind !== "auth" && cls.kind !== null
+        }
+      };
+      yield {
+        kind: "run_finished",
+        source: "system",
+        payload: { status: "failed", failureReason: cls.kind ?? "crash" }
+      };
+    } finally {
+      reapGroup(this.leaderPid);
+    }
+  }
+  spawn(spawnOpts) {
+    const child = spawnInGroup(spawnOpts.command, spawnOpts.args, {
+      cwd: spawnOpts.cwd,
+      env: spawnOpts.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    this.leaderPid = child.pid;
+    child.stderr?.on("data", (d) => {
+      this.capturedStderr += d.toString();
+    });
+    this.cfg.onSpawn?.(child);
+    return {
+      stdin: child.stdin,
+      stdout: child.stdout,
+      get killed() {
+        return child.killed;
+      },
+      get exitCode() {
+        return child.exitCode;
+      },
+      kill: (signal) => {
+        if (!child.pid)
+          return false;
+        try {
+          process.kill(-child.pid, signal);
+          return true;
+        } catch {
+          return child.kill(signal);
+        }
+      },
+      on: (event, listener) => child.on(event, listener),
+      once: (event, listener) => child.once(event, listener),
+      off: (event, listener) => child.off(event, listener)
+    };
+  }
+  *mapMessage(msg) {
+    const sid = msg.session_id;
+    if (sid && !this.capturedSessionId)
+      this.capturedSessionId = sid;
+    const model = msg.message?.model ?? msg.model;
+    if (typeof model === "string" && !this.observedModel) {
+      this.observedModel = model;
+    }
+    switch (msg.type) {
+      case "assistant": {
+        const am = msg;
+        if (am.error) {
+          yield {
+            kind: "error",
+            source: "system",
+            payload: {
+              message: `assistant error: ${am.error}`,
+              errorKind: mapSdkErrorKind(am.error)
+            }
+          };
+        }
+        const blocks = am.message?.content;
+        if (Array.isArray(blocks)) {
+          for (const b of blocks) {
+            if (b.type === "text" && typeof b.text === "string") {
+              const text = b.text.trim();
+              if (text) {
+                yield {
+                  kind: "assistant_text",
+                  source: "agent",
+                  payload: { text: text.slice(0, MAX_TEXT_LEN2) }
+                };
+              }
+            } else if (b.type === "tool_use" && typeof b.name === "string") {
+              if (typeof b.id === "string")
+                this.toolNames.set(b.id, b.name);
+              yield {
+                kind: "tool_started",
+                source: "agent",
+                payload: { toolName: b.name, toolUseId: b.id, input: b.input }
+              };
+            }
+          }
+        }
+        break;
+      }
+      case "user": {
+        const um = msg;
+        const blocks = um.message?.content;
+        if (Array.isArray(blocks)) {
+          for (const b of blocks) {
+            if (b.type === "tool_result" && typeof b.tool_use_id === "string") {
+              const toolName = this.toolNames.get(b.tool_use_id) ?? "";
+              this.toolNames.delete(b.tool_use_id);
+              yield {
+                kind: "tool_ended",
+                source: "agent",
+                payload: {
+                  toolName,
+                  toolUseId: b.tool_use_id,
+                  output: normalize(b.content)?.slice(0, MAX_OUTPUT_LEN2),
+                  isError: b.is_error
+                }
+              };
+            }
+          }
+        }
+        break;
+      }
+      case "result": {
+        const r = msg;
+        if (typeof r.total_cost_usd === "number") {
+          yield {
+            kind: "cost_updated",
+            source: "agent",
+            payload: {
+              totalCostUsd: r.total_cost_usd,
+              inputTokens: r.usage?.input_tokens ?? 0,
+              outputTokens: r.usage?.output_tokens ?? 0,
+              cacheCreationInputTokens: r.usage?.cache_creation_input_tokens ?? 0,
+              cacheReadInputTokens: r.usage?.cache_read_input_tokens ?? 0,
+              numTurns: r.num_turns ?? 0,
+              durationMs: r.duration_ms,
+              modelName: this.observedModel ?? this.effectiveModel
+            }
+          };
+        }
+        if (r.subtype && r.subtype !== "success") {
+          const joined = (r.errors ?? []).join(`
+`);
+          const cls = classifyRunError(`${r.subtype}
+${joined}
+${this.capturedStderr}`);
+          yield {
+            kind: "error",
+            source: "system",
+            payload: {
+              message: `result ${r.subtype}: ${joined || "(no detail)"}`,
+              errorKind: cls.kind,
+              retryable: cls.kind !== "auth" && cls.kind !== null
+            }
+          };
+        }
+        break;
+      }
+    }
+  }
+}
+function normalize(raw) {
+  if (raw == null)
+    return;
+  if (typeof raw === "string")
+    return raw;
+  if (Array.isArray(raw)) {
+    const parts = [];
+    for (const b of raw) {
+      if (b && typeof b === "object" && "text" in b && typeof b.text === "string") {
+        parts.push(b.text);
+      }
+    }
+    return parts.length ? parts.join("") : JSON.stringify(raw);
+  }
+  try {
+    return JSON.stringify(raw);
+  } catch {
+    return String(raw);
+  }
+}
+var SDK_ALLOWED_TOOLS, MAX_TEXT_LEN2 = 8000, MAX_OUTPUT_LEN2 = 4000, STOP_SIGINT_MS = 2000, STOP_SIGTERM_MS = 2000;
+var init_sdk_agent_runner = __esm(() => {
+  init_error_classifier();
+  init_process_group();
+  SDK_ALLOWED_TOOLS = [
+    "Bash",
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "Agent",
+    "mcp__harmony__*"
+  ];
+});
+
 // src/worker.ts
+function sdkDraftLogLine(ev) {
+  switch (ev.kind) {
+    case "assistant_text":
+      return ev.payload.text.slice(0, 200);
+    case "tool_started":
+      return ev.payload.toolName;
+    case "tool_ended":
+      return `${ev.payload.toolUseId ?? ""}${ev.payload.isError ? " (error)" : ""}`;
+    case "cost_updated":
+      return `$${ev.payload.totalCostUsd.toFixed(4)} turns=${ev.payload.numTurns}`;
+    case "error":
+      return ev.payload.message.slice(0, 200);
+    case "run_finished":
+      return ev.payload.status;
+    default:
+      return "";
+  }
+}
+function buildSteeringPrompt(messages) {
+  if (messages.length === 1)
+    return messages[0];
+  return messages.map((m, i) => `${i + 1}. ${m}`).join(`
+`);
+}
+
 class Worker {
   config;
   client;
@@ -5275,12 +5873,16 @@ class Worker {
   timeoutTimer = null;
   heartbeatTimer = null;
   progressTracker = null;
+  cliRunner = null;
+  sdkRunner = null;
   lastSessionStats;
   aborted = false;
   timedOut = false;
   verificationFailed = false;
   sessionId = null;
   runId = null;
+  cliSessionId = null;
+  lastDrainedSeq = 0;
   runCostCents = 0;
   runTurns = 0;
   constructor(id, config, client, agentId, onDone, workspaceId, projectId, stateStore, onCardCompleted, onApiError) {
@@ -5327,7 +5929,7 @@ class Worker {
     }
   }
   get tag() {
-    return `${TAG24}:${this.id}`;
+    return `${TAG26}:${this.id}`;
   }
   get isIdle() {
     return this.state === "idle";
@@ -5349,6 +5951,8 @@ class Worker {
     this.verificationFailed = false;
     this.runCostCents = 0;
     this.runTurns = 0;
+    this.cliSessionId = null;
+    this.lastDrainedSeq = 0;
     this.cardId = card.id;
     this.startedAt = Date.now();
     this.runId = newRunId();
@@ -5386,9 +5990,16 @@ class Worker {
       });
       const sid = session && typeof session === "object" && "id" in session ? session.id : null;
       if (!sid) {
-        log.warn(TAG24, "startAgentSession returned no session id");
+        log.warn(TAG26, "startAgentSession returned no session id");
       }
       this.sessionId = sid;
+      if (this.sessionId) {
+        this.cliRunner = new CliAgentRunner(this.client, card.id, this.sessionId);
+        this.cliRunner.recordRunStarted({
+          runner: this.config.runner,
+          model: this.config.claude.model
+        });
+      }
       await this.recordPhase("preparing");
       const moved = await moveCardAndAddLabel(this.client, card, IN_PROGRESS_COLUMN, "agent");
       if (!moved) {
@@ -5435,6 +6046,9 @@ class Worker {
       await this.spawnClaude(prompt, card, subtasks, {
         model: this.selectImplementModel(card)
       });
+      if (this.aborted)
+        return;
+      await this.drainSteeringMessages(card, subtasks);
       if (this.aborted)
         return;
       if (this.timeoutTimer) {
@@ -5461,7 +6075,17 @@ class Worker {
       log.error(this.tag, `Error on #${card.short_id}: ${msg}`);
       const rawStderr = err?.stderr;
       const errClass = classifyRunError(typeof rawStderr === "string" && rawStderr ? rawStderr : msg);
+      const sdkKind = err?.errorKind;
+      if (errClass.kind === null && sdkKind != null)
+        errClass.kind = sdkKind;
       const apiError = errClass.kind !== null;
+      const baseError = err instanceof WorktreeBaseError;
+      const noBudgetBurn = apiError || baseError;
+      this.cliRunner?.recordError({
+        message: msg.slice(0, 500),
+        errorKind: errClass.kind,
+        retryable: noBudgetBurn
+      });
       if (apiError) {
         try {
           this.onApiError?.(errClass);
@@ -5476,7 +6100,7 @@ class Worker {
         this.worktreePath = null;
       }
       const failureReason = apiError ? errClass.kind : "other";
-      const failureSummary = apiError ? describeApiError(errClass.kind) : `Run failed: ${msg.slice(0, 300)}`;
+      const failureSummary = apiError ? describeApiError(errClass.kind) : baseError ? "Could not fetch current base branch — requeued without counting an attempt" : `Run failed: ${msg.slice(0, 300)}`;
       try {
         await runTransition(this.client, card, {
           move: { columnName: this.config.pickupColumns[0] ?? "To Do" },
@@ -5497,7 +6121,7 @@ class Worker {
             ...this.runLedger()
           });
         } catch {}
-        if (apiError) {
+        if (noBudgetBurn) {
           await this.stateStore.decrementAttempt(card.id);
         } else {
           await this.recordOutcome(card.id, "failure");
@@ -5555,6 +6179,26 @@ class Worker {
         } catch {}
         await this.recordOutcome(card.id, "failure");
       }
+      if (this.cliRunner) {
+        if (succeeded) {
+          this.cliRunner.recordFinished({ status: "completed" });
+        } else if (this.timedOut) {
+          this.cliRunner.recordFinished({
+            status: "failed",
+            failureReason: "timeout"
+          });
+        } else if (this.aborted) {
+          this.cliRunner.recordFinished({
+            status: "stopped",
+            stopReason: "user_requested"
+          });
+        } else {
+          this.cliRunner.recordFinished({ status: "failed" });
+        }
+        try {
+          await this.cliRunner.flushFinal();
+        } catch {}
+      }
       this.cleanup();
       this.state = "idle";
       this.onDone(this);
@@ -5644,7 +6288,9 @@ class Worker {
     this.aborted = true;
     this.state = "cancelling";
     log.info(this.tag, `Cancelling work on ${this.cardId}`);
-    if (this.process && !this.process.killed) {
+    if (this.sdkRunner) {
+      await this.sdkRunner.stop(this.timedOut ? "timeout" : "user_requested");
+    } else if (this.process && !this.process.killed) {
       await terminateGroup(this.process, {
         sigintTimeoutMs: CANCEL_SIGINT_TIMEOUT2,
         sigtermTimeoutMs: CANCEL_SIGTERM_TIMEOUT2
@@ -5679,7 +6325,9 @@ class Worker {
     const planTimeout = setTimeout(() => {
       planTimedOut = true;
       log.warn(this.tag, "Planning pass exceeded timeout — abandoning, implementing directly");
-      if (this.process && !this.process.killed) {
+      if (this.sdkRunner) {
+        this.sdkRunner.stop("timeout").catch(() => {});
+      } else if (this.process && !this.process.killed) {
         terminateGroup(this.process, {
           sigintTimeoutMs: 1e4,
           sigtermTimeoutMs: 5000
@@ -5773,7 +6421,40 @@ class Worker {
     }
     return false;
   }
-  async spawnClaude(prompt, card, subtasks, opts = {}) {
+  async drainSteeringMessages(card, subtasks) {
+    if (!this.cliSessionId || !this.sessionId || !this.cardId)
+      return;
+    for (let i = 0;i < MAX_STEERING_ITERATIONS && !this.aborted; i++) {
+      let messages;
+      try {
+        const res = await this.client.getPendingUserMessages(this.cardId, this.sessionId, this.lastDrainedSeq);
+        messages = res.messages ?? [];
+      } catch (err) {
+        log.warn(this.tag, `Failed to fetch steering messages (non-fatal): ${err instanceof Error ? err.message : err}`);
+        return;
+      }
+      if (messages.length === 0)
+        return;
+      this.lastDrainedSeq = Math.max(this.lastDrainedSeq, ...messages.map((m) => m.seq));
+      log.info(this.tag, `Steering #${card.short_id}: resuming with ${messages.length} queued message(s)`);
+      this.state = "running";
+      await this.recordPhase("running");
+      try {
+        await this.spawnClaude(buildSteeringPrompt(messages.map((m) => m.text)), card, subtasks, {
+          model: this.selectImplementModel(card),
+          maxTurns: STEERING_MAX_TURNS,
+          resumeSessionId: this.cliSessionId
+        });
+      } catch (err) {
+        log.warn(this.tag, `Steering resume failed (non-fatal): ${err instanceof Error ? err.message : err}`);
+        return;
+      }
+    }
+  }
+  spawnClaude(prompt, card, subtasks, opts = {}) {
+    return this.config.runner === "sdk" ? this.spawnClaudeSdk(prompt, card, subtasks, opts) : this.spawnClaudeCli(prompt, card, subtasks, opts);
+  }
+  async spawnClaudeCli(prompt, card, subtasks, opts = {}) {
     const model = opts.model ?? this.config.claude.model;
     const maxTurns = opts.maxTurns ?? this.config.claude.maxTurns;
     const allowedTools = opts.allowedTools ?? IMPLEMENT_ALLOWED_TOOLS;
@@ -5790,6 +6471,7 @@ class Worker {
         String(maxTurns),
         "--allowedTools",
         allowedTools,
+        ...opts.resumeSessionId ? ["--resume", opts.resumeSessionId] : [],
         ...this.config.claude.additionalArgs,
         "--",
         prompt
@@ -5809,10 +6491,11 @@ class Worker {
       });
       const parser = new StreamParser;
       this.progressTracker = new ProgressTracker(this.client, card.id, this.id, subtasks, initialPhase);
-      if (this.sessionId) {
-        this.progressTracker.setSessionId(this.sessionId);
-      }
       this.progressTracker.attach(parser);
+      this.cliRunner?.attach(parser);
+      if (this.cliRunner) {
+        this.progressTracker.setRunEventSink(this.cliRunner);
+      }
       if (this.process.stdout) {
         parser.attach(this.process.stdout);
         if (runLog) {
@@ -5836,14 +6519,16 @@ class Worker {
         reject(new Error(`Failed to spawn claude: ${err.message}`));
       });
       this.process.on("close", (code) => {
+        const leaderPid = this.process?.pid;
         this.process = null;
+        if (parser.sessionId)
+          this.cliSessionId = parser.sessionId;
         this.lastSessionStats = this.progressTracker?.stats;
         const spawnCost = this.lastSessionStats?.cost;
         if (spawnCost) {
           this.runCostCents += Math.round(spawnCost.totalCostUsd * 100);
           this.runTurns += spawnCost.numTurns;
         }
-        this.progressTracker?.flushFinal();
         this.progressTracker?.stop();
         this.progressTracker = null;
         if (runLog) {
@@ -5853,6 +6538,7 @@ class Worker {
 `);
           runLog.stream.end();
         }
+        reapGroup(leaderPid);
         if (this.aborted) {
           resolve3();
         } else if (code === 0) {
@@ -5865,11 +6551,101 @@ class Worker {
       });
     });
   }
+  async spawnClaudeSdk(prompt, card, subtasks, opts = {}) {
+    const model = opts.model ?? this.config.claude.model;
+    const maxTurns = opts.maxTurns ?? this.config.claude.maxTurns;
+    const allowedTools = (opts.allowedTools ?? IMPLEMENT_ALLOWED_TOOLS).split(",").map((t) => t.trim()).filter(Boolean);
+    const initialPhase = opts.initialPhase ?? "exploring";
+    const sdkCfg = this.config.sdk;
+    log.info(this.tag, `Spawning Agent SDK runner (model=${model}, maxTurns=${maxTurns}${opts.resumeSessionId ? ", resume" : ""})`);
+    const runLog = openRunLog(this.tag, this.runId, card.short_id);
+    if (runLog) {
+      log.info(this.tag, `Run log: ${runLog.path}`);
+      runLog.stream.write(`# run=${this.runId} card=#${card.short_id} runner=sdk started=${new Date().toISOString()}
+` + `# model=${model} maxTurns=${maxTurns} <prompt:${prompt.length} chars>
+
+`);
+    }
+    this.progressTracker = new ProgressTracker(this.client, card.id, this.id, subtasks, initialPhase);
+    if (this.cliRunner) {
+      this.progressTracker.setRunEventSink(this.cliRunner);
+    }
+    const runner = new SdkAgentRunner({
+      model,
+      maxTurns,
+      allowedTools,
+      maxBudgetUsd: sdkCfg?.maxBudgetUsd,
+      settingSources: sdkCfg?.settingSources,
+      mcpServers: sdkCfg?.mcpServers,
+      strictMcpConfig: sdkCfg?.strictMcpConfig,
+      onSpawn: (child) => {
+        this.process = child;
+      }
+    });
+    this.sdkRunner = runner;
+    const baseInput = {
+      sessionId: this.sessionId ?? "",
+      cardId: card.id,
+      workspaceId: this.workspaceId,
+      prompt,
+      cwd: this.worktreePath,
+      model
+    };
+    const stream = opts.resumeSessionId ? runner.resume({ ...baseInput, resumeSessionId: opts.resumeSessionId }) : runner.start(baseInput);
+    let failure = null;
+    let failureKind = null;
+    try {
+      for await (const ev of stream) {
+        this.progressTracker?.ingest(ev);
+        if (ev.source === "agent")
+          this.cliRunner?.record(ev);
+        if (ev.kind === "error") {
+          failure = ev.payload.message;
+          if (ev.payload.errorKind != null)
+            failureKind = ev.payload.errorKind;
+        }
+        runLog?.stream.write(`[${ev.kind}] ${sdkDraftLogLine(ev)}
+`);
+      }
+    } finally {
+      this.cliSessionId = runner.sessionId ?? this.cliSessionId;
+      this.lastSessionStats = this.progressTracker?.stats;
+      const spawnCost = this.lastSessionStats?.cost;
+      if (spawnCost) {
+        this.runCostCents += Math.round(spawnCost.totalCostUsd * 100);
+        this.runTurns += spawnCost.numTurns;
+      }
+      if (runLog) {
+        const stats = this.lastSessionStats;
+        runLog.stream.write(`
+# runner=sdk aborted=${this.aborted} ` + `toolCalls=${stats?.toolCalls ?? 0} filesEdited=${stats?.filesEdited ?? 0} ` + `cost=$${stats?.cost?.totalCostUsd.toFixed(4) ?? "0"} ` + `ended=${new Date().toISOString()}
+`);
+        runLog.stream.end();
+      }
+      this.progressTracker?.stop();
+      this.progressTracker = null;
+      this.process = null;
+      this.sdkRunner = null;
+    }
+    if (this.aborted)
+      return;
+    if (failure) {
+      const err = new Error(failure);
+      err.stderr = runner.capturedStderrText;
+      err.errorKind = failureKind;
+      throw err;
+    }
+  }
   cleanup() {
     if (this.progressTracker) {
       this.progressTracker.stop();
       this.progressTracker = null;
     }
+    if (this.cliRunner) {
+      this.cliRunner.stop();
+      this.cliRunner = null;
+    }
+    this.sdkRunner = null;
     this.stopHeartbeat();
     this.lastSessionStats = undefined;
     if (this.timeoutTimer) {
@@ -5894,9 +6670,10 @@ class Worker {
     this.runTurns = 0;
   }
 }
-var TAG24 = "worker", CANCEL_SIGINT_TIMEOUT2 = 30000, CANCEL_SIGTERM_TIMEOUT2 = 1e4, PLAN_ALLOWED_TOOLS = "Read,Grep,Glob,mcp__harmony__*", IMPLEMENT_ALLOWED_TOOLS = "Bash,Read,Write,Edit,Glob,Grep,Agent,mcp__harmony__*", PLAN_PHASE_TIMEOUT;
+var TAG26 = "worker", CANCEL_SIGINT_TIMEOUT2 = 30000, CANCEL_SIGTERM_TIMEOUT2 = 1e4, STEERING_MAX_TURNS = 15, MAX_STEERING_ITERATIONS = 10, PLAN_ALLOWED_TOOLS = "Read,Grep,Glob,mcp__harmony__*", IMPLEMENT_ALLOWED_TOOLS = "Bash,Read,Write,Edit,Glob,Grep,Agent,mcp__harmony__*", PLAN_PHASE_TIMEOUT;
 var init_worker = __esm(() => {
   init_board_helpers();
+  init_cli_agent_runner();
   init_completion();
   init_error_classifier();
   init_log();
@@ -5906,6 +6683,7 @@ var init_worker = __esm(() => {
   init_progress_tracker();
   init_prompt();
   init_run_log();
+  init_sdk_agent_runner();
   init_state_store();
   init_stream_parser();
   init_transitions();
@@ -5964,39 +6742,39 @@ class Pool {
   }
   async enqueue(card, column, labels, subtasks, mode = "implement") {
     if (this.implQueue.has(card.id) || this.reviewQueue.has(card.id) || this.isCardActive(card.id)) {
-      log.debug(TAG25, `Card ${card.id} already queued or active, skipping`);
+      log.debug(TAG27, `Card ${card.id} already queued or active, skipping`);
       return;
     }
     if (mode === "implement") {
       if (this.authPaused) {
-        log.debug(TAG25, `#${card.short_id} held — agent paused (auth error)`);
+        log.debug(TAG27, `#${card.short_id} held — agent paused (auth error)`);
         await this.emitWaiting(card.id, "Agent paused — Anthropic auth error, check API credentials");
         return;
       }
       const cooldownMs = this.apiCooldownRemainingMs();
       if (cooldownMs > 0) {
-        log.debug(TAG25, `#${card.short_id} held — API cooldown ${Math.round(cooldownMs / 1000)}s remaining`);
+        log.debug(TAG27, `#${card.short_id} held — API cooldown ${Math.round(cooldownMs / 1000)}s remaining`);
         await this.emitWaiting(card.id, `Paused — Anthropic API limit, retrying in ~${Math.round(cooldownMs / 1000)}s`);
         return;
       }
       const decision = this.budget.check(card.id);
       if (!decision.allow) {
         if (decision.reason === "daily_budget") {
-          log.warn(TAG25, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
+          log.warn(TAG27, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
           await this.emitWaiting(card.id, `Daily budget reached — waiting for reset (${decision.detail})`);
         } else {
-          log.debug(TAG25, `#${card.short_id} gave up: ${decision.detail}`);
+          log.debug(TAG27, `#${card.short_id} gave up: ${decision.detail}`);
         }
         return;
       }
       const blockers = await getUnresolvedBlockers(this.client, card, this.projectId);
       if (blockers === null) {
-        log.warn(TAG25, `#${card.short_id} blocker check failed — deferring to next tick`);
+        log.warn(TAG27, `#${card.short_id} blocker check failed — deferring to next tick`);
         return;
       }
       if (blockers.length > 0) {
         const list = blockers.map((b) => `#${b.shortId}`).join(", ");
-        log.info(TAG25, `#${card.short_id} blocked by ${list} — waiting`);
+        log.info(TAG27, `#${card.short_id} blocked by ${list} — waiting`);
         await this.emitWaiting(card.id, `Blocked by ${list} — waiting for chain`);
         return;
       }
@@ -6025,7 +6803,7 @@ class Pool {
       });
       this.lastWaitingEmit.set(cardId, currentTask);
     } catch (err) {
-      log.debug(TAG25, `waiting emit failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+      log.debug(TAG27, `waiting emit failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
     }
   }
   noteApiError(err) {
@@ -6033,7 +6811,7 @@ class Pool {
       return;
     if (err.kind === "auth") {
       if (!this.authPaused) {
-        log.error(TAG25, "Auth error from Claude CLI — pausing implement pickups until the daemon is restarted with valid credentials");
+        log.error(TAG27, "Auth error from Claude CLI — pausing implement pickups until the daemon is restarted with valid credentials");
       }
       this.authPaused = true;
       return;
@@ -6042,7 +6820,7 @@ class Pool {
     const until = Date.now() + cooldownMs;
     if (until > this.apiCooldownUntil) {
       this.apiCooldownUntil = until;
-      log.warn(TAG25, `${describeApiError(err.kind)} — pausing implement pickups for ${Math.round(cooldownMs / 1000)}s`);
+      log.warn(TAG27, `${describeApiError(err.kind)} — pausing implement pickups for ${Math.round(cooldownMs / 1000)}s`);
     }
   }
   apiCooldownRemainingMs() {
@@ -6055,13 +6833,13 @@ class Pool {
       const removed = queue.remove(cardId);
       if (removed) {
         this.cardDataCache.delete(cardId);
-        log.info(TAG25, `Removed #${removed.shortId} from ${removed.mode} queue`);
+        log.info(TAG27, `Removed #${removed.shortId} from ${removed.mode} queue`);
         return;
       }
     }
     const worker = this.implWorkers.find((w) => w.cardId === cardId) ?? this.reviewWorkers.find((w) => w.cardId === cardId);
     if (worker) {
-      log.info(TAG25, `Cancelling worker ${worker.id} for card ${cardId}`);
+      log.info(TAG27, `Cancelling worker ${worker.id} for card ${cardId}`);
       await worker.cancel();
     }
   }
@@ -6094,10 +6872,10 @@ class Pool {
   async handleAgentCommand(cardId, command) {
     const worker = this.implWorkers.find((w) => w.cardId === cardId && w.isActive) ?? this.reviewWorkers.find((w) => w.cardId === cardId && w.isActive);
     if (!worker) {
-      log.debug(TAG25, `No active worker for card ${cardId}, ignoring ${command}`);
+      log.debug(TAG27, `No active worker for card ${cardId}, ignoring ${command}`);
       return;
     }
-    log.info(TAG25, `Agent command: ${command} → worker ${worker.id} (card ${cardId})`);
+    log.info(TAG27, `Agent command: ${command} → worker ${worker.id} (card ${cardId})`);
     switch (command) {
       case "pause":
         await worker.pause();
@@ -6145,7 +6923,7 @@ class Pool {
     };
   }
   async shutdown() {
-    log.info(TAG25, "Shutting down pool...");
+    log.info(TAG27, "Shutting down pool...");
     this.shuttingDown = true;
     const active = [
       ...this.implWorkers.filter((w) => w.isActive),
@@ -6153,7 +6931,7 @@ class Pool {
     ];
     await Promise.all(active.map((w) => w.cancel()));
     this.sleepGuard.stop();
-    log.info(TAG25, "Pool shutdown complete");
+    log.info(TAG27, "Pool shutdown complete");
   }
   cardDataCache = new Map;
   tryDispatchFor(workers, queue, label) {
@@ -6161,7 +6939,7 @@ class Pool {
       return false;
     const idle = workers.find((w) => w.isIdle);
     if (!idle) {
-      log.debug(TAG25, `No idle ${label} workers (queue: ${queue.length})`);
+      log.debug(TAG27, `No idle ${label} workers (queue: ${queue.length})`);
       return false;
     }
     const next = queue.dequeue();
@@ -6169,18 +6947,18 @@ class Pool {
       return false;
     const data = this.cardDataCache.get(next.cardId);
     if (!data) {
-      log.warn(TAG25, `No cached data for card ${next.cardId}, skipping`);
+      log.warn(TAG27, `No cached data for card ${next.cardId}, skipping`);
       return false;
     }
     this.cardDataCache.delete(next.cardId);
     this.lastWaitingEmit.delete(next.cardId);
-    log.info(TAG25, `Dispatching #${next.shortId} to ${label} worker ${idle.id}`);
+    log.info(TAG27, `Dispatching #${next.shortId} to ${label} worker ${idle.id}`);
     this.sleepGuard.acquire();
     idle.run(data.card, data.column, data.labels, data.subtasks);
     return true;
   }
 }
-var TAG25 = "pool";
+var TAG27 = "pool";
 var init_pool = __esm(() => {
   init_error_classifier();
   init_log();
@@ -6222,7 +7000,7 @@ function load(path) {
       return parsed;
     return {};
   } catch (err) {
-    log.warn(TAG26, `failed to read ${path}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG28, `failed to read ${path}: ${err instanceof Error ? err.message : err}`);
     return {};
   }
 }
@@ -6240,7 +7018,7 @@ function recordDaemonPort(projectId, entry, path = defaultRegistryPath()) {
     registry[projectId] = { ...entry, updatedAt: Date.now() };
     save(path, registry);
   } catch (err) {
-    log.warn(TAG26, `failed to record port for ${projectId}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG28, `failed to record port for ${projectId}: ${err instanceof Error ? err.message : err}`);
   }
 }
 function lookupDaemonPort(projectId, path = defaultRegistryPath()) {
@@ -6256,10 +7034,10 @@ function clearDaemonPort(projectId, pid, path = defaultRegistryPath()) {
     delete registry[projectId];
     save(path, registry);
   } catch (err) {
-    log.warn(TAG26, `failed to clear port for ${projectId}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG28, `failed to clear port for ${projectId}: ${err instanceof Error ? err.message : err}`);
   }
 }
-var TAG26 = "port-registry";
+var TAG28 = "port-registry";
 var init_port_registry = __esm(() => {
   init_log();
 });
@@ -6280,7 +7058,7 @@ async function fetchCardSafely(client, cardId) {
     const { card } = await client.getCard(cardId);
     return card;
   } catch (err) {
-    log.warn(TAG27, `cannot fetch card ${cardId}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG29, `cannot fetch card ${cardId}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -6290,7 +7068,7 @@ async function recoverOrphans(store, client, config) {
     return [];
   }
   const outcomes = [];
-  log.info(TAG27, `recovering ${active.length} orphan run(s) from prior daemon`);
+  log.info(TAG29, `recovering ${active.length} orphan run(s) from prior daemon`);
   for (const run of active) {
     const outcome = {
       runId: run.runId,
@@ -6302,11 +7080,11 @@ async function recoverOrphans(store, client, config) {
     };
     outcomes.push(outcome);
     if (isProcessAlive(run.daemonPid, process.pid)) {
-      log.warn(TAG27, `run ${run.runId} claims live daemon pid ${run.daemonPid} — skipping`);
+      log.warn(TAG29, `run ${run.runId} claims live daemon pid ${run.daemonPid} — skipping`);
       outcome.actions.push("skipped: daemon pid still alive");
       continue;
     }
-    log.info(TAG27, `recovering ${run.pipeline} run ${run.runId} for card #${run.cardShortId}`);
+    log.info(TAG29, `recovering ${run.pipeline} run ${run.runId} for card #${run.cardShortId}`);
     await recoverRun(run, store, client, config, outcome);
   }
   return outcomes;
@@ -6324,7 +7102,7 @@ async function recoverRun(run, store, client, config, outcome) {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     outcome.errors.push(`endAgentSession: ${msg}`);
-    log.warn(TAG27, `endAgentSession failed for ${run.cardId}: ${msg}`);
+    log.warn(TAG29, `endAgentSession failed for ${run.cardId}: ${msg}`);
   }
   const card = await fetchCardSafely(client, run.cardId);
   if (card) {
@@ -6367,9 +7145,9 @@ async function recoverRun(run, store, client, config, outcome) {
     const msg = err instanceof Error ? err.message : String(err);
     outcome.errors.push(`endRun: ${msg}`);
   }
-  log.info(TAG27, `recovered run ${run.runId} (card #${run.cardShortId}): ${outcome.actions.join(", ")}${outcome.errors.length ? ` | errors: ${outcome.errors.join("; ")}` : ""}`);
+  log.info(TAG29, `recovered run ${run.runId} (card #${run.cardShortId}): ${outcome.actions.join(", ")}${outcome.errors.length ? ` | errors: ${outcome.errors.join("; ")}` : ""}`);
 }
-var TAG27 = "recovery", RECOVERED_LABEL = "agent-recovered", RECOVERED_LABEL_COLOR = "#f59e0b";
+var TAG29 = "recovery", RECOVERED_LABEL = "agent-recovered", RECOVERED_LABEL_COLOR = "#f59e0b";
 var init_recovery = __esm(() => {
   init_board_helpers();
   init_log();
@@ -6417,7 +7195,7 @@ class Reconciler {
       clearInterval(this.timer);
       this.timer = null;
     }
-    log.info(TAG28, "Heartbeat stopped");
+    log.info(TAG30, "Heartbeat stopped");
   }
   async recoverStaleRuns() {
     if (!this.stateStore || !this.agentConfig)
@@ -6434,7 +7212,7 @@ class Reconciler {
       if (!daemonDead && !(heartbeatStale && ourZombie))
         continue;
       const reason = daemonDead ? `foreign daemon ${run.daemonPid} is dead` : `our worker lost card ${run.cardId} with ${Math.round((now - run.lastHeartbeatAt) / 1000)}s stale heartbeat`;
-      log.warn(TAG28, `zombie run ${run.runId} (#${run.cardShortId}): ${reason} — recovering`);
+      log.warn(TAG30, `zombie run ${run.runId} (#${run.cardShortId}): ${reason} — recovering`);
       await recoverRun(run, this.stateStore, this.client, this.agentConfig, {
         runId: run.runId,
         cardId: run.cardId,
@@ -6461,11 +7239,11 @@ class Reconciler {
       const stalledAt = Date.parse(card.updated_at ?? "");
       if (!Number.isFinite(stalledAt) || now - stalledAt < graceMs)
         continue;
-      log.warn(TAG28, `#${card.short_id} stranded in "${inProgressCol.name}" (no live run) — requeueing to "${pickupCol.name}"`);
+      log.warn(TAG30, `#${card.short_id} stranded in "${inProgressCol.name}" (no live run) — requeueing to "${pickupCol.name}"`);
       try {
         await this.client.moveCard(card.id, pickupCol.id);
       } catch (err) {
-        log.error(TAG28, `stranded requeue failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log.error(TAG30, `stranded requeue failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -6488,11 +7266,11 @@ class Reconciler {
       const parkedAt = Date.parse(card.updated_at ?? "");
       if (!Number.isFinite(parkedAt) || now - parkedAt < ttlMs)
         continue;
-      log.warn(TAG28, `#${card.short_id} parked for approval > ${planning.approvalTtlHours}h — auto-releasing to "${pickupCol.name}"`);
+      log.warn(TAG30, `#${card.short_id} parked for approval > ${planning.approvalTtlHours}h — auto-releasing to "${pickupCol.name}"`);
       try {
         await this.client.moveCard(card.id, pickupCol.id);
       } catch (err) {
-        log.error(TAG28, `auto-release failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log.error(TAG30, `auto-release failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -6521,18 +7299,18 @@ class Reconciler {
           const subtasks = card.subtasks ?? [];
           const mode = reviewColumnIds.has(card.column_id) ? "review" : "implement";
           if (mode === "review" && this.approvedLabel && hasLabel(cardLabels, this.approvedLabel)) {
-            log.debug(TAG28, `Skipping #${card.short_id} — already has "${this.approvedLabel}" label`);
+            log.debug(TAG30, `Skipping #${card.short_id} — already has "${this.approvedLabel}" label`);
             continue;
           }
           if (mode === "review" && hasLabel(cardLabels, NEED_REVIEW_LABEL)) {
-            log.debug(TAG28, `Skipping #${card.short_id} — has "${NEED_REVIEW_LABEL}" label (needs human)`);
+            log.debug(TAG30, `Skipping #${card.short_id} — has "${NEED_REVIEW_LABEL}" label (needs human)`);
             continue;
           }
           if (mode === "review" && !extractBranchFromDescription(card.description)) {
-            log.debug(TAG28, `Skipping #${card.short_id} — no branch reference (not qualified for auto-review)`);
+            log.debug(TAG30, `Skipping #${card.short_id} — no branch reference (not qualified for auto-review)`);
             continue;
           }
-          log.info(TAG28, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — enqueueing`);
+          log.info(TAG30, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — enqueueing`);
           await this.pool.enqueue(card, column, cardLabels, subtasks, mode);
         }
       }
@@ -6542,18 +7320,18 @@ class Reconciler {
       await this.recoverStrandedInProgress(cards, columns, knownCardIds);
       for (const knownId of knownCardIds) {
         if (!allAgentCardIds.has(knownId)) {
-          log.info(TAG28, `Missed unassign: ${knownId} — removing`);
+          log.info(TAG30, `Missed unassign: ${knownId} — removing`);
           await this.pool.removeCard(knownId);
         }
       }
       await this.releaseStalledApprovals(cards, columns, knownCardIds);
-      log.debug(TAG28, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
+      log.debug(TAG30, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
     } catch (err) {
-      log.error(TAG28, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG30, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG28 = "reconcile";
+var TAG30 = "reconcile";
 var init_reconcile = __esm(() => {
   init_board_helpers();
   init_log();
@@ -6591,7 +7369,7 @@ function prettyBanner(config, version) {
       checks.push({ kind: "ok", message });
     },
     warn(message) {
-      log.warn(TAG29, message);
+      log.warn(TAG31, message);
       checks.push({ kind: "warn", message: message.split(`
 `, 1)[0] });
     },
@@ -6616,25 +7394,25 @@ function prettyBanner(config, version) {
   };
 }
 function jsonBanner(config, version) {
-  log.info(TAG29, `Harmony Agent Daemon v${version} starting...`);
-  log.info(TAG29, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Model: ${config.agent.claude.model} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
+  log.info(TAG31, `Harmony Agent Daemon v${version} starting...`);
+  log.info(TAG31, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Model: ${config.agent.claude.model} | Runner: ${config.agent.runner} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
   if (config.agent.review.enabled) {
-    log.info(TAG29, `Review: enabled | Columns: ${config.agent.review.pickupColumns.join(", ")} | → ${config.agent.review.moveToColumn} / ${config.agent.review.failColumn}`);
+    log.info(TAG31, `Review: enabled | Columns: ${config.agent.review.pickupColumns.join(", ")} | → ${config.agent.review.moveToColumn} / ${config.agent.review.failColumn}`);
   }
   let failed = false;
   return {
     setProjectName(_name) {},
     setGitProvider(provider) {
-      log.info(TAG29, `Git provider: ${provider}`);
+      log.info(TAG31, `Git provider: ${provider}`);
     },
     setHttpPort(port) {
-      log.info(TAG29, `HTTP server on port ${port}`);
+      log.info(TAG31, `HTTP server on port ${port}`);
     },
     check(message) {
-      log.info(TAG29, message);
+      log.info(TAG31, message);
     },
     warn(message) {
-      log.warn(TAG29, message);
+      log.warn(TAG31, message);
     },
     fail() {
       failed = true;
@@ -6642,7 +7420,7 @@ function jsonBanner(config, version) {
     async ready(message) {
       if (failed)
         return;
-      log.info(TAG29, message);
+      log.info(TAG31, message);
     }
   };
 }
@@ -6688,6 +7466,7 @@ function configRows(config, projectName, gitProvider, httpPort) {
     label: "Model",
     value: `${modelDesc}  ·  ${poolDesc}  ·  ${flowDesc}`
   });
+  rows.push({ label: "Runner", value: runnerDesc(config.agent.runner) });
   const tail = [];
   if (gitProvider)
     tail.push(gitProvider);
@@ -6705,6 +7484,9 @@ function titleRule(title) {
   const suffix = "─".repeat(Math.max(3, RULE_WIDTH - prefix.length - title.length - surround.length));
   return dim(`${prefix}${title}${surround}${suffix}`);
 }
+function runnerDesc(runner) {
+  return runner === "sdk" ? "sdk (Agent SDK)" : "cli (Claude CLI)";
+}
 function shortenId(id) {
   if (id.length <= 8)
     return id;
@@ -6719,7 +7501,7 @@ function cyan(s) {
 function yellow(s) {
   return `${ANSI.yellow}${s}${ANSI.reset}`;
 }
-var TAG29 = "daemon", RULE_WIDTH = 70, ANSI;
+var TAG31 = "daemon", RULE_WIDTH = 70, ANSI;
 var init_startup_banner = __esm(() => {
   init_log();
   ANSI = {
@@ -6866,18 +7648,18 @@ class Watcher {
   }
   async start() {
     if (!isPretty()) {
-      log.info(TAG30, "Connecting to Supabase realtime (broadcast)...");
+      log.info(TAG32, "Connecting to Supabase realtime (broadcast)...");
     }
     this.supabase = createClient(this.credentials.supabaseUrl, this.credentials.supabaseAnonKey);
     const presenceChannel = this.supabase.channel(`board-presence-${this.projectId}`);
     const channel = this.supabase.channel(`board-${this.projectId}`).on("broadcast", { event: "card_update" }, (msg) => {
-      log.debug(TAG30, `Broadcast: card_update ${JSON.stringify(msg.payload)}`);
+      log.debug(TAG32, `Broadcast: card_update ${JSON.stringify(msg.payload)}`);
       this.onCardBroadcast({
         event: "card_update",
         payload: msg.payload ?? {}
       });
     }).on("broadcast", { event: "card_created" }, (msg) => {
-      log.debug(TAG30, `Broadcast: card_created ${JSON.stringify(msg.payload)}`);
+      log.debug(TAG32, `Broadcast: card_created ${JSON.stringify(msg.payload)}`);
       this.onCardBroadcast({
         event: "card_created",
         payload: msg.payload ?? {}
@@ -6887,29 +7669,29 @@ class Watcher {
       const cardId = payload.card_id;
       const command = payload.command;
       if (cardId && command) {
-        log.info(TAG30, `Broadcast: agent_command ${command} for ${cardId}`);
+        log.info(TAG32, `Broadcast: agent_command ${command} for ${cardId}`);
         this.onAgentCommand?.({ cardId, command });
       }
     }).subscribe((status) => {
       if (status === "SUBSCRIBED") {
         this.connected = true;
         if (!isPretty() || !this.suppressStartupLogs) {
-          log.info(TAG30, "Broadcast subscription active");
+          log.info(TAG32, "Broadcast subscription active");
         }
         this.maybeResolveReady();
       } else if (status === "CHANNEL_ERROR") {
         this.connected = false;
-        log.error(TAG30, "Broadcast channel error — will rely on reconciliation");
+        log.error(TAG32, "Broadcast channel error — will rely on reconciliation");
       } else if (status === "TIMED_OUT") {
         this.connected = false;
-        log.warn(TAG30, "Broadcast subscription timed out — retrying...");
+        log.warn(TAG32, "Broadcast subscription timed out — retrying...");
       } else if (status === "CLOSED") {
         this.connected = false;
       }
     });
     this.channel = channel;
     presenceChannel.on("presence", { event: "sync" }, () => {
-      log.debug(TAG30, "Presence sync");
+      log.debug(TAG32, "Presence sync");
     }).subscribe(async (status) => {
       if (status === "SUBSCRIBED") {
         await presenceChannel.track({
@@ -6922,7 +7704,7 @@ class Watcher {
           agentName: this.identity.agentName
         });
         if (!isPretty() || !this.suppressStartupLogs) {
-          log.info(TAG30, "Presence tracked on board-presence channel");
+          log.info(TAG32, "Presence tracked on board-presence channel");
         }
         this.presenceTracked = true;
         this.maybeResolveReady();
@@ -6944,10 +7726,10 @@ class Watcher {
       this.supabase = null;
     }
     this.connected = false;
-    log.info(TAG30, "Broadcast subscription stopped");
+    log.info(TAG32, "Broadcast subscription stopped");
   }
 }
-var TAG30 = "watcher";
+var TAG32 = "watcher";
 var init_watcher = __esm(() => {
   init_log();
 });
@@ -6960,7 +7742,7 @@ __export(exports_worktree_gc, {
   isTransientGitNetworkError: () => isTransientGitNetworkError,
   WorktreeGc: () => WorktreeGc
 });
-import { execFileSync as execFileSync10 } from "node:child_process";
+import { execFileSync as execFileSync11 } from "node:child_process";
 import { readdirSync as readdirSync2, statSync as statSync2 } from "node:fs";
 import { resolve as resolve3 } from "node:path";
 function isTransientGitNetworkError(message) {
@@ -7028,16 +7810,16 @@ function runWorktreeGc(basePath, store, opts = {}) {
     }
   }
   try {
-    execFileSync10("git", ["worktree", "prune", "--expire=now"], {
+    execFileSync11("git", ["worktree", "prune", "--expire=now"], {
       cwd: repoRoot,
       stdio: "pipe"
     });
   } catch {}
   if (result.removed.length > 0) {
-    log.info(TAG31, `GC removed ${result.removed.length} orphan worktree(s): ${result.removed.map((p) => p.split("/").pop()).join(", ")}`);
+    log.info(TAG33, `GC removed ${result.removed.length} orphan worktree(s): ${result.removed.map((p) => p.split("/").pop()).join(", ")}`);
   }
   if (result.errors.length > 0) {
-    log.warn(TAG31, `GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.path}: ${e.error}`).join("; ")}`);
+    log.warn(TAG33, `GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.path}: ${e.error}`).join("; ")}`);
   }
   return result;
 }
@@ -7059,7 +7841,7 @@ function pruneFailedRemoteBranches(opts) {
     return result;
   }
   try {
-    execFileSync10("git", ["fetch", "--prune", "origin"], {
+    execFileSync11("git", ["fetch", "--prune", "origin"], {
       cwd: repoRoot,
       stdio: "pipe",
       ...GIT_NETWORK_EXEC
@@ -7067,7 +7849,7 @@ function pruneFailedRemoteBranches(opts) {
   } catch (err) {
     const detail = gitErrorDetail(err);
     if (isTransientGitNetworkError(detail)) {
-      log.debug(TAG31, `Remote branch GC skipped — remote unreachable: ${detail}`);
+      log.debug(TAG33, `Remote branch GC skipped — remote unreachable: ${detail}`);
       return result;
     }
     result.errors.push({ ref: "fetch", error: detail });
@@ -7075,7 +7857,7 @@ function pruneFailedRemoteBranches(opts) {
   const refPattern = `refs/remotes/origin/${opts.prefix}*`;
   let listing = "";
   try {
-    listing = execFileSync10("git", [
+    listing = execFileSync11("git", [
       "for-each-ref",
       "--format=%(refname:strip=3) %(committerdate:unix)",
       refPattern
@@ -7106,11 +7888,11 @@ function pruneFailedRemoteBranches(opts) {
       continue;
     }
     if (clock() > sweepDeadline) {
-      log.debug(TAG31, `Remote branch GC budget spent — removed ${result.removed.length}, remaining deferred to next tick`);
+      log.debug(TAG33, `Remote branch GC budget spent — removed ${result.removed.length}, remaining deferred to next tick`);
       break;
     }
     try {
-      execFileSync10("git", ["push", "origin", `:refs/heads/${ref}`], {
+      execFileSync11("git", ["push", "origin", `:refs/heads/${ref}`], {
         cwd: repoRoot,
         stdio: "pipe",
         ...GIT_NETWORK_EXEC
@@ -7119,17 +7901,17 @@ function pruneFailedRemoteBranches(opts) {
     } catch (err) {
       const detail = gitErrorDetail(err);
       if (isTransientGitNetworkError(detail)) {
-        log.debug(TAG31, `Remote branch GC interrupted — remote unreachable: ${detail}`);
+        log.debug(TAG33, `Remote branch GC interrupted — remote unreachable: ${detail}`);
         break;
       }
       result.errors.push({ ref, error: detail });
     }
   }
   if (result.removed.length > 0) {
-    log.info(TAG31, `Pruned ${result.removed.length} stale remote branch(es) under ${opts.prefix}: ${result.removed.join(", ")}`);
+    log.info(TAG33, `Pruned ${result.removed.length} stale remote branch(es) under ${opts.prefix}: ${result.removed.join(", ")}`);
   }
   if (result.errors.length > 0) {
-    log.warn(TAG31, `Remote branch GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.ref}: ${e.error}`).join("; ")}`);
+    log.warn(TAG33, `Remote branch GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.ref}: ${e.error}`).join("; ")}`);
   }
   return result;
 }
@@ -7160,27 +7942,27 @@ class WorktreeGc {
     try {
       runWorktreeGc(this.basePath, this.store);
     } catch (err) {
-      log.warn(TAG31, `GC tick failed: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG33, `GC tick failed: ${err instanceof Error ? err.message : err}`);
     }
     if (this.remoteOpts) {
       try {
         pruneFailedRemoteBranches(this.remoteOpts);
       } catch (err) {
-        log.warn(TAG31, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
+        log.warn(TAG33, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
 }
 function getRepoRoot2() {
   try {
-    return execFileSync10("git", ["rev-parse", "--show-toplevel"], {
+    return execFileSync11("git", ["rev-parse", "--show-toplevel"], {
       encoding: "utf-8"
     }).trim();
   } catch {
     return null;
   }
 }
-var TAG31 = "worktree-gc", GIT_NETWORK_TIMEOUT_MS = 30000, GIT_SSH_CONNECT_TIMEOUT_SECS = 10, GIT_PRUNE_SWEEP_BUDGET_MS = 60000, GIT_NETWORK_EXEC, TRANSIENT_GIT_NETWORK_ERROR;
+var TAG33 = "worktree-gc", GIT_NETWORK_TIMEOUT_MS = 30000, GIT_SSH_CONNECT_TIMEOUT_SECS = 10, GIT_PRUNE_SWEEP_BUDGET_MS = 60000, GIT_NETWORK_EXEC, TRANSIENT_GIT_NETWORK_ERROR;
 var init_worktree_gc = __esm(() => {
   init_log();
   init_worktree();
@@ -7214,12 +7996,12 @@ __export(exports_src, {
   validatePrerequisites: () => validatePrerequisites,
   main: () => main
 });
-import { execFileSync as execFileSync11 } from "node:child_process";
+import { execFileSync as execFileSync12 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
 import { createRequire as createRequire2 } from "node:module";
 async function validatePrerequisites(config, banner) {
   try {
-    const ver = execFileSync11("claude", ["--version"], {
+    const ver = execFileSync12("claude", ["--version"], {
       encoding: "utf-8"
     }).trim();
     banner.check(`Claude CLI ${ver}`);
@@ -7234,14 +8016,14 @@ async function validatePrerequisites(config, banner) {
     validateGitProviderCli(provider);
   }
   try {
-    const status = execFileSync11("git", ["status", "--porcelain"], {
+    const status = execFileSync12("git", ["status", "--porcelain"], {
       encoding: "utf-8"
     }).trim();
     if (status) {
       banner.warn(`Working directory has uncommitted changes:
 ${status}`);
     }
-    execFileSync11("git", ["rev-parse", "--verify", `origin/${config.agent.worktree.baseBranch}`], {
+    execFileSync12("git", ["rev-parse", "--verify", `origin/${config.agent.worktree.baseBranch}`], {
       encoding: "utf-8",
       stdio: "pipe"
     });
@@ -7284,7 +8066,7 @@ async function main() {
   } catch (err) {
     if (err instanceof ConfigValidationError) {
       banner.fail();
-      log.error(TAG32, err.message);
+      log.error(TAG34, err.message);
       process.exit(1);
     }
     throw err;
@@ -7352,6 +8134,7 @@ async function main() {
         daemonPid: process.pid,
         startedAt,
         uptimeMs: Date.now() - startedAt,
+        runner: config.agent.runner,
         workers: pool.snapshotWorkers().map((w) => ({
           ...w,
           phase: null
@@ -7393,7 +8176,7 @@ async function main() {
     if (shuttingDown)
       return;
     shuttingDown = true;
-    log.info(TAG32, `Received ${signal}, shutting down gracefully...`);
+    log.info(TAG34, `Received ${signal}, shutting down gracefully...`);
     reconciler.stop();
     mergeMonitor?.stop();
     worktreeGc.stop();
@@ -7403,18 +8186,18 @@ async function main() {
     }
     await watcher.stop();
     await pool.shutdown();
-    log.info(TAG32, "Daemon stopped.");
+    log.info(TAG34, "Daemon stopped.");
     process.exit(exitCode);
   };
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("uncaughtException", (err) => {
-    log.error(TAG32, `Uncaught exception: ${err.message}`);
+    log.error(TAG34, `Uncaught exception: ${err.message}`);
     exitCode = 1;
     shutdown("uncaughtException");
   });
   process.on("unhandledRejection", (reason) => {
-    log.error(TAG32, `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
+    log.error(TAG34, `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
     exitCode = 1;
     shutdown("unhandledRejection");
   });
@@ -7467,35 +8250,35 @@ async function handleBroadcast(event, client, pool, config, agentId) {
   if (assignedAgentId === undefined)
     return;
   if (assignedAgentId === agentId) {
-    log.info(TAG32, `Broadcast: card ${cardId} assigned to agent`);
+    log.info(TAG34, `Broadcast: card ${cardId} assigned to agent`);
     try {
       await pool.resetAttemptsForReassign(cardId);
       await tryEnqueueCard(cardId, client, pool, config, agentId);
     } catch (err) {
-      log.error(TAG32, `Failed to process assignment: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG34, `Failed to process assignment: ${err instanceof Error ? err.message : err}`);
     }
   } else if (pool.isCardKnown(cardId)) {
-    log.info(TAG32, `Broadcast: card ${cardId} unassigned from agent`);
+    log.info(TAG34, `Broadcast: card ${cardId} unassigned from agent`);
     await pool.removeCard(cardId);
   }
 }
 async function tryEnqueueCard(cardId, client, pool, config, agentId) {
   const { card } = await client.getCard(cardId);
   if (card.assigned_agent_id !== agentId) {
-    log.debug(TAG32, `Card ${cardId} no longer assigned to agent — skipping`);
+    log.debug(TAG34, `Card ${cardId} no longer assigned to agent — skipping`);
     return;
   }
   const board = await client.getBoard(config.projectId, { summary: true });
   const columns = board.columns;
   const column = columns.find((c) => c.id === card.column_id);
   if (!column) {
-    log.warn(TAG32, `Column not found for card ${cardId}`);
+    log.warn(TAG34, `Column not found for card ${cardId}`);
     return;
   }
   const isPickupColumn = config.agent.pickupColumns.some((name) => name.toLowerCase() === column.name.toLowerCase());
   const isReviewColumn = config.agent.review.enabled && config.agent.review.pickupColumns.some((name) => name.toLowerCase() === column.name.toLowerCase());
   if (!isPickupColumn && !isReviewColumn) {
-    log.info(TAG32, `Card #${card.short_id} is in "${column.name}", not a pickup/review column — skipping`);
+    log.info(TAG34, `Card #${card.short_id} is in "${column.name}", not a pickup/review column — skipping`);
     return;
   }
   const mode = isReviewColumn ? "review" : "implement";
@@ -7503,16 +8286,16 @@ async function tryEnqueueCard(cardId, client, pool, config, agentId) {
   const cardLabels = resolveCardLabels(card, labelMap);
   const subtasks = card.subtasks ?? [];
   if (mode === "review" && config.agent.review.approvedLabel && hasLabel(cardLabels, config.agent.review.approvedLabel)) {
-    log.debug(TAG32, `Card #${card.short_id} already has "${config.agent.review.approvedLabel}" — skipping review`);
+    log.debug(TAG34, `Card #${card.short_id} already has "${config.agent.review.approvedLabel}" — skipping review`);
     return;
   }
   if (mode === "review" && !extractBranchFromDescription(card.description)) {
-    log.info(TAG32, `Card #${card.short_id} has no branch reference — skipping auto-review`);
+    log.info(TAG34, `Card #${card.short_id} has no branch reference — skipping auto-review`);
     return;
   }
   await pool.enqueue(card, column, cardLabels, subtasks, mode);
 }
-var TAG32 = "daemon", PKG_VERSION;
+var TAG34 = "daemon", PKG_VERSION;
 var init_src = __esm(() => {
   init_board_helpers();
   init_config();