@gethmy/agent 1.10.9 → 1.11.1

package/dist/index.js

@@ -384,11 +384,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",
@@ -430,7 +431,7 @@ var init_types = __esm(() => {
     },
     review: {
       enabled: true,
-      poolSize: 2,
+      poolSize: 3,
       pickupColumns: ["Review"],
       moveToColumn: "Done",
       failColumn: "To Do",
@@ -562,6 +563,9 @@ function loadDaemonConfig() {
       ...agentOverrides.planning ?? {}
     }
   };
+  if (agent.runner !== "cli" && agent.runner !== "sdk") {
+    agent.runner = "cli";
+  }
   return {
     apiKey,
     apiUrl,
@@ -2580,6 +2584,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 {};
@@ -2603,14 +2614,17 @@ async function runCompletion(client, card, branchName, worktreePath, config, wor
   };
   const hasCommits = checkHasCommits(worktreePath, config.worktree.baseBranch);
   if (!hasCommits) {
-    log.warn(TAG14, `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(TAG14, `Pushing branch ${branchName} (pre-verify)...`);
   let lastPushedSha = null;
@@ -2877,6 +2891,20 @@ function signalGroup(proc, signal) {
     }
   }
 }
+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}`);
+    }
+  }
+}
 async function terminateGroup(proc, opts) {
   if (!proc.pid || proc.killed)
     return;
@@ -2928,8 +2956,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") {
@@ -2942,32 +2970,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);
@@ -2977,6 +2988,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) {
@@ -3073,16 +3115,11 @@ class ProgressTracker {
     if (PHASE_ORDER[newPhase] <= PHASE_ORDER[this.phase])
       return;
     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() {
@@ -3190,7 +3227,15 @@ class ProgressTracker {
     }).catch((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) {
@@ -3204,55 +3249,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(TAG16, `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]);
@@ -3260,7 +3256,7 @@ class ProgressTracker {
     return null;
   }
 }
-var TAG16 = "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();
@@ -3690,7 +3686,6 @@ var init_review_completion = __esm(() => {
   init_types();
   init_worktree();
 });
-
 // ../harmony-shared/dist/cardLinks.js
 var init_cardLinks = () => {};
 // ../harmony-shared/dist/classification.js
@@ -4297,6 +4292,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");
@@ -4351,6 +4350,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;
@@ -4361,10 +4363,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;
@@ -5202,6 +5205,150 @@ 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;
@@ -5252,11 +5399,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(TAG24, `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(TAG24, `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;
   }
@@ -5274,7 +5421,7 @@ async function renderCommentsSection(client, cardId) {
 
 ${section}` : "";
   } catch (err) {
-    log.warn(TAG24, "comment-thread fetch failed", {
+    log.warn(TAG25, "comment-thread fetch failed", {
       event: "comment_fetch_failed",
       error: err instanceof Error ? err.message : String(err)
     });
@@ -5324,7 +5471,7 @@ ${description}`.trim();
 ## Similar past tasks
 ${bullets}`;
   } catch (err) {
-    log.warn(TAG24, "past-episodes recall failed", {
+    log.warn(TAG25, "past-episodes recall failed", {
       event: "episode_recall_failed",
       error: err instanceof Error ? err.message : String(err)
     });
@@ -5365,13 +5512,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 TAG24 = "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;
@@ -5392,12 +5872,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) {
@@ -5444,7 +5928,7 @@ class Worker {
     }
   }
   get tag() {
-    return `${TAG25}:${this.id}`;
+    return `${TAG26}:${this.id}`;
   }
   get isIdle() {
     return this.state === "idle";
@@ -5466,6 +5950,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();
@@ -5503,9 +5989,16 @@ class Worker {
       });
       const sid = session && typeof session === "object" && "id" in session ? session.id : null;
       if (!sid) {
-        log.warn(TAG25, "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) {
@@ -5552,6 +6045,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) {
@@ -5578,9 +6074,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);
@@ -5659,6 +6163,16 @@ class Worker {
         } catch {}
         await this.recordOutcome(card.id, "failure");
       } else if (this.runId && this.aborted) {
+        try {
+          await this.client.updateCard(card.id, { assignedAgentId: null });
+        } catch (err) {
+          log.warn(this.tag, `failed to release card after stop: ${err instanceof Error ? err.message : err}`);
+        }
+        try {
+          await runTransition(this.client, card, { removeLabels: ["agent"] });
+        } catch (tErr) {
+          log.warn(this.tag, `stop label cleanup failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
+        }
         try {
           await this.stateStore.endRun(this.runId, "paused", {
             errorMessage: "cancelled",
@@ -5674,6 +6188,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);
@@ -5763,7 +6297,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
@@ -5798,7 +6334,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
@@ -5892,7 +6430,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;
@@ -5909,6 +6480,7 @@ class Worker {
         String(maxTurns),
         "--allowedTools",
         allowedTools,
+        ...opts.resumeSessionId ? ["--resume", opts.resumeSessionId] : [],
         ...this.config.claude.additionalArgs,
         "--",
         prompt
@@ -5928,10 +6500,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) {
@@ -5955,14 +6528,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) {
@@ -5972,6 +6547,7 @@ class Worker {
 `);
           runLog.stream.end();
         }
+        reapGroup(leaderPid);
         if (this.aborted) {
           resolve3();
         } else if (code === 0) {
@@ -5984,11 +6560,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) {
@@ -6013,9 +6679,10 @@ class Worker {
     this.runTurns = 0;
   }
 }
-var TAG25 = "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();
@@ -6025,6 +6692,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();
@@ -6083,39 +6751,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(TAG26, `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(TAG26, `#${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(TAG26, `#${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(TAG26, `#${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(TAG26, `#${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(TAG26, `#${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(TAG26, `#${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;
       }
@@ -6144,7 +6812,7 @@ class Pool {
       });
       this.lastWaitingEmit.set(cardId, currentTask);
     } catch (err) {
-      log.debug(TAG26, `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) {
@@ -6152,7 +6820,7 @@ class Pool {
       return;
     if (err.kind === "auth") {
       if (!this.authPaused) {
-        log.error(TAG26, "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;
@@ -6161,7 +6829,7 @@ class Pool {
     const until = Date.now() + cooldownMs;
     if (until > this.apiCooldownUntil) {
       this.apiCooldownUntil = until;
-      log.warn(TAG26, `${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() {
@@ -6174,13 +6842,13 @@ class Pool {
       const removed = queue.remove(cardId);
       if (removed) {
         this.cardDataCache.delete(cardId);
-        log.info(TAG26, `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(TAG26, `Cancelling worker ${worker.id} for card ${cardId}`);
+      log.info(TAG27, `Cancelling worker ${worker.id} for card ${cardId}`);
       await worker.cancel();
     }
   }
@@ -6213,10 +6881,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(TAG26, `No active worker for card ${cardId}, ignoring ${command}`);
+      log.debug(TAG27, `No active worker for card ${cardId}, ignoring ${command}`);
       return;
     }
-    log.info(TAG26, `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();
@@ -6264,7 +6932,7 @@ class Pool {
     };
   }
   async shutdown() {
-    log.info(TAG26, "Shutting down pool...");
+    log.info(TAG27, "Shutting down pool...");
     this.shuttingDown = true;
     const active = [
       ...this.implWorkers.filter((w) => w.isActive),
@@ -6272,7 +6940,7 @@ class Pool {
     ];
     await Promise.all(active.map((w) => w.cancel()));
     this.sleepGuard.stop();
-    log.info(TAG26, "Pool shutdown complete");
+    log.info(TAG27, "Pool shutdown complete");
   }
   cardDataCache = new Map;
   tryDispatchFor(workers, queue, label) {
@@ -6280,7 +6948,7 @@ class Pool {
       return false;
     const idle = workers.find((w) => w.isIdle);
     if (!idle) {
-      log.debug(TAG26, `No idle ${label} workers (queue: ${queue.length})`);
+      log.debug(TAG27, `No idle ${label} workers (queue: ${queue.length})`);
       return false;
     }
     const next = queue.dequeue();
@@ -6288,18 +6956,18 @@ class Pool {
       return false;
     const data = this.cardDataCache.get(next.cardId);
     if (!data) {
-      log.warn(TAG26, `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(TAG26, `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 TAG26 = "pool";
+var TAG27 = "pool";
 var init_pool = __esm(() => {
   init_error_classifier();
   init_log();
@@ -6341,7 +7009,7 @@ function load(path) {
       return parsed;
     return {};
   } catch (err) {
-    log.warn(TAG27, `failed to read ${path}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG28, `failed to read ${path}: ${err instanceof Error ? err.message : err}`);
     return {};
   }
 }
@@ -6359,7 +7027,7 @@ function recordDaemonPort(projectId, entry, path = defaultRegistryPath()) {
     registry[projectId] = { ...entry, updatedAt: Date.now() };
     save(path, registry);
   } catch (err) {
-    log.warn(TAG27, `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()) {
@@ -6375,10 +7043,10 @@ function clearDaemonPort(projectId, pid, path = defaultRegistryPath()) {
     delete registry[projectId];
     save(path, registry);
   } catch (err) {
-    log.warn(TAG27, `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 TAG27 = "port-registry";
+var TAG28 = "port-registry";
 var init_port_registry = __esm(() => {
   init_log();
 });
@@ -6399,7 +7067,7 @@ async function fetchCardSafely(client, cardId) {
     const { card } = await client.getCard(cardId);
     return card;
   } catch (err) {
-    log.warn(TAG28, `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;
   }
 }
@@ -6409,7 +7077,7 @@ async function recoverOrphans(store, client, config) {
     return [];
   }
   const outcomes = [];
-  log.info(TAG28, `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,
@@ -6421,11 +7089,11 @@ async function recoverOrphans(store, client, config) {
     };
     outcomes.push(outcome);
     if (isProcessAlive(run.daemonPid, process.pid)) {
-      log.warn(TAG28, `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(TAG28, `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;
@@ -6443,7 +7111,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(TAG28, `endAgentSession failed for ${run.cardId}: ${msg}`);
+    log.warn(TAG29, `endAgentSession failed for ${run.cardId}: ${msg}`);
   }
   const card = await fetchCardSafely(client, run.cardId);
   if (card) {
@@ -6486,9 +7154,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(TAG28, `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 TAG28 = "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();
@@ -6536,7 +7204,7 @@ class Reconciler {
       clearInterval(this.timer);
       this.timer = null;
     }
-    log.info(TAG29, "Heartbeat stopped");
+    log.info(TAG30, "Heartbeat stopped");
   }
   async recoverStaleRuns() {
     if (!this.stateStore || !this.agentConfig)
@@ -6553,7 +7221,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(TAG29, `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,
@@ -6580,11 +7248,11 @@ class Reconciler {
       const stalledAt = Date.parse(card.updated_at ?? "");
       if (!Number.isFinite(stalledAt) || now - stalledAt < graceMs)
         continue;
-      log.warn(TAG29, `#${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(TAG29, `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}`);
       }
     }
   }
@@ -6607,11 +7275,11 @@ class Reconciler {
       const parkedAt = Date.parse(card.updated_at ?? "");
       if (!Number.isFinite(parkedAt) || now - parkedAt < ttlMs)
         continue;
-      log.warn(TAG29, `#${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(TAG29, `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}`);
       }
     }
   }
@@ -6640,18 +7308,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(TAG29, `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(TAG29, `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(TAG29, `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(TAG29, `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);
         }
       }
@@ -6661,18 +7329,18 @@ class Reconciler {
       await this.recoverStrandedInProgress(cards, columns, knownCardIds);
       for (const knownId of knownCardIds) {
         if (!allAgentCardIds.has(knownId)) {
-          log.info(TAG29, `Missed unassign: ${knownId} — removing`);
+          log.info(TAG30, `Missed unassign: ${knownId} — removing`);
           await this.pool.removeCard(knownId);
         }
       }
       await this.releaseStalledApprovals(cards, columns, knownCardIds);
-      log.debug(TAG29, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
+      log.debug(TAG30, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
     } catch (err) {
-      log.error(TAG29, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG30, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG29 = "reconcile";
+var TAG30 = "reconcile";
 var init_reconcile = __esm(() => {
   init_board_helpers();
   init_log();
@@ -6710,7 +7378,7 @@ function prettyBanner(config, version) {
       checks.push({ kind: "ok", message });
     },
     warn(message) {
-      log.warn(TAG30, message);
+      log.warn(TAG31, message);
       checks.push({ kind: "warn", message: message.split(`
 `, 1)[0] });
     },
@@ -6735,25 +7403,25 @@ function prettyBanner(config, version) {
   };
 }
 function jsonBanner(config, version) {
-  log.info(TAG30, `Harmony Agent Daemon v${version} starting...`);
-  log.info(TAG30, `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(TAG30, `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(TAG30, `Git provider: ${provider}`);
+      log.info(TAG31, `Git provider: ${provider}`);
     },
     setHttpPort(port) {
-      log.info(TAG30, `HTTP server on port ${port}`);
+      log.info(TAG31, `HTTP server on port ${port}`);
     },
     check(message) {
-      log.info(TAG30, message);
+      log.info(TAG31, message);
     },
     warn(message) {
-      log.warn(TAG30, message);
+      log.warn(TAG31, message);
     },
     fail() {
       failed = true;
@@ -6761,7 +7429,7 @@ function jsonBanner(config, version) {
     async ready(message) {
       if (failed)
         return;
-      log.info(TAG30, message);
+      log.info(TAG31, message);
     }
   };
 }
@@ -6807,6 +7475,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);
@@ -6824,6 +7493,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;
@@ -6838,7 +7510,7 @@ function cyan(s) {
 function yellow(s) {
   return `${ANSI.yellow}${s}${ANSI.reset}`;
 }
-var TAG30 = "daemon", RULE_WIDTH = 70, ANSI;
+var TAG31 = "daemon", RULE_WIDTH = 70, ANSI;
 var init_startup_banner = __esm(() => {
   init_log();
   ANSI = {
@@ -6985,18 +7657,18 @@ class Watcher {
   }
   async start() {
     if (!isPretty()) {
-      log.info(TAG31, "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(TAG31, `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(TAG31, `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 ?? {}
@@ -7006,29 +7678,29 @@ class Watcher {
       const cardId = payload.card_id;
       const command = payload.command;
       if (cardId && command) {
-        log.info(TAG31, `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(TAG31, "Broadcast subscription active");
+          log.info(TAG32, "Broadcast subscription active");
         }
         this.maybeResolveReady();
       } else if (status === "CHANNEL_ERROR") {
         this.connected = false;
-        log.error(TAG31, "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(TAG31, "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(TAG31, "Presence sync");
+      log.debug(TAG32, "Presence sync");
     }).subscribe(async (status) => {
       if (status === "SUBSCRIBED") {
         await presenceChannel.track({
@@ -7041,7 +7713,7 @@ class Watcher {
           agentName: this.identity.agentName
         });
         if (!isPretty() || !this.suppressStartupLogs) {
-          log.info(TAG31, "Presence tracked on board-presence channel");
+          log.info(TAG32, "Presence tracked on board-presence channel");
         }
         this.presenceTracked = true;
         this.maybeResolveReady();
@@ -7063,10 +7735,10 @@ class Watcher {
       this.supabase = null;
     }
     this.connected = false;
-    log.info(TAG31, "Broadcast subscription stopped");
+    log.info(TAG32, "Broadcast subscription stopped");
   }
 }
-var TAG31 = "watcher";
+var TAG32 = "watcher";
 var init_watcher = __esm(() => {
   init_log();
 });
@@ -7153,10 +7825,10 @@ function runWorktreeGc(basePath, store, opts = {}) {
     });
   } catch {}
   if (result.removed.length > 0) {
-    log.info(TAG32, `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(TAG32, `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;
 }
@@ -7186,7 +7858,7 @@ function pruneFailedRemoteBranches(opts) {
   } catch (err) {
     const detail = gitErrorDetail(err);
     if (isTransientGitNetworkError(detail)) {
-      log.debug(TAG32, `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 });
@@ -7225,7 +7897,7 @@ function pruneFailedRemoteBranches(opts) {
       continue;
     }
     if (clock() > sweepDeadline) {
-      log.debug(TAG32, `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 {
@@ -7238,17 +7910,17 @@ function pruneFailedRemoteBranches(opts) {
     } catch (err) {
       const detail = gitErrorDetail(err);
       if (isTransientGitNetworkError(detail)) {
-        log.debug(TAG32, `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(TAG32, `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(TAG32, `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;
 }
@@ -7279,13 +7951,13 @@ class WorktreeGc {
     try {
       runWorktreeGc(this.basePath, this.store);
     } catch (err) {
-      log.warn(TAG32, `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(TAG32, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
+        log.warn(TAG33, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -7299,7 +7971,7 @@ function getRepoRoot2() {
     return null;
   }
 }
-var TAG32 = "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();
@@ -7403,7 +8075,7 @@ async function main() {
   } catch (err) {
     if (err instanceof ConfigValidationError) {
       banner.fail();
-      log.error(TAG33, err.message);
+      log.error(TAG34, err.message);
       process.exit(1);
     }
     throw err;
@@ -7471,6 +8143,7 @@ async function main() {
         daemonPid: process.pid,
         startedAt,
         uptimeMs: Date.now() - startedAt,
+        runner: config.agent.runner,
         workers: pool.snapshotWorkers().map((w) => ({
           ...w,
           phase: null
@@ -7512,7 +8185,7 @@ async function main() {
     if (shuttingDown)
       return;
     shuttingDown = true;
-    log.info(TAG33, `Received ${signal}, shutting down gracefully...`);
+    log.info(TAG34, `Received ${signal}, shutting down gracefully...`);
     reconciler.stop();
     mergeMonitor?.stop();
     worktreeGc.stop();
@@ -7522,18 +8195,18 @@ async function main() {
     }
     await watcher.stop();
     await pool.shutdown();
-    log.info(TAG33, "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(TAG33, `Uncaught exception: ${err.message}`);
+    log.error(TAG34, `Uncaught exception: ${err.message}`);
     exitCode = 1;
     shutdown("uncaughtException");
   });
   process.on("unhandledRejection", (reason) => {
-    log.error(TAG33, `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");
   });
@@ -7586,35 +8259,35 @@ async function handleBroadcast(event, client, pool, config, agentId) {
   if (assignedAgentId === undefined)
     return;
   if (assignedAgentId === agentId) {
-    log.info(TAG33, `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(TAG33, `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(TAG33, `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(TAG33, `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(TAG33, `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(TAG33, `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";
@@ -7622,16 +8295,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(TAG33, `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(TAG33, `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 TAG33 = "daemon", PKG_VERSION;
+var TAG34 = "daemon", PKG_VERSION;
 var init_src = __esm(() => {
   init_board_helpers();
   init_config();