@gethmy/agent 1.23.2 → 1.25.0

package/dist/cli.js

@@ -592,7 +592,6 @@ var init_agentStaleness = __esm(() => {
   SWEPT_SESSION_WRITE_GRACE_MS = 60 * 60 * 1000;
   ACTIVE_STATUSES = new Set(["working", "blocked", "waiting"]);
 });
-
 // ../harmony-shared/dist/branchRef.js
 function extractBranchRef(description) {
   if (!description)
@@ -655,6 +654,14 @@ var init_classification = __esm(() => {
   MODEL_TIERS = ["simple", "advanced", "research"];
 });
 
+// ../harmony-shared/dist/columnSort.js
+var init_columnSort = () => {};
+
+// ../harmony-shared/dist/columnCardSplit.js
+var init_columnCardSplit = __esm(() => {
+  init_columnSort();
+});
+
 // ../harmony-shared/dist/commentSerializer.js
 function sanitizeHeaderField(value) {
   return value.replace(/[\]\r\n|<>]/g, " ").trim() || "—";
@@ -835,7 +842,7 @@ function gateEvaluate(gateSpec, evidence) {
       findings: [
         {
           level: "error",
-          message: resultIsKnown ? `Gate "${spec.kind}" not satisfied: evidence result is "${String(result)}".` : `Gate "${spec.kind}" not satisfied: evidence result is missing or invalid.`
+          message: resultIsKnown ? `Gate "${spec.kind}" not satisfied: evidence result is "${String(result)}".${blockedDetail(safeStructured)}` : `Gate "${spec.kind}" not satisfied: evidence result is missing or invalid.`
         }
       ],
       structured: safeStructured
@@ -853,7 +860,7 @@ function gateEvaluate(gateSpec, evidence) {
   if (result === "blocked") {
     findings.unshift({
       level: "error",
-      message: `Gate "${spec.kind}" cannot pass: evidence result is "blocked".`
+      message: `Gate "${spec.kind}" cannot pass: evidence result is "blocked".${blockedDetail(safeStructured)}`
     });
     return { passed: false, findings, structured: safeStructured };
   }
@@ -949,6 +956,15 @@ function evaluateCondition(raw, structured) {
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function blockedDetail(structured) {
+  const reason = structured.reason;
+  if (typeof reason !== "string")
+    return "";
+  const trimmed = reason.trim();
+  if (!trimmed)
+    return "";
+  return ` ${trimmed.length > MAX_REASON_CHARS ? `${trimmed.slice(0, MAX_REASON_CHARS)}…` : trimmed}`;
+}
 function resolvePath(root, path) {
   const segments = path.split(".");
   let current = root;
@@ -1021,7 +1037,7 @@ function formatValue(value) {
     return "[unserializable]";
   }
 }
-var GATE_KINDS, GATE_OPERATORS;
+var GATE_KINDS, GATE_OPERATORS, MAX_REASON_CHARS = 400;
 var init_gateEvaluate = __esm(() => {
   GATE_KINDS = [
     "build_green",
@@ -1432,6 +1448,8 @@ var init_dist = __esm(() => {
   init_branchRef();
   init_cardLinks();
   init_classification();
+  init_columnCardSplit();
+  init_columnSort();
   init_commentSerializer();
   init_constants();
   init_gateEvaluate();
@@ -1752,7 +1770,7 @@ function agentIdentifier(workerId) {
 function endStatusForCancel(reason) {
   return reason === "human_stop" ? "cancelled" : "paused";
 }
-var DEFAULT_AGENT_CONFIG, IN_PROGRESS_COLUMN = "In Progress", NEED_REVIEW_LABEL = "Need Review", NEED_REVIEW_LABEL_COLOR = "#f59e0b", AGENT_NAME = "Harmony Agent";
+var DEFAULT_METRIC_TIMEOUT_MS = 300000, DEFAULT_AGENT_CONFIG, IN_PROGRESS_COLUMN = "In Progress", NEED_REVIEW_LABEL = "Need Review", NEED_REVIEW_LABEL_COLOR = "#f59e0b", AGENT_NAME = "Harmony Agent";
 var init_types2 = __esm(() => {
   init_board_review();
   init_contract_phase();
@@ -1845,7 +1863,7 @@ var init_types2 = __esm(() => {
       worktreeGcIntervalMs: 5 * 60000
     },
     planning: DEFAULT_PLANNING_CONFIG,
-    playbooks: { enabled: true, humanStageColumns: [] },
+    playbooks: { enabled: true, humanStageColumns: [], metrics: {} },
     contractFirst: DEFAULT_CONTRACT_CONFIG,
     boardReview: DEFAULT_BOARD_REVIEW_CONFIG
   };
@@ -5676,6 +5694,278 @@ var init_artifact_judge = __esm(() => {
   init_sdk_agent_runner();
 });
 
+// src/gate-config-error.ts
+function gateConfigErrorReason(evaluation) {
+  if (!evaluation || evaluation.passed)
+    return null;
+  const structured = evaluation.structured;
+  if (!structured || typeof structured !== "object")
+    return null;
+  if (!Object.hasOwn(structured, GATE_CONFIG_ERROR_KEY))
+    return null;
+  if (structured[GATE_CONFIG_ERROR_KEY] !== true) {
+    return null;
+  }
+  const reason = structured.reason;
+  return typeof reason === "string" && reason.trim().length > 0 ? reason.trim() : "the gate cannot be measured as configured";
+}
+var GATE_CONFIG_ERROR_KEY = "configError", GATE_CONFIG_ERROR_MARK;
+var init_gate_config_error = __esm(() => {
+  GATE_CONFIG_ERROR_MARK = Object.freeze({ [GATE_CONFIG_ERROR_KEY]: true });
+});
+
+// src/command-metric.ts
+function parseParseMode(parse) {
+  if (typeof parse !== "string" || parse.length === 0) {
+    return { kind: "invalid", reason: "`parse` must be a non-empty string" };
+  }
+  if (parse === "number")
+    return { kind: "number" };
+  if (parse.startsWith("json:")) {
+    const path = parse.slice("json:".length).trim();
+    if (!path) {
+      return { kind: "invalid", reason: '`parse` "json:" is missing a path' };
+    }
+    return { kind: "json", path };
+  }
+  return {
+    kind: "invalid",
+    reason: `unknown \`parse\` mode "${parse}" (expected "number" or "json:<path>")`
+  };
+}
+function parseMetricValue(mode, stdout) {
+  if (mode.kind === "invalid")
+    return { ok: false, reason: mode.reason };
+  if (mode.kind === "number") {
+    const trimmed = stdout.trim();
+    if (!trimmed) {
+      return {
+        ok: false,
+        reason: "command produced no output to read a number from"
+      };
+    }
+    const value = Number(trimmed);
+    if (!Number.isFinite(value)) {
+      return {
+        ok: false,
+        reason: `command output is not a finite number: ${JSON.stringify(truncate(trimmed, 120))}`
+      };
+    }
+    return { ok: true, value };
+  }
+  let doc;
+  try {
+    doc = JSON.parse(stdout);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: `command output is not valid JSON: ${msg}` };
+  }
+  const resolved = resolvePath(doc, mode.path);
+  if (resolved === undefined) {
+    return {
+      ok: false,
+      reason: `JSON path "${mode.path}" is absent in the command output`
+    };
+  }
+  if (resolved !== null && typeof resolved !== "number" && typeof resolved !== "string" && typeof resolved !== "boolean") {
+    return {
+      ok: false,
+      reason: `JSON path "${mode.path}" resolved to a ${Array.isArray(resolved) ? "array" : typeof resolved}, which no gate operator can compare`
+    };
+  }
+  return { ok: true, value: resolved };
+}
+function runMetricCommand(args) {
+  return new Promise((resolve3, reject) => {
+    let child;
+    try {
+      child = spawnInGroup(args.command, args.args, {
+        cwd: args.cwd,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      reject(err);
+      return;
+    }
+    const pgid = child.pid;
+    const chunks = [];
+    let stdoutBytes = 0;
+    let stderr = "";
+    let settled = false;
+    let killReason = null;
+    let timer;
+    let drainTimer;
+    const settle = (failure) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer)
+        clearTimeout(timer);
+      if (drainTimer)
+        clearTimeout(drainTimer);
+      reapGroup(pgid);
+      if (failure)
+        reject(failure);
+      else
+        resolve3(Buffer.concat(chunks).toString("utf8"));
+    };
+    const killTree = (reason) => {
+      if (settled || killReason)
+        return;
+      killReason = reason;
+      terminateGroup(child, {
+        sigintTimeoutMs: METRIC_SIGINT_GRACE_MS,
+        sigtermTimeoutMs: METRIC_SIGTERM_GRACE_MS
+      }).catch(() => {}).then(() => {
+        settle(reason === "timeout" ? Object.assign(new Error(`command timed out after ${args.timeoutMs}ms`), { code: "ETIMEDOUT" }) : Object.assign(new Error("stdout maxBuffer exceeded"), {
+          code: "ENOBUFS"
+        }));
+      });
+    };
+    child.stdout?.on("data", (chunk) => {
+      stdoutBytes += chunk.length;
+      if (stdoutBytes > MAX_OUTPUT_BUFFER2) {
+        killTree("overflow");
+        return;
+      }
+      chunks.push(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      if (stderr.length >= MAX_STDERR_CHARS)
+        return;
+      stderr += chunk.toString("utf8");
+    });
+    child.once("error", (err) => settle(err));
+    const settleFromExit = (code, signal) => {
+      if (drainTimer)
+        clearTimeout(drainTimer);
+      if (code === 0) {
+        settle(null);
+        return;
+      }
+      const detail = signal ? `terminated by signal ${signal}` : `exited ${code}`;
+      settle(Object.assign(new Error(`command ${detail}`), {
+        status: typeof code === "number" ? code : null,
+        stderr
+      }));
+    };
+    child.once("exit", (code, signal) => {
+      if (killReason)
+        return;
+      if (timer)
+        clearTimeout(timer);
+      reapGroup(pgid);
+      drainTimer = setTimeout(() => settleFromExit(code, signal), STDIO_DRAIN_GRACE_MS);
+      child.once("close", () => settleFromExit(code, signal));
+    });
+    timer = setTimeout(() => killTree("timeout"), args.timeoutMs);
+  });
+}
+
+class CommandMetricCollector {
+  deps;
+  kind = "custom";
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async collect(context) {
+    const name = context.gate.metric;
+    if (typeof name !== "string" || name.length === 0) {
+      return configError(null, 'Gate kind "custom" needs a `metric` name naming an allowlisted command (e.g. { "kind": "custom", "metric": "lighthouse_performance" }).');
+    }
+    const def = Object.hasOwn(this.deps.metrics, name) ? this.deps.metrics[name] : undefined;
+    if (!def) {
+      return configError(name, `Metric "${name}" is not declared in this daemon's allowlist — add it under \`agent.playbooks.metrics\` to permit it.`);
+    }
+    if (typeof def.command !== "string" || def.command.length === 0) {
+      return configError(name, `Metric "${name}" declares no \`command\`.`);
+    }
+    const mode = parseParseMode(def.parse);
+    if (mode.kind === "invalid") {
+      return configError(name, `Metric "${name}": ${mode.reason}.`);
+    }
+    const requested = typeof def.timeoutMs === "number" && def.timeoutMs > 0 ? Math.floor(def.timeoutMs) : DEFAULT_METRIC_TIMEOUT_MS;
+    const timeoutMs = Math.min(requested, MAX_METRIC_TIMEOUT_MS);
+    if (timeoutMs < requested) {
+      log.warn(TAG19, `Metric "${name}" declares timeoutMs=${requested}, clamped to the ${MAX_METRIC_TIMEOUT_MS}ms ceiling`);
+    }
+    const run = this.deps.runCommand ?? runMetricCommand;
+    let stdout;
+    try {
+      stdout = await run({
+        command: def.command,
+        args: def.args ?? [],
+        cwd: this.deps.worktreePath,
+        timeoutMs
+      });
+    } catch (err) {
+      const reason = describeRunFailure(err, timeoutMs);
+      log.warn(TAG19, `Metric "${name}" did not produce a measurement: ${reason}`);
+      return blocked(name, reason);
+    }
+    const parsed = parseMetricValue(mode, stdout);
+    if (!parsed.ok) {
+      log.warn(TAG19, `Metric "${name}" output unusable: ${parsed.reason}`);
+      return blocked(name, `Metric "${name}": ${parsed.reason}.`, stdout);
+    }
+    log.info(TAG19, `Metric "${name}" measured: ${JSON.stringify(parsed.value)}`);
+    return {
+      result: "passed",
+      structured: {
+        metric: name,
+        value: parsed.value,
+        raw: truncate(stdout, MAX_RAW_CHARS)
+      }
+    };
+  }
+}
+function blocked(metric, reason, raw) {
+  return {
+    result: "blocked",
+    structured: {
+      metric,
+      reason,
+      ...raw === undefined ? {} : { raw: truncate(raw, MAX_RAW_CHARS) }
+    }
+  };
+}
+function configError(metric, reason) {
+  const evidence = blocked(metric, reason);
+  return {
+    ...evidence,
+    structured: { ...evidence.structured, ...GATE_CONFIG_ERROR_MARK }
+  };
+}
+function describeRunFailure(err, timeoutMs) {
+  const e = err;
+  if (e?.code === "ENOBUFS") {
+    return `command produced more than ${MAX_OUTPUT_BUFFER2} bytes of output (use a flag that prints only the metric, or parse a smaller report)`;
+  }
+  if (e?.code === "ETIMEDOUT" || e?.signal === "SIGTERM") {
+    return `command timed out after ${timeoutMs}ms`;
+  }
+  if (e?.code === "ENOENT") {
+    return "command not found on PATH";
+  }
+  const stderr = typeof e?.stderr === "string" ? e.stderr : e?.stderr instanceof Buffer ? e.stderr.toString("utf8") : "";
+  const detail = stderr.trim() || String(e?.message ?? err);
+  const status = typeof e?.status === "number" ? e.status : null;
+  return status === null ? `command failed: ${truncate(detail, 400)}` : `command exited ${status}: ${truncate(detail, 400)}`;
+}
+function truncate(value, max) {
+  return value.length <= max ? value : `${value.slice(0, max)}…[truncated]`;
+}
+var TAG19 = "command-metric", MAX_RAW_CHARS = 2000, MAX_OUTPUT_BUFFER2, MAX_STDERR_CHARS, MAX_METRIC_TIMEOUT_MS = 900000, METRIC_SIGINT_GRACE_MS = 2000, METRIC_SIGTERM_GRACE_MS = 3000, STDIO_DRAIN_GRACE_MS = 500;
+var init_command_metric = __esm(() => {
+  init_dist();
+  init_gate_config_error();
+  init_log();
+  init_process_group();
+  init_types2();
+  MAX_OUTPUT_BUFFER2 = 10 * 1024 * 1024;
+  MAX_STDERR_CHARS = 64 * 1024;
+});
+
 // src/gate-collectors.ts
 async function resolveStageGate(client, card) {
   const currentStage = card.current_stage;
@@ -5694,7 +5984,7 @@ async function resolveStageGate(client, card) {
       return null;
     return { stage: resolution.stage, gate };
   } catch (err) {
-    log.warn(TAG19, `resolveStageGate failed for stage "${currentStage}": ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG20, `resolveStageGate failed for stage "${currentStage}": ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -5714,6 +6004,9 @@ function normalizeGateSpec(gate) {
   const mode = gate.mode;
   if (mode === "all" || mode === "any")
     spec.mode = mode;
+  const metric = gate.metric;
+  if (typeof metric === "string" && metric.length > 0)
+    spec.metric = metric;
   return spec;
 }
 
@@ -5811,12 +6104,15 @@ function buildGateCollectorRegistry(deps) {
   if (deps.artifact) {
     registry.artifact = new ArtifactCollector(deps.artifact);
   }
+  if (deps.command) {
+    registry.custom = new CommandMetricCollector(deps.command);
+  }
   return registry;
 }
 async function collectGateEvidence(registry, context) {
   const collector = registry[context.gate.kind];
   if (!collector) {
-    log.info(TAG19, `No collector for gate kind "${context.gate.kind}" — reporting blocked`);
+    log.info(TAG20, `No collector for gate kind "${context.gate.kind}" — reporting blocked`);
     return {
       result: "blocked",
       structured: {
@@ -5828,20 +6124,21 @@ async function collectGateEvidence(registry, context) {
     return await collector.collect(context);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    log.warn(TAG19, `Collector for "${context.gate.kind}" threw: ${msg} — reporting blocked`);
+    log.warn(TAG20, `Collector for "${context.gate.kind}" threw: ${msg} — reporting blocked`);
     return { result: "blocked", structured: { error: msg } };
   }
 }
-var TAG19 = "gate-collectors";
+var TAG20 = "gate-collectors";
 var init_gate_collectors = __esm(() => {
   init_dist();
   init_artifact_judge();
+  init_command_metric();
   init_log();
   init_verification();
 });
 
 // src/progress-tracker.ts
-function truncate(str, max) {
+function truncate2(str, max) {
   return str.length > max ? `${str.slice(0, max - 3)}...` : str;
 }
 
@@ -5865,6 +6162,7 @@ class ProgressTracker {
   filesEdited = new Set;
   filesRead = new Set;
   lastCost = null;
+  requestedModel = null;
   runEventSink = null;
   lastEmittedProgress = -1;
   lastAssistantText = "";
@@ -5882,6 +6180,9 @@ class ProgressTracker {
   setRunEventSink(sink) {
     this.runEventSink = sink;
   }
+  setRequestedModel(model) {
+    this.requestedModel = model;
+  }
   attach(parser) {
     parser.on("tool_start", (name, input) => {
       this.onToolStart(name, input);
@@ -5952,7 +6253,7 @@ class ProgressTracker {
   }
   onToolStart(name, input) {
     this.toolCallCount++;
-    log.debug(TAG20, `Tool: ${name} (count: ${this.toolCallCount}, phase: ${this.phase})`);
+    log.debug(TAG21, `Tool: ${name} (count: ${this.toolCallCount}, phase: ${this.phase})`);
     const filePath = this.extractString(input, "file_path");
     if (filePath) {
       if (EDIT_TOOLS.has(name)) {
@@ -6016,14 +6317,14 @@ class ProgressTracker {
     const firstLine = (end === -1 ? trimmed : trimmed.slice(0, end)).trim();
     if (firstLine.length >= 10 && firstLine.length <= 200) {
       if (ACTION_PREFIX.test(firstLine)) {
-        this.lastAction = truncate(firstLine, MAX_TASK_LENGTH);
+        this.lastAction = truncate2(firstLine, MAX_TASK_LENGTH);
       }
     }
   }
   transitionTo(newPhase) {
     if (PHASE_ORDER[newPhase] <= PHASE_ORDER[this.phase])
       return;
-    log.info(TAG20, `Phase: ${this.phase} → ${newPhase}`);
+    log.info(TAG21, `Phase: ${this.phase} → ${newPhase}`);
     const previousPhase = this.phase;
     this.runEventSink?.recordPhaseChanged(newPhase, previousPhase);
     this.phase = newPhase;
@@ -6072,16 +6373,16 @@ class ProgressTracker {
       }
       case "Grep": {
         const pattern = this.extractString(input, "pattern");
-        return pattern ? `Searching for "${truncate(pattern, 40)}"` : "Searching code";
+        return pattern ? `Searching for "${truncate2(pattern, 40)}"` : "Searching code";
       }
       case "Bash": {
         const cmd = this.extractString(input, "command");
-        return cmd ? `Running: ${truncate(cmd.split(`
+        return cmd ? `Running: ${truncate2(cmd.split(`
 `)[0], 80)}` : "Running command";
       }
       case "Agent": {
         const desc = this.extractString(input, "description");
-        return desc ? `Sub-agent: ${truncate(desc, 60)}` : "Delegating to sub-agent";
+        return desc ? `Sub-agent: ${truncate2(desc, 60)}` : "Delegating to sub-agent";
       }
       default: {
         if (name.startsWith("mcp__harmony__harmony_")) {
@@ -6125,12 +6426,12 @@ class ProgressTracker {
   }
   sendUpdate(currentTask) {
     this.lastUpdateAt = Date.now();
-    log.debug(TAG20, `Progress: ${this.progress}% — ${currentTask}`);
+    log.debug(TAG21, `Progress: ${this.progress}% — ${currentTask}`);
     this.client.updateAgentProgress(this.cardId, {
       agentIdentifier: agentIdentifier(this.workerId),
       agentName: AGENT_NAME,
       status: "working",
-      currentTask: truncate(currentTask, MAX_TASK_LENGTH),
+      currentTask: truncate2(currentTask, MAX_TASK_LENGTH),
       progressPercent: this.progress,
       phase: this.phase,
       filesChanged: this.filesEdited.size,
@@ -6139,16 +6440,16 @@ class ProgressTracker {
       outputTokens: this.lastCost?.totalOutputTokens ?? 0,
       cacheCreationInputTokens: this.lastCost?.totalCacheCreationInputTokens ?? 0,
       cacheReadInputTokens: this.lastCost?.totalCacheReadInputTokens ?? 0,
-      modelName: this.lastCost?.modelName,
+      modelName: this.lastCost?.modelName ?? this.requestedModel ?? undefined,
       numTurns: this.lastCost?.numTurns ?? 0
     }).catch((err) => {
-      log.warn(TAG20, `Failed to send progress update: ${err}`);
+      log.warn(TAG21, `Failed to send progress update: ${err}`);
     });
     if (this.runEventSink && this.progress !== this.lastEmittedProgress) {
       this.lastEmittedProgress = this.progress;
       this.runEventSink.recordProgress({
         progressPercent: this.progress,
-        currentTask: truncate(currentTask, MAX_TASK_LENGTH),
+        currentTask: truncate2(currentTask, MAX_TASK_LENGTH),
         phase: this.phase,
         filesChanged: this.filesEdited.size
       });
@@ -6161,7 +6462,7 @@ class ProgressTracker {
     this.heartbeatTimer = setTimeout(() => {
       if (!this.stopped) {
         const task = this.lastAction ? `Still working — ${this.lastAction}` : "Still working...";
-        this.sendUpdate(truncate(task, MAX_TASK_LENGTH));
+        this.sendUpdate(truncate2(task, MAX_TASK_LENGTH));
         this.startHeartbeat();
       }
     }, HEARTBEAT_MS);
@@ -6173,7 +6474,7 @@ class ProgressTracker {
     return null;
   }
 }
-var TAG20 = "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 TAG21 = "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_types2();
@@ -6329,7 +6630,7 @@ function parseReviewOutput(stdout) {
     try {
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object" && "verdict" in parsed) {
-        log.debug(TAG21, "Parsed review output from fenced JSON block");
+        log.debug(TAG22, "Parsed review output from fenced JSON block");
         return extractResult(parsed);
       }
     } catch {}
@@ -6355,21 +6656,21 @@ function parseReviewOutput(stdout) {
     try {
       const parsed = JSON.parse(candidates[i]);
       if (parsed && typeof parsed === "object" && "verdict" in parsed) {
-        log.debug(TAG21, "Parsed review output from raw JSON object");
+        log.debug(TAG22, "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(TAG21, `Parsed verdict via regex fallback — findings lost (${verdictMatch[1]})`);
+    log.warn(TAG22, `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(TAG21, "Failed to parse review JSON output — returning error verdict (card stays in Review)");
+  log.warn(TAG22, "Failed to parse review JSON output — returning error verdict (card stays in Review)");
   return {
     verdict: "error",
     summary: stdout.slice(0, 500),
@@ -6402,7 +6703,7 @@ async function postReviewComment(client, card, commentType, body) {
   try {
     await client.addComment(card.id, body, { commentType });
   } catch (err) {
-    log.error(TAG21, `Failed to post review comment to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log.error(TAG22, `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, resolvedFromPrUrl) {
@@ -6416,11 +6717,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(TAG21, `#${card.short_id} review output unparseable — labelling "${NEED_REVIEW_LABEL}" for manual inspection`);
+    log.warn(TAG22, `#${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(TAG21, `Failed to add "${NEED_REVIEW_LABEL}" label: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG22, `Failed to add "${NEED_REVIEW_LABEL}" label: ${err instanceof Error ? err.message : err}`);
     }
     if (config.review.postFindings) {
       const rawTail = runLogPath ? tailRunLog(runLogPath) : null;
@@ -6463,7 +6764,7 @@ ${runLogTail}
           renameRemoteBranch(branchName, newRef, worktreePath);
           approvedBranch = newRef;
         } catch (err) {
-          log.warn(TAG21, `Branch rename failed (continuing on ${branchName}): ${err instanceof Error ? err.message : err}`);
+          log.warn(TAG22, `Branch rename failed (continuing on ${branchName}): ${err instanceof Error ? err.message : err}`);
         }
       }
       if (config.review.createPR && approvedBranch) {
@@ -6484,14 +6785,14 @@ ${runLogTail}
           });
         }
       } catch (err) {
-        log.warn(TAG21, `Failed to persist PR URL to #${card.short_id} description: ${err instanceof Error ? err.message : err}`);
+        log.warn(TAG22, `Failed to persist PR URL to #${card.short_id} description: ${err instanceof Error ? err.message : err}`);
       }
     }
     if (branchName) {
       try {
         await persistReviewedSha(client, card, worktreePath);
       } catch (err) {
-        log.warn(TAG21, `Failed to persist Reviewed-SHA to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log.warn(TAG22, `Failed to persist Reviewed-SHA to #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
     if (config.review.postFindings) {
@@ -6513,7 +6814,7 @@ ${runLogTail}
       progressPercent: 100,
       ...buildTokenPayload(sessionStats)
     });
-    log.info(TAG21, `#${card.short_id} approved${prUrl ? ` — PR: ${prUrl}` : ""} — labeled "${config.review.approvedLabel}"`);
+    log.info(TAG22, `#${card.short_id} approved${prUrl ? ` — PR: ${prUrl}` : ""} — labeled "${config.review.approvedLabel}"`);
   } else {
     const reworkFindings = result.findings.filter((f) => f.relatedToDiff !== false);
     const criticalFindings = reworkFindings.filter((f) => f.severity === "critical").slice(0, MAX_FINDINGS);
@@ -6521,7 +6822,7 @@ ${runLogTail}
     const linkedFindings = [...criticalFindings, ...majorFindings];
     const minorFindings = reworkFindings.filter((f) => f.severity === "minor").slice(0, MAX_FINDINGS);
     if (currentCycle >= maxCycles) {
-      log.warn(TAG21, `#${card.short_id} reached max review cycles (${maxCycles}), moving to Done with note`);
+      log.warn(TAG22, `#${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.**",
@@ -6561,7 +6862,7 @@ ${runLogTail}
         try {
           await client.createSubtask(card.id, clampSubtaskTitle(`[${finding.severity}] ${finding.title}`));
         } catch (err) {
-          log.error(TAG21, `Failed to create finding subtask: ${err instanceof Error ? err.message : err}`);
+          log.error(TAG22, `Failed to create finding subtask: ${err instanceof Error ? err.message : err}`);
         }
       }));
       if (linkedFindings.length > 0) {
@@ -6573,7 +6874,7 @@ ${runLogTail}
         try {
           await client.createSubtask(card.id, clampSubtaskTitle(finding.title));
         } catch (err) {
-          log.error(TAG21, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
+          log.error(TAG22, `Failed to create subtask: ${err instanceof Error ? err.message : err}`);
         }
       }));
       const baseDesc = stripReviewSummary(freshDesc);
@@ -6581,7 +6882,7 @@ ${runLogTail}
       try {
         await client.updateCard(card.id, { description: updatedDesc });
       } catch (err) {
-        log.error(TAG21, `Failed to update review cycle marker: ${err instanceof Error ? err.message : err}`);
+        log.error(TAG22, `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 = [
@@ -6598,9 +6899,9 @@ ${runLogTail}
     if (config.planning.enabled && card.plan_id) {
       try {
         await client.updateCard(card.id, { needsPlanRefresh: true });
-        log.info(TAG21, `#${card.short_id} flagged needs_plan_refresh after rejected review`);
+        log.info(TAG22, `#${card.short_id} flagged needs_plan_refresh after rejected review`);
       } catch (err) {
-        log.warn(TAG21, `Failed to flag needs_plan_refresh for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log.warn(TAG22, `Failed to flag needs_plan_refresh for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
     await moveCardToColumn(client, card, config.review.failColumn);
@@ -6614,10 +6915,10 @@ ${runLogTail}
         recoveryBranch
       });
     } catch (err) {
-      log.debug(TAG21, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
+      log.debug(TAG22, `recordFailureSummary failed: ${err instanceof Error ? err.message : err}`);
     }
     if (recoveryBranch) {
-      log.info(TAG21, `#${card.short_id} recovery branch ${recoveryBranch}${recoveryUrl ? ` (${recoveryUrl})` : ""}`);
+      log.info(TAG22, `#${card.short_id} recovery branch ${recoveryBranch}${recoveryUrl ? ` (${recoveryUrl})` : ""}`);
     }
     await client.endAgentSession(card.id, {
       status: "failed",
@@ -6626,7 +6927,7 @@ ${runLogTail}
       recoveryBranch,
       ...buildTokenPayload(sessionStats)
     });
-    log.info(TAG21, `#${card.short_id} rejected (cycle ${currentCycle}/${maxCycles}) — moved to "${config.review.failColumn}"`);
+    log.info(TAG22, `#${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);
@@ -6648,7 +6949,7 @@ ${runLogTail}
     cleanupWorktree(worktreePath, branchName);
   }
 }
-var TAG21 = "review-completion", MAX_FINDINGS = 10, MAX_SUBTASK_TITLE = 120, COMMENT_BODY_BUDGET = 9500, REVIEW_MARKER = `---
+var TAG22 = "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();
@@ -6877,7 +7178,7 @@ class StateStore {
       const raw = readFileSync4(this.path, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed?.version !== SCHEMA_VERSION) {
-        log.warn(TAG22, `state file has version ${parsed?.version}, expected ${SCHEMA_VERSION} — migrating (preserving card budget/attempts, dropping in-flight runs)`);
+        log.warn(TAG23, `state file has version ${parsed?.version}, expected ${SCHEMA_VERSION} — migrating (preserving card budget/attempts, dropping in-flight runs)`);
         return {
           version: SCHEMA_VERSION,
           daemonId: null,
@@ -6898,7 +7199,7 @@ class StateStore {
         daily: parsed.daily ?? []
       };
     } catch (err) {
-      log.error(TAG22, `failed to read state file: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG23, `failed to read state file: ${err instanceof Error ? err.message : err}`);
       return emptyState();
     }
   }
@@ -7087,7 +7388,7 @@ class StateStore {
     return this.state.daily.find((d) => d.date === key)?.costCents ?? 0;
   }
 }
-var TAG22 = "state-store", SCHEMA_VERSION = 1;
+var TAG23 = "state-store", SCHEMA_VERSION = 1;
 var init_state_store = __esm(() => {
   init_log();
 });
@@ -7114,7 +7415,7 @@ function normalizeToolResultContent(raw) {
     return String(raw);
   }
 }
-var TAG23 = "stream-parser", StreamParser;
+var TAG24 = "stream-parser", StreamParser;
 var init_stream_parser = __esm(() => {
   init_log();
   StreamParser = class StreamParser extends EventEmitter {
@@ -7162,14 +7463,14 @@ var init_stream_parser = __esm(() => {
       try {
         msg = JSON.parse(line);
       } catch {
-        log.debug(TAG23, `Non-JSON line: ${line.slice(0, 100)}`);
+        log.debug(TAG24, `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(TAG23, `Error handling stream event: ${errMsg}`);
+        log.warn(TAG24, `Error handling stream event: ${errMsg}`);
         this.emit("parse_error", errMsg);
       }
     }
@@ -7255,7 +7556,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(TAG24, `${step} failed for #${cardShortId} (attempt ${i + 1}/${attempts}): ${msg2} — retrying in ${wait}ms`);
+        log.warn(TAG25, `${step} failed for #${cardShortId} (attempt ${i + 1}/${attempts}): ${msg2} — retrying in ${wait}ms`);
         await new Promise((r) => setTimeout(r, wait));
       }
     }
@@ -7278,10 +7579,10 @@ async function runTransition(client, card, plan, opts = {}) {
       if (opts.strictColumn) {
         throw new TransitionError("move", 1, msg);
       }
-      log.warn(TAG24, `#${shortId}: ${msg} — skipping move`);
+      log.warn(TAG25, `#${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(TAG24, `#${shortId} → "${target.name}"`);
+      log.info(TAG25, `#${shortId} → "${target.name}"`);
       card.column_id = target.id;
       moveLanded = true;
     } else {
@@ -7300,7 +7601,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(TAG24, `#${shortId} +label "${name}"`);
+      log.info(TAG25, `#${shortId} +label "${name}"`);
     }
     card.labelIds = Array.from(existing);
   }
@@ -7312,22 +7613,22 @@ 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(TAG24, `#${shortId} -label "${name}"`);
+      log.info(TAG25, `#${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(TAG24, `#${shortId} updated`);
+    log.info(TAG25, `#${shortId} updated`);
   }
   if (plan.endSession) {
     await withRetry("endSession", shortId, () => client.endAgentSession(card.id, plan.endSession), attempts, backoffMs);
-    log.info(TAG24, `#${shortId} session ended (${plan.endSession.status})`);
+    log.info(TAG25, `#${shortId} session ended (${plan.endSession.status})`);
   }
   if (plan.assignAgent !== undefined) {
     const assignedAgentId = plan.assignAgent;
     await withRetry("assignAgent", shortId, () => client.updateCard(card.id, { assignedAgentId }), attempts, backoffMs);
-    log.info(TAG24, assignedAgentId ? `#${shortId} assigned → agent ${assignedAgentId}` : `#${shortId} unassigned`);
+    log.info(TAG25, assignedAgentId ? `#${shortId} assigned → agent ${assignedAgentId}` : `#${shortId} unassigned`);
   }
   if (opts.store && opts.runId) {
     try {
@@ -7340,11 +7641,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(TAG24, `ensureLabel "${name}" failed: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG25, `ensureLabel "${name}" failed: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
-var TAG24 = "transition", TransitionError;
+var TAG25 = "transition", TransitionError;
 var init_transitions = __esm(() => {
   init_log();
   TransitionError = class TransitionError extends Error {
@@ -7428,7 +7729,7 @@ class ReviewWorker {
     }
   }
   get tag() {
-    return `${TAG25}:${this.id}`;
+    return `${TAG26}:${this.id}`;
   }
   get isIdle() {
     return this.state === "idle";
@@ -7499,7 +7800,8 @@ class ReviewWorker {
         agentId: this.identity.agentId,
         status: "working",
         currentTask: "Setting up review worktree",
-        progressPercent: 5
+        progressPercent: 5,
+        modelName: this.config.claude.reviewModel
       });
       this.sessionId = reviewSession && typeof reviewSession === "object" && "id" in reviewSession ? reviewSession.id ?? null : null;
       const labelPromise = addLabelByName(this.client, card, "agent", "#8b5cf6");
@@ -7600,6 +7902,7 @@ class ReviewWorker {
         this.cancel("timeout");
       }, this.config.review.maxTimeout);
       this.progressTracker = new ProgressTracker(this.client, card.id, this.id, subtasks);
+      this.progressTracker.setRequestedModel(this.config.claude.reviewModel);
       const stdout = await this.spawnClaude(userPrompt, systemPrompt, this.progressTracker, card.short_id);
       this.lastSessionStats = this.progressTracker?.stats ?? null;
       this.progressTracker?.stop();
@@ -7891,7 +8194,7 @@ class ReviewWorker {
     this.lastSessionStats = null;
   }
 }
-var TAG25 = "review-worker", CANCEL_SIGINT_TIMEOUT = 30000, CANCEL_SIGTERM_TIMEOUT = 1e4;
+var TAG26 = "review-worker", CANCEL_SIGINT_TIMEOUT = 30000, CANCEL_SIGTERM_TIMEOUT = 1e4;
 var init_review_worker = __esm(() => {
   init_dist();
   init_board_helpers();
@@ -7944,7 +8247,7 @@ class SleepGuard {
       if (!this.child.killed)
         this.child.kill("SIGTERM");
       this.child = null;
-      log.info(TAG26, "sleep assertion released");
+      log.info(TAG27, "sleep assertion released");
     }
   }
   start() {
@@ -7959,7 +8262,7 @@ class SleepGuard {
         spawned = true;
       });
       child.on("error", (err) => {
-        log.warn(TAG26, `caffeinate unavailable: ${err.message}`);
+        log.warn(TAG27, `caffeinate unavailable: ${err.message}`);
         if (this.child === child)
           this.child = null;
       });
@@ -7972,13 +8275,13 @@ class SleepGuard {
       });
       child.unref();
       this.child = child;
-      log.info(TAG26, "sleep assertion acquired (caffeinate -i)");
+      log.info(TAG27, "sleep assertion acquired (caffeinate -i)");
     } catch (err) {
-      log.warn(TAG26, `failed to spawn caffeinate: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG27, `failed to spawn caffeinate: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG26 = "sleep-guard";
+var TAG27 = "sleep-guard";
 var init_sleep_guard = __esm(() => {
   init_log();
 });
@@ -7989,7 +8292,7 @@ async function fetchBlocksLinks(client, cardId) {
     const { links } = await client.getCardLinks(cardId);
     return links.filter((l) => l.link_type === "blocks");
   } catch (err) {
-    log.warn(TAG27, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG28, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -8021,27 +8324,27 @@ async function promoteUnblockedSuccessors(completedCard, deps) {
   const successors = links.filter((l) => l.direction === "outgoing" && !l.target_card.done);
   if (successors.length === 0)
     return;
-  log.info(TAG27, `#${completedCard.short_id} completed — checking ${successors.length} chained successor(s)`);
+  log.info(TAG28, `#${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(TAG27, `successor #${card.short_id} unassigned — auto-assigning to continue chain`);
+        log.info(TAG28, `successor #${card.short_id} unassigned — auto-assigning to continue chain`);
         await deps.client.updateCard(successorId, {
           assignedAgentId: deps.agentId
         });
       } else {
-        log.debug(TAG27, `successor #${card.short_id} assigned to different entity — skipping`);
+        log.debug(TAG28, `successor #${card.short_id} assigned to different entity — skipping`);
         continue;
       }
       await deps.enqueue(successorId);
     } catch (err) {
-      log.warn(TAG27, `promotion failed for successor ${successorId}: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG28, `promotion failed for successor ${successorId}: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG27 = "unblock";
+var TAG28 = "unblock";
 var init_unblock = __esm(() => {
   init_log();
 });
@@ -8196,7 +8499,7 @@ class CliAgentRunner {
         events: batch
       });
     } catch (err) {
-      log.warn(TAG28, `Failed to flush run events: ${err}`);
+      log.warn(TAG29, `Failed to flush run events: ${err}`);
       this.buffer.unshift(...batch);
       if (this.buffer.length > MAX_BUFFER) {
         this.buffer.length = MAX_BUFFER;
@@ -8233,7 +8536,7 @@ function mapCost(cost) {
     durationMs: cost.durationMs
   };
 }
-var TAG28 = "cli-agent-runner", FLUSH_INTERVAL_MS = 2000, MAX_BUFFER = 1000, MAX_TEXT_LEN2 = 8000, MAX_OUTPUT_LEN2 = 4000;
+var TAG29 = "cli-agent-runner", FLUSH_INTERVAL_MS = 2000, MAX_BUFFER = 1000, MAX_TEXT_LEN2 = 8000, MAX_OUTPUT_LEN2 = 4000;
 var init_cli_agent_runner = __esm(() => {
   init_log();
 });
@@ -8266,11 +8569,11 @@ async function buildPrompt(enriched, branchName, worktreePath, client, workspace
 Do NOT push to main. All your work stays on \`${branchName}\`.
 The daemon owns the run lifecycle: once your work is committed it ends the agent session, pushes the branch, and moves the card to Review for you. Do NOT call harmony_end_agent_session, do NOT start a new session, and do NOT move the card or change its column yourself. If the skill driving this work tells you to move the card or end the session as a final step, SKIP it — it is handled for you (those tools are disabled for this run). Finish the implementation, commit, and stop.`
     });
-    log.info(TAG29, `Generated prompt for #${card.short_id} — ${result.contextSummary.memoryCount} memories, ${result.tokenEstimate} tokens`);
+    log.info(TAG30, `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(TAG29, `Failed to generate prompt via API, using fallback: ${msg}`);
+    log.warn(TAG30, `Failed to generate prompt via API, using fallback: ${msg}`);
     const commentsSection = await renderCommentsSection(client, card.id);
     return buildFallbackPrompt(enriched, branchName, worktreePath) + commentsSection + pastEpisodesSection;
   }
@@ -8288,7 +8591,7 @@ async function renderCommentsSection(client, cardId) {
 
 ${section}` : "";
   } catch (err) {
-    log.warn(TAG29, "comment-thread fetch failed", {
+    log.warn(TAG30, "comment-thread fetch failed", {
       event: "comment_fetch_failed",
       error: err instanceof Error ? err.message : String(err)
     });
@@ -8338,7 +8641,7 @@ ${description}`.trim();
 ## Similar past tasks
 ${bullets}`;
   } catch (err) {
-    log.warn(TAG29, "past-episodes recall failed", {
+    log.warn(TAG30, "past-episodes recall failed", {
       event: "episode_recall_failed",
       error: err instanceof Error ? err.message : String(err)
     });
@@ -8379,15 +8682,18 @@ ${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 TAG29 = "prompt";
+var TAG30 = "prompt";
 var init_prompt = __esm(() => {
   init_dist();
   init_log();
 });
 
 // src/stage-advance.ts
+function gateKindOf(stage) {
+  return stage.gate && typeof stage.gate === "object" ? String(stage.gate.kind ?? "gate") : "gate";
+}
 function gateSummary(stage, evaluation) {
-  const kind = stage.gate && typeof stage.gate === "object" ? String(stage.gate.kind ?? "gate") : "gate";
+  const kind = gateKindOf(stage);
   if (evaluation.passed)
     return `${kind} passed`;
   const firstError = evaluation.findings.find((f) => f.level === "error");
@@ -8402,7 +8708,7 @@ async function resolveStageColumnName(client, card, stage) {
     const match = board.columns.find((c) => c.id === target || c.name.toLowerCase() === target.toLowerCase());
     return match ? match.name : null;
   } catch (err) {
-    log.warn(TAG30, `board fetch failed resolving stage column for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG31, `board fetch failed resolving stage column for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -8410,6 +8716,10 @@ async function persistStagePointer(client, card, body) {
   await client.request("POST", `/cards/${encodeURIComponent(card.id)}/advance-stage`, body);
 }
 async function advanceStageRun(card, stage, stageIndex, def, evaluation, deps) {
+  const configErrorDetail = gateConfigErrorReason(evaluation);
+  if (configErrorDetail) {
+    return holdGateMisconfigured(card, stage, configErrorDetail, deps);
+  }
   const loop = getStageLoop(stage);
   if (!isConvergeLoop(loop)) {
     if (!evaluation)
@@ -8418,6 +8728,28 @@ async function advanceStageRun(card, stage, stageIndex, def, evaluation, deps) {
   }
   return advanceConvergeLoop(card, stage, stageIndex, def, evaluation, loop, deps);
 }
+async function holdGateMisconfigured(card, stage, detail, deps) {
+  const reason = `Stage "${stage.name}" cannot be evaluated as configured — ${detail} Holding for a human: this is a configuration defect, so re-running the stage would reach the same result. No attempt was charged.`;
+  deps.sink?.recordStageGateEvaluated({
+    stageId: stage.id,
+    gateId: gateKindOf(stage),
+    verdict: "blocked",
+    evidence: detail,
+    summary: `${gateKindOf(stage)} misconfigured`
+  });
+  await deps.stateStore.resetLoopIterations(card.id).catch(() => {});
+  try {
+    await deps.client.updateAgentProgress(card.id, {
+      agentIdentifier: "claude-code-stage",
+      agentName: "Harmony Agent",
+      status: "waiting",
+      currentTask: reason
+    });
+  } catch {}
+  await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore);
+  log.info(TAG31, `#${card.short_id} GateMisconfigured: ${reason}`);
+  return { kind: "held_misconfigured", reason };
+}
 function firstErrorMessage(evaluation) {
   const e = evaluation?.findings.find((f) => f.level === "error");
   return e ? e.message : null;
@@ -8446,7 +8778,7 @@ async function advanceConvergeLoop(card, stage, stageIndex, def, evaluation, loo
     evidence,
     summary
   });
-  log.info(TAG30, `#${card.short_id} converge loop "${stage.name}": ${summary} → ${decision}`);
+  log.info(TAG31, `#${card.short_id} converge loop "${stage.name}": ${summary} → ${decision}`);
   if (decision === "exit") {
     await deps.stateStore.resetLoopIterations(card.id).catch(() => {});
     deps.sink?.recordLoopCompleted?.({
@@ -8488,7 +8820,7 @@ async function advanceConvergeLoop(card, stage, stageIndex, def, evaluation, loo
     await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore, {
       keepAttempts: true
     });
-    log.info(TAG30, `#${card.short_id} LoopExhausted: ${reason}`);
+    log.info(TAG31, `#${card.short_id} LoopExhausted: ${reason}`);
     return { kind: "held_gate_unmet", reason };
   }
   await deps.stateStore.decrementAttempt(card.id).catch(() => {});
@@ -8502,7 +8834,7 @@ async function advanceConvergeLoop(card, stage, stageIndex, def, evaluation, loo
     addLabels: [{ name: AGENT_LABEL }],
     ...isAgentRunnableOwner(stage.owner) ? { assignAgent: deps.agentId } : {}
   }, { store: deps.stateStore, runId: deps.runId });
-  log.info(TAG30, `#${card.short_id} converge loop "${stage.name}" — requeued to "${toColumn}" for iteration ${iteration + 1}/${maxIterations}`);
+  log.info(TAG31, `#${card.short_id} converge loop "${stage.name}" — requeued to "${toColumn}" for iteration ${iteration + 1}/${maxIterations}`);
   return { kind: "requeued_gate_unmet", toColumn };
 }
 async function writeIterationHandoff(card, stage, iteration, maxIterations, evaluation, deps) {
@@ -8521,14 +8853,14 @@ ${findings.map((f) => `- [${f.level}] ${f.message}`).join(`
     });
     await deps.client.addComment(card.id, body, { commentType: "decision" });
   } catch (err) {
-    log.warn(TAG30, `iteration-handoff write failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG31, `iteration-handoff write failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
 }
 async function advanceStageOnGate(card, stage, stageIndex, def, evaluation, deps) {
   const summary = gateSummary(stage, evaluation);
   deps.sink?.recordStageGateEvaluated({
     stageId: stage.id,
-    gateId: stage.gate && typeof stage.gate === "object" ? String(stage.gate.kind ?? "gate") : "gate",
+    gateId: gateKindOf(stage),
     verdict: evaluation.passed ? "passed" : "failed",
     evidence: evaluation.findings.map((f) => `[${f.level}] ${f.message}`).join(`
 `),
@@ -8552,7 +8884,7 @@ async function advanceStageOnGate(card, stage, stageIndex, def, evaluation, deps
       reason: "Playbook complete — final stage gate passed."
     });
     deps.stateStore.recordOutcome(card.id, "success").catch(() => {});
-    log.info(TAG30, `#${card.short_id} terminal stage "${stage.name}" passed — marked done`);
+    log.info(TAG31, `#${card.short_id} terminal stage "${stage.name}" passed — marked done`);
     return { kind: "completed_terminal" };
   }
   if (next.kind === "out_of_range") {
@@ -8584,7 +8916,7 @@ async function advanceStageOnGate(card, stage, stageIndex, def, evaluation, deps
     ...isAgentRunnableOwner(next.stage.owner) ? { assignAgent: deps.agentId } : {}
   }, { store: deps.stateStore, runId: deps.runId });
   deps.stateStore.recordOutcome(card.id, "success").catch(() => {});
-  log.info(TAG30, `#${card.short_id} advanced "${stage.name}" → "${next.stage.name}" (column "${toColumn}")`);
+  log.info(TAG31, `#${card.short_id} advanced "${stage.name}" → "${next.stage.name}" (column "${toColumn}")`);
   return { kind: "advanced", toStageId: next.stage.id, toColumn };
 }
 async function handleGateUnmet(card, stage, summary, deps) {
@@ -8603,7 +8935,7 @@ async function handleGateUnmet(card, stage, summary, deps) {
     await holdForHuman(deps.client, card, reason, deps.runId, deps.stateStore, {
       keepAttempts: true
     });
-    log.info(TAG30, `#${card.short_id} GateUnmetExhausted: ${reason}`);
+    log.info(TAG31, `#${card.short_id} GateUnmetExhausted: ${reason}`);
     return { kind: "held_gate_unmet", reason };
   }
   const toColumn = await resolveStageColumnName(deps.client, card, stage) ?? deps.fallbackColumn;
@@ -8615,7 +8947,7 @@ async function handleGateUnmet(card, stage, summary, deps) {
     addLabels: [{ name: AGENT_LABEL }],
     ...isAgentRunnableOwner(stage.owner) ? { assignAgent: deps.agentId } : {}
   }, { store: deps.stateStore, runId: deps.runId });
-  log.info(TAG30, `#${card.short_id} gate unmet for "${stage.name}" — requeued to "${toColumn}" for re-run (attempt ${attempts}/${deps.maxAttempts})`);
+  log.info(TAG31, `#${card.short_id} gate unmet for "${stage.name}" — requeued to "${toColumn}" for re-run (attempt ${attempts}/${deps.maxAttempts})`);
   return { kind: "requeued_gate_unmet", toColumn };
 }
 async function holdForHuman(client, card, reason, runId, stateStore, opts = {}) {
@@ -8635,12 +8967,13 @@ async function holdForHuman(client, card, reason, runId, stateStore, opts = {})
       }
     }, { store: stateStore, runId });
   } catch (err) {
-    log.warn(TAG30, `hold transition failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG31, `hold transition failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
   }
 }
-var TAG30 = "stage-advance", AGENT_LABEL = "agent";
+var TAG31 = "stage-advance", AGENT_LABEL = "agent";
 var init_stage_advance = __esm(() => {
   init_dist();
+  init_gate_config_error();
   init_log();
   init_transitions();
 });
@@ -8785,7 +9118,7 @@ class Worker {
     }
   }
   get tag() {
-    return `${TAG31}:${this.id}`;
+    return `${TAG32}:${this.id}`;
   }
   get isIdle() {
     return this.state === "idle";
@@ -8841,24 +9174,26 @@ class Worker {
         costCents: 0,
         numTurns: 0
       });
+      const implementModel = this.selectImplementModel(card);
       const { session } = await this.client.startAgentSession(card.id, {
         agentIdentifier: agentIdentifier(this.id),
         agentName: AGENT_NAME,
         agentId: this.identity.agentId,
         status: "working",
         currentTask: "Setting up worktree",
-        progressPercent: 5
+        progressPercent: 5,
+        modelName: implementModel
       });
       const sid = session && typeof session === "object" && "id" in session ? session.id : null;
       if (!sid) {
-        log.warn(TAG31, "startAgentSession returned no session id");
+        log.warn(TAG32, "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
+          model: implementModel
         });
       }
       await this.recordPhase("preparing");
@@ -8947,7 +9282,7 @@ ${basePrompt}`;
       }, this.config.maxTimeout);
       this.activeRunSpawnOpts = computeRunSpawnGating(stageCtx.kind === "run" ? stageCtx.allowedTools : null);
       await this.spawnClaude(prompt, card, subtasks, {
-        model: this.selectImplementModel(card),
+        model: implementModel,
         ...this.activeRunSpawnOpts ?? {}
       });
       if (this.aborted)
@@ -9308,6 +9643,10 @@ ${basePrompt}`;
           artifactType: stage.artifact_type
         },
         checklist: { subtasks, cardDone: card.done ?? false },
+        command: {
+          worktreePath,
+          metrics: this.config.playbooks.metrics ?? {}
+        },
         ...review ? { review } : {}
       });
       const context = {
@@ -9718,6 +10057,7 @@ ${basePrompt}`;
       });
       const parser = new StreamParser;
       this.progressTracker = new ProgressTracker(this.client, card.id, this.id, subtasks, initialPhase);
+      this.progressTracker.setRequestedModel(model);
       this.progressTracker.attach(parser);
       this.cliRunner?.attach(parser);
       if (this.cliRunner) {
@@ -9798,6 +10138,7 @@ ${basePrompt}`;
 `);
     }
     this.progressTracker = new ProgressTracker(this.client, card.id, this.id, subtasks, initialPhase);
+    this.progressTracker.setRequestedModel(model);
     if (this.cliRunner) {
       this.progressTracker.setRunEventSink(this.cliRunner);
     }
@@ -9906,7 +10247,7 @@ ${basePrompt}`;
     this.runTurns = 0;
   }
 }
-var TAG31 = "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 TAG32 = "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_dist();
   init_board_helpers();
@@ -9984,41 +10325,41 @@ class Pool {
   }
   async enqueue(card, column, labels, subtasks, mode = "implement") {
     if (this.isCardKnown(card.id) || this.reservations.has(card.id)) {
-      log.debug(TAG32, `Card ${card.id} already queued, active, or reserved, skipping`);
+      log.debug(TAG33, `Card ${card.id} already queued, active, or reserved, skipping`);
       return;
     }
     this.reservations.add(card.id);
     try {
       if (mode === "implement") {
         if (this.authPaused) {
-          log.debug(TAG32, `#${card.short_id} held — agent paused (auth error)`);
+          log.debug(TAG33, `#${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(TAG32, `#${card.short_id} held — API cooldown ${Math.round(cooldownMs / 1000)}s remaining`);
+          log.debug(TAG33, `#${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(TAG32, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
+            log.warn(TAG33, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
             await this.emitWaiting(card.id, `Daily budget reached — waiting for reset (${decision.detail})`);
           } else {
-            log.debug(TAG32, `#${card.short_id} gave up: ${decision.detail}`);
+            log.debug(TAG33, `#${card.short_id} gave up: ${decision.detail}`);
           }
           return;
         }
         const blockers = await getUnresolvedBlockers(this.client, card, this.projectId);
         if (blockers === null) {
-          log.warn(TAG32, `#${card.short_id} blocker check failed — deferring to next tick`);
+          log.warn(TAG33, `#${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(TAG32, `#${card.short_id} blocked by ${list} — waiting`);
+          log.info(TAG33, `#${card.short_id} blocked by ${list} — waiting`);
           await this.emitWaiting(card.id, `Blocked by ${list} — waiting for chain`);
           return;
         }
@@ -10050,7 +10391,7 @@ class Pool {
       });
       this.lastWaitingEmit.set(cardId, currentTask);
     } catch (err) {
-      log.debug(TAG32, `waiting emit failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+      log.debug(TAG33, `waiting emit failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
     }
   }
   noteApiError(err) {
@@ -10058,7 +10399,7 @@ class Pool {
       return;
     if (err.kind === "auth") {
       if (!this.authPaused) {
-        log.error(TAG32, "Auth error from Claude CLI — pausing implement pickups until the daemon is restarted with valid credentials");
+        log.error(TAG33, "Auth error from Claude CLI — pausing implement pickups until the daemon is restarted with valid credentials");
       }
       this.authPaused = true;
       return;
@@ -10067,7 +10408,7 @@ class Pool {
     const until = Date.now() + cooldownMs;
     if (until > this.apiCooldownUntil) {
       this.apiCooldownUntil = until;
-      log.warn(TAG32, `${describeApiError(err.kind)} — pausing implement pickups for ${Math.round(cooldownMs / 1000)}s`);
+      log.warn(TAG33, `${describeApiError(err.kind)} — pausing implement pickups for ${Math.round(cooldownMs / 1000)}s`);
     }
   }
   apiCooldownRemainingMs() {
@@ -10081,13 +10422,13 @@ class Pool {
       const removed = queue.remove(cardId);
       if (removed) {
         this.cardDataCache.delete(cardId);
-        log.info(TAG32, `Removed #${removed.shortId} from ${removed.mode} queue`);
+        log.info(TAG33, `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(TAG32, `Cancelling worker ${worker.id} for card ${cardId}`);
+      log.info(TAG33, `Cancelling worker ${worker.id} for card ${cardId}`);
       await worker.cancel("unassigned");
     }
   }
@@ -10120,10 +10461,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(TAG32, `No active worker for card ${cardId}, ignoring ${command}`);
+      log.debug(TAG33, `No active worker for card ${cardId}, ignoring ${command}`);
       return;
     }
-    log.info(TAG32, `Agent command: ${command} → worker ${worker.id} (card ${cardId})`);
+    log.info(TAG33, `Agent command: ${command} → worker ${worker.id} (card ${cardId})`);
     switch (command) {
       case "pause":
         await worker.pause();
@@ -10171,7 +10512,7 @@ class Pool {
     };
   }
   async shutdown() {
-    log.info(TAG32, "Shutting down pool...");
+    log.info(TAG33, "Shutting down pool...");
     this.shuttingDown = true;
     const active = [
       ...this.implWorkers.filter((w) => w.isActive),
@@ -10179,7 +10520,7 @@ class Pool {
     ];
     await Promise.all(active.map((w) => w.cancel("shutdown")));
     this.sleepGuard.stop();
-    log.info(TAG32, "Pool shutdown complete");
+    log.info(TAG33, "Pool shutdown complete");
   }
   reservations = new Set;
   cardDataCache = new Map;
@@ -10188,7 +10529,7 @@ class Pool {
       return false;
     const idle = workers.find((w) => w.isIdle);
     if (!idle) {
-      log.debug(TAG32, `No idle ${label} workers (queue: ${queue.length})`);
+      log.debug(TAG33, `No idle ${label} workers (queue: ${queue.length})`);
       return false;
     }
     const next = queue.dequeue();
@@ -10196,18 +10537,18 @@ class Pool {
       return false;
     const data = this.cardDataCache.get(next.cardId);
     if (!data) {
-      log.warn(TAG32, `No cached data for card ${next.cardId}, skipping`);
+      log.warn(TAG33, `No cached data for card ${next.cardId}, skipping`);
       return false;
     }
     this.cardDataCache.delete(next.cardId);
     this.lastWaitingEmit.delete(next.cardId);
-    log.info(TAG32, `Dispatching #${next.shortId} to ${label} worker ${idle.id}`);
+    log.info(TAG33, `Dispatching #${next.shortId} to ${label} worker ${idle.id}`);
     this.sleepGuard.acquire();
     idle.run(data.card, data.column, data.labels, data.subtasks);
     return true;
   }
 }
-var TAG32 = "pool";
+var TAG33 = "pool";
 var init_pool = __esm(() => {
   init_error_classifier();
   init_log();
@@ -10249,7 +10590,7 @@ function load(path) {
       return parsed;
     return {};
   } catch (err) {
-    log.warn(TAG33, `failed to read ${path}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG34, `failed to read ${path}: ${err instanceof Error ? err.message : err}`);
     return {};
   }
 }
@@ -10267,7 +10608,7 @@ function recordDaemonPort(projectId, entry, path = defaultRegistryPath()) {
     registry[projectId] = { ...entry, updatedAt: Date.now() };
     save(path, registry);
   } catch (err) {
-    log.warn(TAG33, `failed to record port for ${projectId}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG34, `failed to record port for ${projectId}: ${err instanceof Error ? err.message : err}`);
   }
 }
 function lookupDaemonPort(projectId, path = defaultRegistryPath()) {
@@ -10283,10 +10624,10 @@ function clearDaemonPort(projectId, pid, path = defaultRegistryPath()) {
     delete registry[projectId];
     save(path, registry);
   } catch (err) {
-    log.warn(TAG33, `failed to clear port for ${projectId}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG34, `failed to clear port for ${projectId}: ${err instanceof Error ? err.message : err}`);
   }
 }
-var TAG33 = "port-registry";
+var TAG34 = "port-registry";
 var init_port_registry = __esm(() => {
   init_log();
 });
@@ -10307,7 +10648,7 @@ async function fetchCardSafely(client, cardId) {
     const { card } = await client.getCard(cardId);
     return card;
   } catch (err) {
-    log.warn(TAG34, `cannot fetch card ${cardId}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG35, `cannot fetch card ${cardId}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -10317,7 +10658,7 @@ async function recoverOrphans(store, client, config) {
     return [];
   }
   const outcomes = [];
-  log.info(TAG34, `recovering ${active.length} orphan run(s) from prior daemon`);
+  log.info(TAG35, `recovering ${active.length} orphan run(s) from prior daemon`);
   for (const run of active) {
     const outcome = {
       runId: run.runId,
@@ -10329,11 +10670,11 @@ async function recoverOrphans(store, client, config) {
     };
     outcomes.push(outcome);
     if (isProcessAlive(run.daemonPid, process.pid)) {
-      log.warn(TAG34, `run ${run.runId} claims live daemon pid ${run.daemonPid} — skipping`);
+      log.warn(TAG35, `run ${run.runId} claims live daemon pid ${run.daemonPid} — skipping`);
       outcome.actions.push("skipped: daemon pid still alive");
       continue;
     }
-    log.info(TAG34, `recovering ${run.pipeline} run ${run.runId} for card #${run.cardShortId}`);
+    log.info(TAG35, `recovering ${run.pipeline} run ${run.runId} for card #${run.cardShortId}`);
     await recoverRun(run, store, client, config, outcome, {
       rollbackAttempt: true
     });
@@ -10353,7 +10694,7 @@ async function recoverRun(run, store, client, config, outcome, opts = {}) {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     outcome.errors.push(`endAgentSession: ${msg}`);
-    log.warn(TAG34, `endAgentSession failed for ${run.cardId}: ${msg}`);
+    log.warn(TAG35, `endAgentSession failed for ${run.cardId}: ${msg}`);
   }
   const card = await fetchCardSafely(client, run.cardId);
   if (card) {
@@ -10405,9 +10746,9 @@ async function recoverRun(run, store, client, config, outcome, opts = {}) {
       outcome.errors.push(`decrementAttempt: ${msg}`);
     }
   }
-  log.info(TAG34, `recovered run ${run.runId} (card #${run.cardShortId}): ${outcome.actions.join(", ")}${outcome.errors.length ? ` | errors: ${outcome.errors.join("; ")}` : ""}`);
+  log.info(TAG35, `recovered run ${run.runId} (card #${run.cardShortId}): ${outcome.actions.join(", ")}${outcome.errors.length ? ` | errors: ${outcome.errors.join("; ")}` : ""}`);
 }
-var TAG34 = "recovery", RECOVERED_LABEL = "agent-recovered", RECOVERED_LABEL_COLOR = "#f59e0b";
+var TAG35 = "recovery", RECOVERED_LABEL = "agent-recovered", RECOVERED_LABEL_COLOR = "#f59e0b";
 var init_recovery = __esm(() => {
   init_board_helpers();
   init_log();
@@ -10418,14 +10759,14 @@ var init_recovery = __esm(() => {
 async function claimReviewCard(client, cardId, agentId) {
   try {
     const { claimed } = await client.claimCard(cardId, agentId);
-    log.debug(TAG35, `claim ${cardId} → ${claimed ? "won" : "lost"}`);
+    log.debug(TAG36, `claim ${cardId} → ${claimed ? "won" : "lost"}`);
     return claimed;
   } catch (err) {
-    log.error(TAG35, `claim ${cardId} failed: ${err instanceof Error ? err.message : err}`);
+    log.error(TAG36, `claim ${cardId} failed: ${err instanceof Error ? err.message : err}`);
     return false;
   }
 }
-var TAG35 = "claim";
+var TAG36 = "claim";
 var init_claim = __esm(() => {
   init_log();
 });
@@ -10478,22 +10819,22 @@ async function reclaimPreReviewStrands(opts) {
       continue;
     const won = await claimReviewCard(client, card.id, agentId);
     if (!won) {
-      log.debug(TAG36, `#${card.short_id} — lost the review claim race, skipping`);
+      log.debug(TAG37, `#${card.short_id} — lost the review claim race, skipping`);
       continue;
     }
-    log.warn(TAG36, `#${card.short_id} claimed for review (branch pushed, no PR, unowned)`);
+    log.warn(TAG37, `#${card.short_id} claimed for review (branch pushed, no PR, unowned)`);
     reclaimed.push(card.id);
     if (opts.onClaimed) {
       try {
         await opts.onClaimed(card);
       } catch (err) {
-        log.error(TAG36, `onClaimed for #${card.short_id} failed: ${err instanceof Error ? err.message : err}`);
+        log.error(TAG37, `onClaimed for #${card.short_id} failed: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
   return reclaimed;
 }
-var TAG36 = "strand-recovery";
+var TAG37 = "strand-recovery";
 var init_strand_recovery = __esm(() => {
   init_board_helpers();
   init_claim();
@@ -10545,7 +10886,7 @@ class Reconciler {
       clearInterval(this.timer);
       this.timer = null;
     }
-    log.info(TAG37, "Heartbeat stopped");
+    log.info(TAG38, "Heartbeat stopped");
   }
   async recoverStaleRuns() {
     if (!this.stateStore || !this.agentConfig)
@@ -10562,7 +10903,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(TAG37, `zombie run ${run.runId} (#${run.cardShortId}): ${reason} — recovering`);
+      log.warn(TAG38, `zombie run ${run.runId} (#${run.cardShortId}): ${reason} — recovering`);
       await recoverRun(run, this.stateStore, this.client, this.agentConfig, {
         runId: run.runId,
         cardId: run.cardId,
@@ -10589,11 +10930,11 @@ class Reconciler {
       const stalledAt = Date.parse(card.updated_at ?? "");
       if (!Number.isFinite(stalledAt) || now - stalledAt < graceMs)
         continue;
-      log.warn(TAG37, `#${card.short_id} stranded in "${inProgressCol.name}" (no live run) — requeueing to "${pickupCol.name}"`);
+      log.warn(TAG38, `#${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(TAG37, `stranded requeue failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log.error(TAG38, `stranded requeue failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -10625,7 +10966,7 @@ class Reconciler {
           return;
         const cardLabels = resolveCardLabels(card, labelMap);
         const subtasks = card.subtasks ?? [];
-        log.info(TAG37, `Enqueuing claimed review card #${card.short_id} (agent-agnostic pickup)`);
+        log.info(TAG38, `Enqueuing claimed review card #${card.short_id} (agent-agnostic pickup)`);
         await this.pool.enqueue(card, column, cardLabels, subtasks, "review");
       }
     });
@@ -10649,11 +10990,11 @@ class Reconciler {
       const parkedAt = Date.parse(card.updated_at ?? "");
       if (!Number.isFinite(parkedAt) || now - parkedAt < ttlMs)
         continue;
-      log.warn(TAG37, `#${card.short_id} parked for approval > ${planning.approvalTtlHours}h — auto-releasing to "${pickupCol.name}"`);
+      log.warn(TAG38, `#${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(TAG37, `auto-release failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log.error(TAG38, `auto-release failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -10673,7 +11014,8 @@ class Reconciler {
         reviewColumns: this.reviewColumns,
         playbooks: this.agentConfig?.playbooks ?? {
           enabled: false,
-          humanStageColumns: []
+          humanStageColumns: [],
+          metrics: {}
         }
       };
       const assignedCards = cards.filter((c) => {
@@ -10696,21 +11038,21 @@ class Reconciler {
           const subtasks = card.subtasks ?? [];
           const mode = route.mode;
           if (route.stage) {
-            log.info(TAG37, `Stage card #${card.short_id} (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement) regardless of column`);
+            log.info(TAG38, `Stage card #${card.short_id} (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement) regardless of column`);
           }
           if (mode === "review" && this.approvedLabel && hasLabel(cardLabels, this.approvedLabel)) {
-            log.debug(TAG37, `Skipping #${card.short_id} — already has "${this.approvedLabel}" label`);
+            log.debug(TAG38, `Skipping #${card.short_id} — already has "${this.approvedLabel}" label`);
             continue;
           }
           if (mode === "review" && hasLabel(cardLabels, NEED_REVIEW_LABEL)) {
-            log.debug(TAG37, `Skipping #${card.short_id} — has "${NEED_REVIEW_LABEL}" label (needs human)`);
+            log.debug(TAG38, `Skipping #${card.short_id} — has "${NEED_REVIEW_LABEL}" label (needs human)`);
             continue;
           }
           if (mode === "review" && !qualifiesForAutoReview(card.description)) {
-            log.debug(TAG37, `Skipping #${card.short_id} — no branch or PR reference (not qualified for auto-review)`);
+            log.debug(TAG38, `Skipping #${card.short_id} — no branch or PR reference (not qualified for auto-review)`);
             continue;
           }
-          log.info(TAG37, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — enqueueing`);
+          log.info(TAG38, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — enqueueing`);
           await this.pool.enqueue(card, column, cardLabels, subtasks, mode);
         }
       }
@@ -10721,18 +11063,18 @@ class Reconciler {
       await this.recoverStrandedReview(cards, columns, labelMap, knownCardIds);
       for (const knownId of knownCardIds) {
         if (!allAgentCardIds.has(knownId)) {
-          log.info(TAG37, `Missed unassign: ${knownId} — removing`);
+          log.info(TAG38, `Missed unassign: ${knownId} — removing`);
           await this.pool.removeCard(knownId);
         }
       }
       await this.releaseStalledApprovals(cards, columns, knownCardIds);
-      log.debug(TAG37, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
+      log.debug(TAG38, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
     } catch (err) {
-      log.error(TAG37, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG38, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG37 = "reconcile";
+var TAG38 = "reconcile";
 var init_reconcile = __esm(() => {
   init_board_helpers();
   init_git_pr();
@@ -10772,7 +11114,7 @@ function prettyBanner(config, version) {
       checks.push({ kind: "ok", message });
     },
     warn(message) {
-      log.warn(TAG38, message);
+      log.warn(TAG39, message);
       checks.push({ kind: "warn", message: message.split(`
 `, 1)[0] });
     },
@@ -10797,25 +11139,25 @@ function prettyBanner(config, version) {
   };
 }
 function jsonBanner(config, version) {
-  log.info(TAG38, `Harmony Agent Daemon v${version} starting...`);
-  log.info(TAG38, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Model: ${config.agent.claude.model} | Runner: ${config.agent.runner} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
+  log.info(TAG39, `Harmony Agent Daemon v${version} starting...`);
+  log.info(TAG39, `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(TAG38, `Review: enabled | Columns: ${config.agent.review.pickupColumns.join(", ")} | → ${config.agent.review.moveToColumn} / ${config.agent.review.failColumn}`);
+    log.info(TAG39, `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(TAG38, `Git provider: ${provider}`);
+      log.info(TAG39, `Git provider: ${provider}`);
     },
     setHttpPort(port) {
-      log.info(TAG38, `HTTP server on port ${port}`);
+      log.info(TAG39, `HTTP server on port ${port}`);
     },
     check(message) {
-      log.info(TAG38, message);
+      log.info(TAG39, message);
     },
     warn(message) {
-      log.warn(TAG38, message);
+      log.warn(TAG39, message);
     },
     fail() {
       failed = true;
@@ -10823,7 +11165,7 @@ function jsonBanner(config, version) {
     async ready(message) {
       if (failed)
         return;
-      log.info(TAG38, message);
+      log.info(TAG39, message);
     }
   };
 }
@@ -10904,7 +11246,7 @@ function cyan(s) {
 function yellow(s) {
   return `${ANSI.yellow}${s}${ANSI.reset}`;
 }
-var TAG38 = "daemon", RULE_WIDTH = 70, ANSI;
+var TAG39 = "daemon", RULE_WIDTH = 70, ANSI;
 var init_startup_banner = __esm(() => {
   init_log();
   ANSI = {
@@ -11055,13 +11397,13 @@ class Watcher {
   }
   async start() {
     if (!isPretty()) {
-      log.info(TAG39, "Connecting to Supabase realtime (broadcast)...");
+      log.info(TAG40, "Connecting to Supabase realtime (broadcast)...");
     }
     this.supabase = createClient(this.credentials.supabaseUrl, this.credentials.supabaseAnonKey);
     const presenceChannel = this.supabase.channel(`board-presence-${this.projectId}`);
     this.subscribeBroadcast();
     presenceChannel.on("presence", { event: "sync" }, () => {
-      log.debug(TAG39, "Presence sync");
+      log.debug(TAG40, "Presence sync");
     }).subscribe(async (status) => {
       if (status === "SUBSCRIBED") {
         await presenceChannel.track({
@@ -11074,7 +11416,7 @@ class Watcher {
           agentName: this.identity.agentName
         });
         if (!isPretty() || !this.suppressStartupLogs) {
-          log.info(TAG39, "Presence tracked on board-presence channel");
+          log.info(TAG40, "Presence tracked on board-presence channel");
         }
         this.presenceTracked = true;
         this.maybeResolveReady();
@@ -11087,13 +11429,13 @@ class Watcher {
       return;
     const gen = ++this.broadcastGen;
     this.channel = this.supabase.channel(`board-${this.projectId}`).on("broadcast", { event: "card_update" }, (msg) => {
-      log.debug(TAG39, `Broadcast: card_update ${JSON.stringify(msg.payload)}`);
+      log.debug(TAG40, `Broadcast: card_update ${JSON.stringify(msg.payload)}`);
       this.onCardBroadcast({
         event: "card_update",
         payload: msg.payload ?? {}
       });
     }).on("broadcast", { event: "card_created" }, (msg) => {
-      log.debug(TAG39, `Broadcast: card_created ${JSON.stringify(msg.payload)}`);
+      log.debug(TAG40, `Broadcast: card_created ${JSON.stringify(msg.payload)}`);
       this.onCardBroadcast({
         event: "card_created",
         payload: msg.payload ?? {}
@@ -11103,7 +11445,7 @@ class Watcher {
       const cardId = payload.card_id;
       const command = payload.command;
       if (cardId && command) {
-        log.info(TAG39, `Broadcast: agent_command ${command} for ${cardId}`);
+        log.info(TAG40, `Broadcast: agent_command ${command} for ${cardId}`);
         this.onAgentCommand?.({ cardId, command });
       }
     }).subscribe((status) => {
@@ -11113,13 +11455,13 @@ class Watcher {
         this.connected = true;
         this.reconnectAttempts = 0;
         if (!isPretty() || !this.suppressStartupLogs) {
-          log.info(TAG39, "Broadcast subscription active");
+          log.info(TAG40, "Broadcast subscription active");
         }
         this.maybeResolveReady();
       } else if (status === "CHANNEL_ERROR" || status === "TIMED_OUT" || status === "CLOSED") {
         this.connected = false;
         if (!this.stopping) {
-          log.warn(TAG39, `Broadcast subscription ${status} — scheduling reconnect`);
+          log.warn(TAG40, `Broadcast subscription ${status} — scheduling reconnect`);
           this.scheduleReconnect();
         }
       }
@@ -11138,7 +11480,7 @@ class Watcher {
   async reconnectBroadcast() {
     if (this.stopping || !this.supabase)
       return;
-    log.warn(TAG39, `Reconnecting broadcast subscription (attempt ${this.reconnectAttempts})`);
+    log.warn(TAG40, `Reconnecting broadcast subscription (attempt ${this.reconnectAttempts})`);
     if (this.channel) {
       const old = this.channel;
       this.channel = null;
@@ -11168,10 +11510,10 @@ class Watcher {
       this.supabase = null;
     }
     this.connected = false;
-    log.info(TAG39, "Broadcast subscription stopped");
+    log.info(TAG40, "Broadcast subscription stopped");
   }
 }
-var TAG39 = "watcher";
+var TAG40 = "watcher";
 var init_watcher = __esm(() => {
   init_log();
 });
@@ -11258,10 +11600,10 @@ function runWorktreeGc(basePath, store, opts = {}) {
     });
   } catch {}
   if (result.removed.length > 0) {
-    log.info(TAG40, `GC removed ${result.removed.length} orphan worktree(s): ${result.removed.map((p) => p.split("/").pop()).join(", ")}`);
+    log.info(TAG41, `GC removed ${result.removed.length} orphan worktree(s): ${result.removed.map((p) => p.split("/").pop()).join(", ")}`);
   }
   if (result.errors.length > 0) {
-    log.warn(TAG40, `GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.path}: ${e.error}`).join("; ")}`);
+    log.warn(TAG41, `GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.path}: ${e.error}`).join("; ")}`);
   }
   return result;
 }
@@ -11291,7 +11633,7 @@ function pruneFailedRemoteBranches(opts) {
   } catch (err) {
     const detail = gitErrorDetail2(err);
     if (isTransientGitNetworkError(detail)) {
-      log.debug(TAG40, `Remote branch GC skipped — remote unreachable: ${detail}`);
+      log.debug(TAG41, `Remote branch GC skipped — remote unreachable: ${detail}`);
       return result;
     }
     result.errors.push({ ref: "fetch", error: detail });
@@ -11330,7 +11672,7 @@ function pruneFailedRemoteBranches(opts) {
       continue;
     }
     if (clock() > sweepDeadline) {
-      log.debug(TAG40, `Remote branch GC budget spent — removed ${result.removed.length}, remaining deferred to next tick`);
+      log.debug(TAG41, `Remote branch GC budget spent — removed ${result.removed.length}, remaining deferred to next tick`);
       break;
     }
     try {
@@ -11343,17 +11685,17 @@ function pruneFailedRemoteBranches(opts) {
     } catch (err) {
       const detail = gitErrorDetail2(err);
       if (isTransientGitNetworkError(detail)) {
-        log.debug(TAG40, `Remote branch GC interrupted — remote unreachable: ${detail}`);
+        log.debug(TAG41, `Remote branch GC interrupted — remote unreachable: ${detail}`);
         break;
       }
       result.errors.push({ ref, error: detail });
     }
   }
   if (result.removed.length > 0) {
-    log.info(TAG40, `Pruned ${result.removed.length} stale remote branch(es) under ${opts.prefix}: ${result.removed.join(", ")}`);
+    log.info(TAG41, `Pruned ${result.removed.length} stale remote branch(es) under ${opts.prefix}: ${result.removed.join(", ")}`);
   }
   if (result.errors.length > 0) {
-    log.warn(TAG40, `Remote branch GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.ref}: ${e.error}`).join("; ")}`);
+    log.warn(TAG41, `Remote branch GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.ref}: ${e.error}`).join("; ")}`);
   }
   return result;
 }
@@ -11384,13 +11726,13 @@ class WorktreeGc {
     try {
       runWorktreeGc(this.basePath, this.store);
     } catch (err) {
-      log.warn(TAG40, `GC tick failed: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG41, `GC tick failed: ${err instanceof Error ? err.message : err}`);
     }
     if (this.remoteOpts) {
       try {
         pruneFailedRemoteBranches(this.remoteOpts);
       } catch (err) {
-        log.warn(TAG40, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
+        log.warn(TAG41, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -11404,7 +11746,7 @@ function getRepoRoot2() {
     return null;
   }
 }
-var TAG40 = "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 TAG41 = "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();
@@ -11509,7 +11851,7 @@ async function main() {
   } catch (err) {
     if (err instanceof ConfigValidationError) {
       banner.fail();
-      log.error(TAG41, err.message);
+      log.error(TAG42, err.message);
       process.exit(1);
     }
     throw err;
@@ -11519,7 +11861,7 @@ async function main() {
   } catch (err) {
     if (err instanceof ConfigValidationError) {
       banner.fail();
-      log.error(TAG41, err.message);
+      log.error(TAG42, err.message);
       process.exit(1);
     }
     throw err;
@@ -11634,7 +11976,7 @@ async function main() {
     if (shuttingDown)
       return;
     shuttingDown = true;
-    log.info(TAG41, `Received ${signal}, shutting down gracefully...`);
+    log.info(TAG42, `Received ${signal}, shutting down gracefully...`);
     reconciler.stop();
     mergeMonitor?.stop();
     worktreeGc.stop();
@@ -11645,18 +11987,18 @@ async function main() {
     }
     await watcher.stop();
     await pool.shutdown();
-    log.info(TAG41, "Daemon stopped.");
+    log.info(TAG42, "Daemon stopped.");
     process.exit(exitCode);
   };
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("uncaughtException", (err) => {
-    log.error(TAG41, `Uncaught exception: ${err.message}`);
+    log.error(TAG42, `Uncaught exception: ${err.message}`);
     exitCode = 1;
     shutdown("uncaughtException");
   });
   process.on("unhandledRejection", (reason) => {
-    log.error(TAG41, `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
+    log.error(TAG42, `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
     exitCode = 1;
     shutdown("unhandledRejection");
   });
@@ -11715,29 +12057,29 @@ async function handleBroadcast(event, client, pool, config, agentId) {
   if (assignedAgentId === undefined)
     return;
   if (assignedAgentId === agentId) {
-    log.info(TAG41, `Broadcast: card ${cardId} assigned to agent`);
+    log.info(TAG42, `Broadcast: card ${cardId} assigned to agent`);
     try {
       await pool.resetAttemptsForReassign(cardId);
       await tryEnqueueCard(cardId, client, pool, config, agentId);
     } catch (err) {
-      log.error(TAG41, `Failed to process assignment: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG42, `Failed to process assignment: ${err instanceof Error ? err.message : err}`);
     }
   } else if (pool.isCardKnown(cardId)) {
-    log.info(TAG41, `Broadcast: card ${cardId} unassigned from agent`);
+    log.info(TAG42, `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(TAG41, `Card ${cardId} no longer assigned to agent — skipping`);
+    log.debug(TAG42, `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(TAG41, `Column not found for card ${cardId}`);
+    log.warn(TAG42, `Column not found for card ${cardId}`);
     return;
   }
   const route = classifyPickup(card, column.name, {
@@ -11746,31 +12088,31 @@ async function tryEnqueueCard(cardId, client, pool, config, agentId) {
     playbooks: config.agent.playbooks
   });
   if (!route) {
-    log.info(TAG41, `Card #${card.short_id} is in "${column.name}", not a pickup/review/stage column — skipping`);
+    log.info(TAG42, `Card #${card.short_id} is in "${column.name}", not a pickup/review/stage column — skipping`);
     return;
   }
   if (route.stage) {
-    log.info(TAG41, `Card #${card.short_id} is a playbook stage card (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement pool) regardless of column`);
+    log.info(TAG42, `Card #${card.short_id} is a playbook stage card (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement pool) regardless of column`);
   }
   const mode = route.mode;
   const labelMap = buildLabelMap(board.labels ?? []);
   const cardLabels = resolveCardLabels(card, labelMap);
   const subtasks = card.subtasks ?? [];
   if (mode === "review" && config.agent.review.approvedLabel && hasLabel(cardLabels, config.agent.review.approvedLabel)) {
-    log.debug(TAG41, `Card #${card.short_id} already has "${config.agent.review.approvedLabel}" — skipping review`);
+    log.debug(TAG42, `Card #${card.short_id} already has "${config.agent.review.approvedLabel}" — skipping review`);
     return;
   }
   if (mode === "review" && hasLabel(cardLabels, NEED_REVIEW_LABEL)) {
-    log.debug(TAG41, `Card #${card.short_id} has "${NEED_REVIEW_LABEL}" label (needs human) — skipping review`);
+    log.debug(TAG42, `Card #${card.short_id} has "${NEED_REVIEW_LABEL}" label (needs human) — skipping review`);
     return;
   }
   if (mode === "review" && !qualifiesForAutoReview(card.description)) {
-    log.info(TAG41, `Card #${card.short_id} has no branch or PR reference — skipping auto-review`);
+    log.info(TAG42, `Card #${card.short_id} has no branch or PR reference — skipping auto-review`);
     return;
   }
   await pool.enqueue(card, column, cardLabels, subtasks, mode);
 }
-var TAG41 = "daemon", PKG_VERSION;
+var TAG42 = "daemon", PKG_VERSION;
 var init_src = __esm(() => {
   init_board_helpers();
   init_board_reviewer();