@gethmy/agent 1.8.0 → 1.9.0

package/dist/cli.js

@@ -337,6 +337,9 @@ function loadDaemonConfig() {
     throw new Error("No user email configured. Run `npx @gethmy/mcp setup` first.");
   }
   let agentOverrides = {};
+  let agentName = "Harmony Agent";
+  let agentIdentifier2 = "harmony-daemon";
+  let agentColor = "#57b8a5";
   try {
     const configPath = join(homedir(), ".harmony-mcp", "config.json");
     const raw = readFileSync(configPath, "utf-8");
@@ -344,6 +347,12 @@ function loadDaemonConfig() {
     if (parsed.agent) {
       agentOverrides = parsed.agent;
     }
+    if (typeof parsed.agentName === "string" && parsed.agentName.trim())
+      agentName = parsed.agentName.trim();
+    if (typeof parsed.agentIdentifier === "string" && parsed.agentIdentifier.trim())
+      agentIdentifier2 = parsed.agentIdentifier.trim();
+    if (typeof parsed.agentColor === "string" && parsed.agentColor.trim())
+      agentColor = parsed.agentColor.trim();
   } catch {}
   const agent = {
     ...DEFAULT_AGENT_CONFIG,
@@ -381,7 +390,17 @@ function loadDaemonConfig() {
       ...agentOverrides.timing ?? {}
     }
   };
-  return { apiKey, apiUrl, workspaceId, projectId, userEmail, agent };
+  return {
+    apiKey,
+    apiUrl,
+    workspaceId,
+    projectId,
+    userEmail,
+    agentName,
+    agentIdentifier: agentIdentifier2,
+    agentColor,
+    agent
+  };
 }
 async function fetchRealtimeCredentials(client) {
   const result = await client.request("GET", "/config/realtime");
@@ -3739,6 +3758,7 @@ import { createHash } from "node:crypto";
 class ReviewWorker {
   config;
   client;
+  agentId;
   onDone;
   stateStore;
   workspaceId;
@@ -3755,12 +3775,14 @@ class ReviewWorker {
   progressTracker = null;
   lastSessionStats = null;
   aborted = false;
+  timedOut = false;
   runId = null;
   lastRunLogPath = null;
   sessionId = null;
-  constructor(id, config, client, _userEmail, onDone, stateStore, workspaceId, _projectId) {
+  constructor(id, config, client, agentId, onDone, stateStore, workspaceId, _projectId) {
     this.config = config;
     this.client = client;
+    this.agentId = agentId;
     this.onDone = onDone;
     this.stateStore = stateStore;
     this.workspaceId = workspaceId;
@@ -3810,6 +3832,7 @@ class ReviewWorker {
   }
   async run(card, column, labels, subtasks) {
     this.aborted = false;
+    this.timedOut = false;
     this.cardId = card.id;
     this.startedAt = Date.now();
     this.runId = newRunId();
@@ -3858,6 +3881,7 @@ class ReviewWorker {
       const { session: reviewSession } = await this.client.startAgentSession(card.id, {
         agentIdentifier: agentIdentifier(this.id),
         agentName: `${AGENT_NAME} (Review)`,
+        agentId: this.agentId,
         status: "working",
         currentTask: localMode ? "Reviewing local changes" : "Setting up review worktree",
         progressPercent: 5
@@ -3947,6 +3971,7 @@ class ReviewWorker {
       });
       this.timeoutTimer = setTimeout(() => {
         log.warn(this.tag, `Review timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
+        this.timedOut = true;
         this.cancel();
       }, this.config.review.maxTimeout);
       this.progressTracker = new ProgressTracker(this.client, card.id, this.id, subtasks);
@@ -3957,6 +3982,10 @@ class ReviewWorker {
       const sessionStats = this.lastSessionStats;
       if (this.aborted)
         return;
+      if (this.timeoutTimer) {
+        clearTimeout(this.timeoutTimer);
+        this.timeoutTimer = null;
+      }
       this.state = "completing";
       await this.recordPhase("completing");
       log.info(this.tag, `Claude review finished for #${card.short_id}`);
@@ -4013,7 +4042,7 @@ class ReviewWorker {
         try {
           const run = this.stateStore.getRun(this.runId);
           if (run && run.endedAt === null) {
-            const status = this.state === "error" || this.aborted ? "paused" : "completed";
+            const status = this.timedOut ? "failed" : this.state === "error" || this.aborted ? "paused" : "completed";
             await this.stateStore.endRun(this.runId, status);
           }
         } catch {}
@@ -4051,6 +4080,7 @@ class ReviewWorker {
     signalGroup(this.process, "SIGCONT");
     this.timeoutTimer = setTimeout(() => {
       log.warn(this.tag, `Timeout reached (${this.config.review.maxTimeout}ms), cancelling`);
+      this.timedOut = true;
       this.cancel();
     }, this.config.review.maxTimeout);
     if (this.cardId) {
@@ -4086,7 +4116,11 @@ class ReviewWorker {
     if (this.cardId) {
       try {
         await this.client.endAgentSession(this.cardId, {
-          status: "paused",
+          status: this.timedOut ? "failed" : "paused",
+          ...this.timedOut ? {
+            failureReason: "timeout",
+            failureSummary: `Review exceeded the ${Math.round(this.config.review.maxTimeout / 60000)} min timeout`
+          } : {},
           ...buildTokenPayload(snapshotStats)
         });
       } catch {}
@@ -4264,13 +4298,81 @@ var init_review_worker = __esm(() => {
   init_worktree();
 });
 
+// src/sleep-guard.ts
+import { spawn as spawn3 } from "node:child_process";
+
+class SleepGuard {
+  platform;
+  child = null;
+  holds = 0;
+  constructor(platform = process.platform) {
+    this.platform = platform;
+  }
+  get active() {
+    return this.child !== null;
+  }
+  acquire() {
+    this.holds++;
+    if (this.holds === 1)
+      this.start();
+  }
+  release() {
+    this.holds = Math.max(0, this.holds - 1);
+    if (this.holds === 0)
+      this.stop();
+  }
+  stop() {
+    this.holds = 0;
+    if (this.child) {
+      if (!this.child.killed)
+        this.child.kill("SIGTERM");
+      this.child = null;
+      log.info(TAG20, "sleep assertion released");
+    }
+  }
+  start() {
+    if (this.platform !== "darwin" || this.child)
+      return;
+    try {
+      const child = spawn3("caffeinate", ["-i", "-w", String(process.pid)], {
+        stdio: "ignore"
+      });
+      let spawned = false;
+      child.on("spawn", () => {
+        spawned = true;
+      });
+      child.on("error", (err) => {
+        log.warn(TAG20, `caffeinate unavailable: ${err.message}`);
+        if (this.child === child)
+          this.child = null;
+      });
+      child.on("exit", () => {
+        if (this.child !== child)
+          return;
+        this.child = null;
+        if (spawned && this.holds > 0)
+          this.start();
+      });
+      child.unref();
+      this.child = child;
+      log.info(TAG20, "sleep assertion acquired (caffeinate -i)");
+    } catch (err) {
+      log.warn(TAG20, `failed to spawn caffeinate: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+}
+var TAG20 = "sleep-guard";
+var init_sleep_guard = __esm(() => {
+  init_log();
+});
+
 // src/unblock.ts
 async function fetchBlocksLinks(client, cardId) {
   try {
     const { links } = await client.getCardLinks(cardId);
     return links.filter((l) => l.link_type === "blocks");
   } catch (err) {
-    log.warn(TAG20, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG21, `link fetch failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -4302,22 +4404,22 @@ async function promoteUnblockedSuccessors(completedCard, deps) {
   const successors = links.filter((l) => l.direction === "outgoing" && !l.target_card.done);
   if (successors.length === 0)
     return;
-  log.info(TAG20, `#${completedCard.short_id} completed — checking ${successors.length} chained successor(s)`);
+  log.info(TAG21, `#${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.assignee_id !== deps.agentUserId) {
-        log.debug(TAG20, `successor #${card.short_id} not assigned to agent — skipping promotion`);
+      if (card.assigned_agent_id !== deps.agentId) {
+        log.debug(TAG21, `successor #${card.short_id} not assigned to agent — skipping promotion`);
         continue;
       }
       await deps.enqueue(successorId);
     } catch (err) {
-      log.warn(TAG20, `promotion failed for successor ${successorId}: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG21, `promotion failed for successor ${successorId}: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG20 = "unblock";
+var TAG21 = "unblock";
 var init_unblock = __esm(() => {
   init_log();
 });
@@ -4461,11 +4563,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(TAG21, `Generated prompt for #${card.short_id} — ${result.contextSummary.memoryCount} memories, ${result.tokenEstimate} tokens`);
+    log.info(TAG22, `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(TAG21, `Failed to generate prompt via API, using fallback: ${msg}`);
+    log.warn(TAG22, `Failed to generate prompt via API, using fallback: ${msg}`);
     const commentsSection = await renderCommentsSection(client, card.id);
     return buildFallbackPrompt(enriched, branchName, worktreePath) + commentsSection + pastEpisodesSection;
   }
@@ -4483,7 +4585,7 @@ async function renderCommentsSection(client, cardId) {
 
 ${section}` : "";
   } catch (err) {
-    log.warn(TAG21, "comment-thread fetch failed", {
+    log.warn(TAG22, "comment-thread fetch failed", {
       event: "comment_fetch_failed",
       error: err instanceof Error ? err.message : String(err)
     });
@@ -4533,7 +4635,7 @@ ${description}`.trim();
 ## Similar past tasks
 ${bullets}`;
   } catch (err) {
-    log.warn(TAG21, "past-episodes recall failed", {
+    log.warn(TAG22, "past-episodes recall failed", {
       event: "episode_recall_failed",
       error: err instanceof Error ? err.message : String(err)
     });
@@ -4574,7 +4676,7 @@ ${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 TAG21 = "prompt";
+var TAG22 = "prompt";
 var init_prompt = __esm(() => {
   init_dist();
   init_log();
@@ -4584,6 +4686,7 @@ var init_prompt = __esm(() => {
 class Worker {
   config;
   client;
+  agentId;
   onDone;
   workspaceId;
   projectId;
@@ -4601,12 +4704,14 @@ class Worker {
   progressTracker = null;
   lastSessionStats;
   aborted = false;
+  timedOut = false;
   verificationFailed = false;
   sessionId = null;
   runId = null;
-  constructor(id, config, client, _userEmail, onDone, workspaceId, projectId, stateStore, onCardCompleted) {
+  constructor(id, config, client, agentId, onDone, workspaceId, projectId, stateStore, onCardCompleted) {
     this.config = config;
     this.client = client;
+    this.agentId = agentId;
     this.onDone = onDone;
     this.workspaceId = workspaceId;
     this.projectId = projectId;
@@ -4646,7 +4751,7 @@ class Worker {
     }
   }
   get tag() {
-    return `${TAG22}:${this.id}`;
+    return `${TAG23}:${this.id}`;
   }
   get isIdle() {
     return this.state === "idle";
@@ -4656,6 +4761,7 @@ class Worker {
   }
   async run(card, column, labels, subtasks) {
     this.aborted = false;
+    this.timedOut = false;
     this.verificationFailed = false;
     this.cardId = card.id;
     this.startedAt = Date.now();
@@ -4686,13 +4792,14 @@ class Worker {
       const { session } = await this.client.startAgentSession(card.id, {
         agentIdentifier: agentIdentifier(this.id),
         agentName: AGENT_NAME,
+        agentId: this.agentId,
         status: "working",
         currentTask: "Setting up worktree",
         progressPercent: 5
       });
       const sid = session && typeof session === "object" && "id" in session ? session.id : null;
       if (!sid) {
-        log.warn(TAG22, "startAgentSession returned no session id");
+        log.warn(TAG23, "startAgentSession returned no session id");
       }
       this.sessionId = sid;
       await this.recordPhase("preparing");
@@ -4724,11 +4831,16 @@ class Worker {
       });
       this.timeoutTimer = setTimeout(() => {
         log.warn(this.tag, `Timeout reached (${this.config.maxTimeout}ms), cancelling`);
+        this.timedOut = true;
         this.cancel();
       }, this.config.maxTimeout);
       await this.spawnClaude(prompt, card, subtasks);
       if (this.aborted)
         return;
+      if (this.timeoutTimer) {
+        clearTimeout(this.timeoutTimer);
+        this.timeoutTimer = null;
+      }
       this.state = "verifying";
       await this.recordPhase("verifying");
       log.info(this.tag, `Claude finished for #${card.short_id}, running verification & completion`);
@@ -4770,6 +4882,32 @@ class Worker {
           await this.stateStore.endRun(this.runId, "completed");
         } catch {}
         await this.recordOutcome(card.id, "success");
+      } else if (this.runId && this.timedOut) {
+        if (this.worktreePath) {
+          try {
+            cleanupWorktree(this.worktreePath, this.branchName ?? undefined);
+          } catch {
+            log.warn(this.tag, "Failed to cleanup worktree before requeue");
+          }
+          this.worktreePath = null;
+        }
+        try {
+          await runTransition(this.client, card, {
+            move: { columnName: this.config.pickupColumns[0] ?? "To Do" },
+            endSession: {
+              status: "failed",
+              failureReason: "timeout",
+              failureSummary: `Run exceeded the ${Math.round(this.config.maxTimeout / 60000)} min timeout`,
+              ...buildTokenPayload(this.lastSessionStats)
+            }
+          });
+        } catch (tErr) {
+          log.error(this.tag, `timeout transition failed on #${card.short_id}: ${tErr instanceof TransitionError ? tErr.detail : tErr}`);
+        }
+        try {
+          await this.stateStore.endRun(this.runId, "failed", "timeout");
+        } catch {}
+        await this.recordOutcome(card.id, "failure");
       } else if (this.runId && this.aborted) {
         try {
           await this.stateStore.endRun(this.runId, "paused", "cancelled");
@@ -4840,6 +4978,7 @@ class Worker {
     signalGroup(this.process, "SIGCONT");
     this.timeoutTimer = setTimeout(() => {
       log.warn(this.tag, `Timeout reached (${this.config.maxTimeout}ms), cancelling`);
+      this.timedOut = true;
       this.cancel();
     }, this.config.maxTimeout);
     if (this.cardId) {
@@ -4866,7 +5005,7 @@ class Worker {
         sigtermTimeoutMs: CANCEL_SIGTERM_TIMEOUT2
       });
     }
-    if (this.cardId) {
+    if (this.cardId && !this.timedOut) {
       try {
         const stats = this.lastSessionStats ?? this.progressTracker?.stats;
         await this.client.endAgentSession(this.cardId, {
@@ -4970,7 +5109,7 @@ class Worker {
       clearTimeout(this.timeoutTimer);
       this.timeoutTimer = null;
     }
-    if (this.worktreePath && this.state === "error") {
+    if (this.worktreePath && (this.state === "error" || this.timedOut)) {
       try {
         cleanupWorktree(this.worktreePath, this.branchName ?? undefined);
       } catch {
@@ -4986,7 +5125,7 @@ class Worker {
     this.sessionId = null;
   }
 }
-var TAG22 = "worker", CANCEL_SIGINT_TIMEOUT2 = 30000, CANCEL_SIGTERM_TIMEOUT2 = 1e4;
+var TAG23 = "worker", CANCEL_SIGINT_TIMEOUT2 = 30000, CANCEL_SIGTERM_TIMEOUT2 = 1e4;
 var init_worker = __esm(() => {
   init_board_helpers();
   init_completion();
@@ -5007,22 +5146,30 @@ class Pool {
   client;
   projectId;
   stateStore;
+  agentId;
   implWorkers = [];
   reviewWorkers = [];
   implQueue;
   reviewQueue;
   budget;
+  sleepGuard = new SleepGuard;
+  shuttingDown = false;
   onCardCompleted = null;
-  constructor(config, client, userEmail, workspaceId, projectId, stateStore) {
+  constructor(config, client, _userEmail, workspaceId, projectId, stateStore, agentId) {
     this.client = client;
     this.projectId = projectId;
     this.stateStore = stateStore;
+    this.agentId = agentId;
     this.implQueue = new PriorityQueue(config);
     this.reviewQueue = new PriorityQueue(config);
     this.budget = new BudgetGuard(config.budget, this.stateStore);
     for (let i = 0;i < config.poolSize; i++) {
-      this.implWorkers.push(new Worker(i, config, client, userEmail, () => {
-        this.tryDispatchFor(this.implWorkers, this.implQueue, "impl");
+      this.implWorkers.push(new Worker(i, config, client, this.agentId, () => {
+        try {
+          this.tryDispatchFor(this.implWorkers, this.implQueue, "impl");
+        } finally {
+          this.sleepGuard.release();
+        }
       }, workspaceId, projectId, stateStore, async (completedCard) => {
         await this.onCardCompleted?.(completedCard);
       }));
@@ -5030,36 +5177,40 @@ class Pool {
     if (config.review.enabled) {
       for (let i = 0;i < config.review.poolSize; i++) {
         const reviewWorkerId = config.poolSize + i;
-        this.reviewWorkers.push(new ReviewWorker(reviewWorkerId, config, client, userEmail, () => {
-          this.tryDispatchFor(this.reviewWorkers, this.reviewQueue, "review");
+        this.reviewWorkers.push(new ReviewWorker(reviewWorkerId, config, client, this.agentId, () => {
+          try {
+            this.tryDispatchFor(this.reviewWorkers, this.reviewQueue, "review");
+          } finally {
+            this.sleepGuard.release();
+          }
         }, stateStore, workspaceId, projectId));
       }
     }
   }
   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(TAG23, `Card ${card.id} already queued or active, skipping`);
+      log.debug(TAG24, `Card ${card.id} already queued or active, skipping`);
       return;
     }
     if (mode === "implement") {
       const decision = this.budget.check(card.id);
       if (!decision.allow) {
         if (decision.reason === "daily_budget") {
-          log.warn(TAG23, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
+          log.warn(TAG24, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
           await this.emitWaiting(card.id, `Daily budget reached — waiting for reset (${decision.detail})`);
         } else {
-          log.debug(TAG23, `#${card.short_id} gave up: ${decision.detail}`);
+          log.debug(TAG24, `#${card.short_id} gave up: ${decision.detail}`);
         }
         return;
       }
       const blockers = await getUnresolvedBlockers(this.client, card, this.projectId);
       if (blockers === null) {
-        log.warn(TAG23, `#${card.short_id} blocker check failed — deferring to next tick`);
+        log.warn(TAG24, `#${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(TAG23, `#${card.short_id} blocked by ${list} — waiting`);
+        log.info(TAG24, `#${card.short_id} blocked by ${list} — waiting`);
         await this.emitWaiting(card.id, `Blocked by ${list} — waiting for chain`);
         return;
       }
@@ -5088,7 +5239,7 @@ class Pool {
       });
       this.lastWaitingEmit.set(cardId, currentTask);
     } catch (err) {
-      log.debug(TAG23, `waiting emit failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+      log.debug(TAG24, `waiting emit failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
     }
   }
   async removeCard(cardId) {
@@ -5098,13 +5249,13 @@ class Pool {
       const removed = queue.remove(cardId);
       if (removed) {
         this.cardDataCache.delete(cardId);
-        log.info(TAG23, `Removed #${removed.shortId} from ${removed.mode} queue`);
+        log.info(TAG24, `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(TAG23, `Cancelling worker ${worker.id} for card ${cardId}`);
+      log.info(TAG24, `Cancelling worker ${worker.id} for card ${cardId}`);
       await worker.cancel();
     }
   }
@@ -5132,10 +5283,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(TAG23, `No active worker for card ${cardId}, ignoring ${command}`);
+      log.debug(TAG24, `No active worker for card ${cardId}, ignoring ${command}`);
       return;
     }
-    log.info(TAG23, `Agent command: ${command} → worker ${worker.id} (card ${cardId})`);
+    log.info(TAG24, `Agent command: ${command} → worker ${worker.id} (card ${cardId})`);
     switch (command) {
       case "pause":
         await worker.pause();
@@ -5181,19 +5332,23 @@ class Pool {
     };
   }
   async shutdown() {
-    log.info(TAG23, "Shutting down pool...");
+    log.info(TAG24, "Shutting down pool...");
+    this.shuttingDown = true;
     const active = [
       ...this.implWorkers.filter((w) => w.isActive),
       ...this.reviewWorkers.filter((w) => w.isActive)
     ];
     await Promise.all(active.map((w) => w.cancel()));
-    log.info(TAG23, "Pool shutdown complete");
+    this.sleepGuard.stop();
+    log.info(TAG24, "Pool shutdown complete");
   }
   cardDataCache = new Map;
   tryDispatchFor(workers, queue, label) {
+    if (this.shuttingDown)
+      return false;
     const idle = workers.find((w) => w.isIdle);
     if (!idle) {
-      log.debug(TAG23, `No idle ${label} workers (queue: ${queue.length})`);
+      log.debug(TAG24, `No idle ${label} workers (queue: ${queue.length})`);
       return false;
     }
     const next = queue.dequeue();
@@ -5201,21 +5356,23 @@ class Pool {
       return false;
     const data = this.cardDataCache.get(next.cardId);
     if (!data) {
-      log.warn(TAG23, `No cached data for card ${next.cardId}, skipping`);
+      log.warn(TAG24, `No cached data for card ${next.cardId}, skipping`);
       return false;
     }
     this.cardDataCache.delete(next.cardId);
     this.lastWaitingEmit.delete(next.cardId);
-    log.info(TAG23, `Dispatching #${next.shortId} to ${label} worker ${idle.id}`);
+    log.info(TAG24, `Dispatching #${next.shortId} to ${label} worker ${idle.id}`);
+    this.sleepGuard.acquire();
     idle.run(data.card, data.column, data.labels, data.subtasks);
     return true;
   }
 }
-var TAG23 = "pool";
+var TAG24 = "pool";
 var init_pool = __esm(() => {
   init_log();
   init_queue();
   init_review_worker();
+  init_sleep_guard();
   init_types();
   init_unblock();
   init_worker();
@@ -5237,7 +5394,7 @@ async function fetchCardSafely(client, cardId) {
     const { card } = await client.getCard(cardId);
     return card;
   } catch (err) {
-    log.warn(TAG24, `cannot fetch card ${cardId}: ${err instanceof Error ? err.message : err}`);
+    log.warn(TAG25, `cannot fetch card ${cardId}: ${err instanceof Error ? err.message : err}`);
     return null;
   }
 }
@@ -5247,7 +5404,7 @@ async function recoverOrphans(store, client, config) {
     return [];
   }
   const outcomes = [];
-  log.info(TAG24, `recovering ${active.length} orphan run(s) from prior daemon`);
+  log.info(TAG25, `recovering ${active.length} orphan run(s) from prior daemon`);
   for (const run of active) {
     const outcome = {
       runId: run.runId,
@@ -5259,11 +5416,11 @@ async function recoverOrphans(store, client, config) {
     };
     outcomes.push(outcome);
     if (isProcessAlive(run.daemonPid, process.pid)) {
-      log.warn(TAG24, `run ${run.runId} claims live daemon pid ${run.daemonPid} — skipping`);
+      log.warn(TAG25, `run ${run.runId} claims live daemon pid ${run.daemonPid} — skipping`);
       outcome.actions.push("skipped: daemon pid still alive");
       continue;
     }
-    log.info(TAG24, `recovering ${run.pipeline} run ${run.runId} for card #${run.cardShortId}`);
+    log.info(TAG25, `recovering ${run.pipeline} run ${run.runId} for card #${run.cardShortId}`);
     await recoverRun(run, store, client, config, outcome);
   }
   return outcomes;
@@ -5281,7 +5438,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(TAG24, `endAgentSession failed for ${run.cardId}: ${msg}`);
+    log.warn(TAG25, `endAgentSession failed for ${run.cardId}: ${msg}`);
   }
   const card = await fetchCardSafely(client, run.cardId);
   if (card) {
@@ -5322,9 +5479,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(TAG24, `recovered run ${run.runId} (card #${run.cardShortId}): ${outcome.actions.join(", ")}${outcome.errors.length ? ` | errors: ${outcome.errors.join("; ")}` : ""}`);
+  log.info(TAG25, `recovered run ${run.runId} (card #${run.cardShortId}): ${outcome.actions.join(", ")}${outcome.errors.length ? ` | errors: ${outcome.errors.join("; ")}` : ""}`);
 }
-var TAG24 = "recovery", RECOVERED_LABEL = "agent-recovered", RECOVERED_LABEL_COLOR = "#f59e0b";
+var TAG25 = "recovery", RECOVERED_LABEL = "agent-recovered", RECOVERED_LABEL_COLOR = "#f59e0b";
 var init_recovery = __esm(() => {
   init_board_helpers();
   init_log();
@@ -5336,7 +5493,7 @@ class Reconciler {
   client;
   pool;
   projectId;
-  agentUserId;
+  agentId;
   pickupColumns;
   reviewColumns;
   approvedLabel;
@@ -5351,11 +5508,11 @@ class Reconciler {
   get isRunning() {
     return this.timer !== null;
   }
-  constructor(client, pool, projectId, agentUserId, pickupColumns, reviewColumns, approvedLabel, intervalMs = 60000, stateStore, agentConfig) {
+  constructor(client, pool, projectId, agentId, pickupColumns, reviewColumns, approvedLabel, intervalMs = 60000, stateStore, agentConfig) {
     this.client = client;
     this.pool = pool;
     this.projectId = projectId;
-    this.agentUserId = agentUserId;
+    this.agentId = agentId;
     this.pickupColumns = pickupColumns;
     this.reviewColumns = reviewColumns;
     this.approvedLabel = approvedLabel;
@@ -5372,7 +5529,7 @@ class Reconciler {
       clearInterval(this.timer);
       this.timer = null;
     }
-    log.info(TAG25, "Heartbeat stopped");
+    log.info(TAG26, "Heartbeat stopped");
   }
   async recoverStaleRuns() {
     if (!this.stateStore || !this.agentConfig)
@@ -5389,7 +5546,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(TAG25, `zombie run ${run.runId} (#${run.cardShortId}): ${reason} — recovering`);
+      log.warn(TAG26, `zombie run ${run.runId} (#${run.cardShortId}): ${reason} — recovering`);
       await recoverRun(run, this.stateStore, this.client, this.agentConfig, {
         runId: run.runId,
         cardId: run.cardId,
@@ -5413,9 +5570,9 @@ class Reconciler {
       }
       const pickupColumnIds = new Set(columns.filter((c) => this.pickupColumns.some((name) => name.toLowerCase() === c.name.toLowerCase())).map((c) => c.id));
       const reviewColumnIds = new Set(columns.filter((c) => this.reviewColumns.some((name) => name.toLowerCase() === c.name.toLowerCase())).map((c) => c.id));
-      const assignedCards = cards.filter((c) => c.assignee_id === this.agentUserId && !c.archived_at && (pickupColumnIds.has(c.column_id) || reviewColumnIds.has(c.column_id)));
+      const assignedCards = cards.filter((c) => c.assigned_agent_id === this.agentId && !c.archived_at && (pickupColumnIds.has(c.column_id) || reviewColumnIds.has(c.column_id)));
       const knownCardIds = this.pool.knownCardIds();
-      const allAgentCardIds = new Set(cards.filter((c) => c.assignee_id === this.agentUserId && !c.archived_at).map((c) => c.id));
+      const allAgentCardIds = new Set(cards.filter((c) => c.assigned_agent_id === this.agentId && !c.archived_at).map((c) => c.id));
       for (const card of assignedCards) {
         if (!knownCardIds.has(card.id)) {
           const column = columnMap.get(card.column_id);
@@ -5425,18 +5582,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(TAG25, `Skipping #${card.short_id} — already has "${this.approvedLabel}" label`);
+            log.debug(TAG26, `Skipping #${card.short_id} — already has "${this.approvedLabel}" label`);
             continue;
           }
           if (mode === "review" && hasLabel(cardLabels, NEED_REVIEW_LABEL)) {
-            log.debug(TAG25, `Skipping #${card.short_id} — has "${NEED_REVIEW_LABEL}" label (needs human)`);
+            log.debug(TAG26, `Skipping #${card.short_id} — has "${NEED_REVIEW_LABEL}" label (needs human)`);
             continue;
           }
           if (mode === "review" && !extractBranchFromDescription(card.description)) {
-            log.debug(TAG25, `Skipping #${card.short_id} — no branch reference (not qualified for auto-review)`);
+            log.debug(TAG26, `Skipping #${card.short_id} — no branch reference (not qualified for auto-review)`);
             continue;
           }
-          log.info(TAG25, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — enqueueing`);
+          log.info(TAG26, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — enqueueing`);
           await this.pool.enqueue(card, column, cardLabels, subtasks, mode);
         }
       }
@@ -5445,17 +5602,17 @@ class Reconciler {
       }
       for (const knownId of knownCardIds) {
         if (!allAgentCardIds.has(knownId)) {
-          log.info(TAG25, `Missed unassign: ${knownId} — removing`);
+          log.info(TAG26, `Missed unassign: ${knownId} — removing`);
           await this.pool.removeCard(knownId);
         }
       }
-      log.debug(TAG25, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
+      log.debug(TAG26, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
     } catch (err) {
-      log.error(TAG25, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG26, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG25 = "reconcile";
+var TAG26 = "reconcile";
 var init_reconcile = __esm(() => {
   init_board_helpers();
   init_log();
@@ -5489,7 +5646,7 @@ function prettyBanner(config, version) {
       checks.push({ kind: "ok", message });
     },
     warn(message) {
-      log.warn(TAG26, message);
+      log.warn(TAG27, message);
       checks.push({ kind: "warn", message: message.split(`
 `, 1)[0] });
     },
@@ -5513,22 +5670,22 @@ function prettyBanner(config, version) {
   };
 }
 function jsonBanner(config, version) {
-  log.info(TAG26, `Harmony Agent Daemon v${version} starting...`);
-  log.info(TAG26, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Model: ${config.agent.claude.model} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
+  log.info(TAG27, `Harmony Agent Daemon v${version} starting...`);
+  log.info(TAG27, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Model: ${config.agent.claude.model} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
   if (config.agent.review.enabled) {
-    log.info(TAG26, `Review: enabled | Columns: ${config.agent.review.pickupColumns.join(", ")} | → ${config.agent.review.moveToColumn} / ${config.agent.review.failColumn}`);
+    log.info(TAG27, `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(TAG26, `Git provider: ${provider}`);
+      log.info(TAG27, `Git provider: ${provider}`);
     },
     check(message) {
-      log.info(TAG26, message);
+      log.info(TAG27, message);
     },
     warn(message) {
-      log.warn(TAG26, message);
+      log.warn(TAG27, message);
     },
     fail() {
       failed = true;
@@ -5536,7 +5693,7 @@ function jsonBanner(config, version) {
     async ready(message) {
       if (failed)
         return;
-      log.info(TAG26, message);
+      log.info(TAG27, message);
     }
   };
 }
@@ -5603,7 +5760,7 @@ function cyan(s) {
 function yellow(s) {
   return `${ANSI.yellow}${s}${ANSI.reset}`;
 }
-var TAG26 = "daemon", RULE_WIDTH = 70, ANSI;
+var TAG27 = "daemon", RULE_WIDTH = 70, ANSI;
 var init_startup_banner = __esm(() => {
   init_log();
   ANSI = {
@@ -5750,18 +5907,18 @@ class Watcher {
   }
   async start() {
     if (!isPretty()) {
-      log.info(TAG27, "Connecting to Supabase realtime (broadcast)...");
+      log.info(TAG28, "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(TAG27, `Broadcast: card_update ${JSON.stringify(msg.payload)}`);
+      log.debug(TAG28, `Broadcast: card_update ${JSON.stringify(msg.payload)}`);
       this.onCardBroadcast({
         event: "card_update",
         payload: msg.payload ?? {}
       });
     }).on("broadcast", { event: "card_created" }, (msg) => {
-      log.debug(TAG27, `Broadcast: card_created ${JSON.stringify(msg.payload)}`);
+      log.debug(TAG28, `Broadcast: card_created ${JSON.stringify(msg.payload)}`);
       this.onCardBroadcast({
         event: "card_created",
         payload: msg.payload ?? {}
@@ -5771,41 +5928,42 @@ class Watcher {
       const cardId = payload.card_id;
       const command = payload.command;
       if (cardId && command) {
-        log.info(TAG27, `Broadcast: agent_command ${command} for ${cardId}`);
+        log.info(TAG28, `Broadcast: agent_command ${command} for ${cardId}`);
         this.onAgentCommand?.({ cardId, command });
       }
     }).subscribe((status) => {
       if (status === "SUBSCRIBED") {
         this.connected = true;
         if (!isPretty() || !this.suppressStartupLogs) {
-          log.info(TAG27, "Broadcast subscription active");
+          log.info(TAG28, "Broadcast subscription active");
         }
         this.maybeResolveReady();
       } else if (status === "CHANNEL_ERROR") {
         this.connected = false;
-        log.error(TAG27, "Broadcast channel error — will rely on reconciliation");
+        log.error(TAG28, "Broadcast channel error — will rely on reconciliation");
       } else if (status === "TIMED_OUT") {
         this.connected = false;
-        log.warn(TAG27, "Broadcast subscription timed out — retrying...");
+        log.warn(TAG28, "Broadcast subscription timed out — retrying...");
       } else if (status === "CLOSED") {
         this.connected = false;
       }
     });
     this.channel = channel;
     presenceChannel.on("presence", { event: "sync" }, () => {
-      log.debug(TAG27, "Presence sync");
+      log.debug(TAG28, "Presence sync");
     }).subscribe(async (status) => {
       if (status === "SUBSCRIBED") {
         await presenceChannel.track({
           daemonId: this.daemonId,
           startedAt: new Date().toISOString(),
           userId: this.identity.userId,
+          agentId: this.identity.agentId,
           userEmail: this.identity.userEmail,
           agentIdentifier: this.identity.agentIdentifier,
           agentName: this.identity.agentName
         });
         if (!isPretty() || !this.suppressStartupLogs) {
-          log.info(TAG27, "Presence tracked on board-presence channel");
+          log.info(TAG28, "Presence tracked on board-presence channel");
         }
         this.presenceTracked = true;
         this.maybeResolveReady();
@@ -5827,10 +5985,10 @@ class Watcher {
       this.supabase = null;
     }
     this.connected = false;
-    log.info(TAG27, "Broadcast subscription stopped");
+    log.info(TAG28, "Broadcast subscription stopped");
   }
 }
-var TAG27 = "watcher";
+var TAG28 = "watcher";
 var init_watcher = __esm(() => {
   init_log();
 });
@@ -5905,10 +6063,10 @@ function runWorktreeGc(basePath, store, opts = {}) {
     });
   } catch {}
   if (result.removed.length > 0) {
-    log.info(TAG28, `GC removed ${result.removed.length} orphan worktree(s): ${result.removed.map((p) => p.split("/").pop()).join(", ")}`);
+    log.info(TAG29, `GC removed ${result.removed.length} orphan worktree(s): ${result.removed.map((p) => p.split("/").pop()).join(", ")}`);
   }
   if (result.errors.length > 0) {
-    log.warn(TAG28, `GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.path}: ${e.error}`).join("; ")}`);
+    log.warn(TAG29, `GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.path}: ${e.error}`).join("; ")}`);
   }
   return result;
 }
@@ -5985,10 +6143,10 @@ function pruneFailedRemoteBranches(opts) {
     }
   }
   if (result.removed.length > 0) {
-    log.info(TAG28, `Pruned ${result.removed.length} stale remote branch(es) under ${opts.prefix}: ${result.removed.join(", ")}`);
+    log.info(TAG29, `Pruned ${result.removed.length} stale remote branch(es) under ${opts.prefix}: ${result.removed.join(", ")}`);
   }
   if (result.errors.length > 0) {
-    log.warn(TAG28, `Remote branch GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.ref}: ${e.error}`).join("; ")}`);
+    log.warn(TAG29, `Remote branch GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.ref}: ${e.error}`).join("; ")}`);
   }
   return result;
 }
@@ -6019,13 +6177,13 @@ class WorktreeGc {
     try {
       runWorktreeGc(this.basePath, this.store);
     } catch (err) {
-      log.warn(TAG28, `GC tick failed: ${err instanceof Error ? err.message : err}`);
+      log.warn(TAG29, `GC tick failed: ${err instanceof Error ? err.message : err}`);
     }
     if (this.remoteOpts) {
       try {
         pruneFailedRemoteBranches(this.remoteOpts);
       } catch (err) {
-        log.warn(TAG28, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
+        log.warn(TAG29, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -6039,7 +6197,7 @@ function getRepoRoot2() {
     return null;
   }
 }
-var TAG28 = "worktree-gc";
+var TAG29 = "worktree-gc";
 var init_worktree_gc = __esm(() => {
   init_log();
   init_worktree();
@@ -6121,7 +6279,7 @@ async function main() {
   } catch (err) {
     if (err instanceof ConfigValidationError) {
       banner.fail();
-      log.error(TAG29, err.message);
+      log.error(TAG30, err.message);
       process.exit(1);
     }
     throw err;
@@ -6136,20 +6294,27 @@ async function main() {
     const errored = outcomes.filter((o) => o.errors.length).length;
     banner.check(`Recovery: ${outcomes.length} orphan(s) handled${errored > 0 ? `, ${errored} with errors` : ""}`);
   }
+  const { agent: registeredAgent } = await client.registerWorkspaceAgent(config.workspaceId, {
+    identifier: config.agentIdentifier,
+    name: config.agentName,
+    color: config.agentColor
+  });
+  const agentId = registeredAgent.id;
+  banner.check(`Agent registered (${config.agentName})`);
   const realtimeCreds = await fetchRealtimeCredentials(client);
   banner.check("Realtime credentials");
-  const pool = new Pool(config.agent, client, config.userEmail, config.workspaceId, config.projectId, stateStore);
+  const pool = new Pool(config.agent, client, config.userEmail, config.workspaceId, config.projectId, stateStore, agentId);
   const promoteSuccessors = async (completedCard) => {
     await promoteUnblockedSuccessors(completedCard, {
       client,
-      agentUserId,
-      enqueue: (cardId) => tryEnqueueCard(cardId, client, pool, config)
+      agentId,
+      enqueue: (cardId) => tryEnqueueCard(cardId, client, pool, config, agentId)
     });
   };
   pool.onCardCompleted = promoteSuccessors;
   const reviewColumns = config.agent.review.enabled ? config.agent.review.pickupColumns : [];
   const approvedLabel = config.agent.review.enabled ? config.agent.review.approvedLabel : "";
-  const reconciler = new Reconciler(client, pool, config.projectId, agentUserId, config.agent.pickupColumns, reviewColumns, approvedLabel, config.agent.timing.reconcileIntervalMs, stateStore, config.agent);
+  const reconciler = new Reconciler(client, pool, config.projectId, agentId, config.agent.pickupColumns, reviewColumns, approvedLabel, config.agent.timing.reconcileIntervalMs, stateStore, config.agent);
   let mergeMonitor = null;
   if (config.agent.review.enabled && config.agent.review.mergeMonitor) {
     mergeMonitor = new MergeMonitor(client, config.projectId, config.agent);
@@ -6208,11 +6373,12 @@ async function main() {
   }) : null;
   const watcher = new Watcher(realtimeCreds, config.projectId, {
     userId: agentUserId,
+    agentId,
     userEmail: config.userEmail,
-    agentIdentifier: "harmony-daemon",
-    agentName: AGENT_NAME
+    agentIdentifier: config.agentIdentifier,
+    agentName: config.agentName
   }, async (event) => {
-    await handleBroadcast(event, client, pool, config, agentUserId);
+    await handleBroadcast(event, client, pool, config, agentId);
   }, async (command) => {
     await pool.handleAgentCommand(command.cardId, command.command);
   });
@@ -6222,25 +6388,25 @@ async function main() {
     if (shuttingDown)
       return;
     shuttingDown = true;
-    log.info(TAG29, `Received ${signal}, shutting down gracefully...`);
+    log.info(TAG30, `Received ${signal}, shutting down gracefully...`);
     reconciler.stop();
     mergeMonitor?.stop();
     worktreeGc.stop();
     await httpServer?.stop();
     await watcher.stop();
     await pool.shutdown();
-    log.info(TAG29, "Daemon stopped.");
+    log.info(TAG30, "Daemon stopped.");
     process.exit(exitCode);
   };
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("uncaughtException", (err) => {
-    log.error(TAG29, `Uncaught exception: ${err.message}`);
+    log.error(TAG30, `Uncaught exception: ${err.message}`);
     exitCode = 1;
     shutdown("uncaughtException");
   });
   process.on("unhandledRejection", (reason) => {
-    log.error(TAG29, `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
+    log.error(TAG30, `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
     exitCode = 1;
     shutdown("unhandledRejection");
   });
@@ -6278,39 +6444,43 @@ async function main() {
   await banner.ready("watching for card assignments");
   watcher.allowStartupLogs();
 }
-async function handleBroadcast(event, client, pool, config, agentUserId) {
+async function handleBroadcast(event, client, pool, config, agentId) {
   const payload = event.payload;
   const cardId = payload.card_id;
   if (!cardId)
     return;
-  const assigneeId = payload.assignee_id;
-  if (assigneeId === undefined)
+  const assignedAgentId = payload.assigned_agent_id;
+  if (assignedAgentId === undefined)
     return;
-  if (assigneeId === agentUserId) {
-    log.info(TAG29, `Broadcast: card ${cardId} assigned to agent`);
+  if (assignedAgentId === agentId) {
+    log.info(TAG30, `Broadcast: card ${cardId} assigned to agent`);
     try {
-      await tryEnqueueCard(cardId, client, pool, config);
+      await tryEnqueueCard(cardId, client, pool, config, agentId);
     } catch (err) {
-      log.error(TAG29, `Failed to process assignment: ${err instanceof Error ? err.message : err}`);
+      log.error(TAG30, `Failed to process assignment: ${err instanceof Error ? err.message : err}`);
     }
   } else if (pool.isCardKnown(cardId)) {
-    log.info(TAG29, `Broadcast: card ${cardId} unassigned from agent`);
+    log.info(TAG30, `Broadcast: card ${cardId} unassigned from agent`);
     await pool.removeCard(cardId);
   }
 }
-async function tryEnqueueCard(cardId, client, pool, config) {
+async function tryEnqueueCard(cardId, client, pool, config, agentId) {
   const { card } = await client.getCard(cardId);
+  if (card.assigned_agent_id !== agentId) {
+    log.debug(TAG30, `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(TAG29, `Column not found for card ${cardId}`);
+    log.warn(TAG30, `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(TAG29, `Card #${card.short_id} is in "${column.name}", not a pickup/review column — skipping`);
+    log.info(TAG30, `Card #${card.short_id} is in "${column.name}", not a pickup/review column — skipping`);
     return;
   }
   const mode = isReviewColumn ? "review" : "implement";
@@ -6318,16 +6488,16 @@ async function tryEnqueueCard(cardId, client, pool, config) {
   const cardLabels = resolveCardLabels(card, labelMap);
   const subtasks = card.subtasks ?? [];
   if (mode === "review" && config.agent.review.approvedLabel && hasLabel(cardLabels, config.agent.review.approvedLabel)) {
-    log.debug(TAG29, `Card #${card.short_id} already has "${config.agent.review.approvedLabel}" — skipping review`);
+    log.debug(TAG30, `Card #${card.short_id} already has "${config.agent.review.approvedLabel}" — skipping review`);
     return;
   }
   if (mode === "review" && !extractBranchFromDescription(card.description)) {
-    log.info(TAG29, `Card #${card.short_id} has no branch reference — skipping auto-review`);
+    log.info(TAG30, `Card #${card.short_id} has no branch reference — skipping auto-review`);
     return;
   }
   await pool.enqueue(card, column, cardLabels, subtasks, mode);
 }
-var TAG29 = "daemon", PKG_VERSION;
+var TAG30 = "daemon", PKG_VERSION;
 var init_src = __esm(() => {
   init_board_helpers();
   init_config();
@@ -6343,7 +6513,6 @@ var init_src = __esm(() => {
   init_startup_banner();
   init_state_store();
   init_stream_parser_selftest();
-  init_types();
   init_unblock();
   init_watcher();
   init_worktree_gc();