kantban-cli 0.1.47 → 0.1.51

package/dist/{pipeline-EUOOLKHN.js → pipeline-6J64Z7VH.js}

@@ -1,6 +1,6 @@
 import {
   runGates
-} from "./chunk-O47Q6CNM.js";
+} from "./chunk-GQQUH3TA.js";
 import {
   ClaudeProvider,
   RalphLoop,
@@ -8,11 +8,13 @@ import {
   cleanupGateProxyConfigs,
   cleanupMcpConfig,
   composeStuckDetectionPrompt,
+  detectBranchMerged,
   generateGateProxyMcpConfig,
   generateMcpConfig,
   parseJsonFromLlmOutput,
-  parseStuckDetectionResponse
-} from "./chunk-UKWQ6VUQ.js";
+  parseStuckDetectionResponse,
+  reapOrphanedMcpConfigDirs
+} from "./chunk-X2CJ3ZAI.js";
 import {
   LoopCheckpointSchema,
   VerdictSchema,
@@ -20,7 +22,7 @@ import {
   parseGateConfig,
   parseTimeout,
   resolveGatesForColumn
-} from "./chunk-VDCHOIQI.js";
+} from "./chunk-4R27WTCJ.js";
 import {
   IS_WINDOWS,
   crossSpawnOptions,
@@ -30,9 +32,17 @@ import {
 } from "./chunk-5ZU2OOES.js";
 
 // src/commands/pipeline.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, readFileSync as readFileSync3, unlinkSync as unlinkSync3, existsSync as existsSync3, appendFileSync as appendFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, readFileSync as readFileSync3, unlinkSync as unlinkSync3, existsSync as existsSync3, appendFileSync as appendFileSync2, promises as fsPromises } from "fs";
+import { execFile } from "child_process";
+import { homedir as homedir3 } from "os";
+import { join as join4, dirname as dirname2, resolve, sep } from "path";
+import { promisify } from "util";
+
+// src/lib/harness-signal.ts
+var HARNESS_SIGNAL_PREFIX = "@harness:";
+function createHarnessSignalContent(kind, payload) {
+  return HARNESS_SIGNAL_PREFIX + JSON.stringify({ ...payload, kind });
+}
 
 // src/lib/tool-profiles.ts
 function resolveToolRestrictions(builtinTools, allowedTools, disallowedTools) {
@@ -50,6 +60,8 @@ function resolveToolRestrictions(builtinTools, allowedTools, disallowedTools) {
 
 // src/lib/worktree.ts
 import { execFile as defaultExecFile, execFileSync } from "child_process";
+import { homedir } from "os";
+import { join } from "path";
 function generateWorktreeName(ticketNumber, columnName) {
   const slug = columnSlug(columnName);
   return `kantban-${ticketNumber}-${slug}`;
@@ -57,10 +69,16 @@ function generateWorktreeName(ticketNumber, columnName) {
 function columnSlug(columnName) {
   return columnName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
-function renderWorktreePath(ticketNumber, columnName, pathPattern) {
+function renderWorktreePath(ticketNumber, columnName, pathPattern, options) {
+  const slug = columnSlug(columnName);
   const worktreeName = generateWorktreeName(ticketNumber, columnName);
-  if (!pathPattern) return worktreeName;
-  return pathPattern.replace(/\{ticket_number\}/g, String(ticketNumber)).replace(/\{column_slug\}/g, columnSlug(columnName)).replace(/\{worktree_name\}/g, worktreeName);
+  if (pathPattern) {
+    return pathPattern.replace(/\{ticket_number\}/g, String(ticketNumber)).replace(/\{column_slug\}/g, slug).replace(/\{worktree_name\}/g, worktreeName);
+  }
+  return join(options.defaultRoot, options.boardId, slug, String(ticketNumber));
+}
+function defaultWorktreeRoot() {
+  return join(homedir(), ".kantban", "worktrees");
 }
 function isPlausibleRemoteUrl(url) {
   return url.includes("/") || url.includes("@") || url.includes("://");
@@ -108,22 +126,22 @@ async function cleanupWorktree(worktreeName, exec = defaultExecFile) {
   } catch {
     return true;
   }
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     exec("git", ["worktree", "remove", "--force", target], (err) => {
       if (err) {
         console.error(`[worktree] cleanup failed for ${worktreeName} (${target}): ${err.message}`);
-        resolve(false);
+        resolve2(false);
       } else {
-        resolve(true);
+        resolve2(true);
       }
     });
   });
 }
 function execPromise(exec, cmd, args) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     exec(cmd, args, (err, stdout, stderr) => {
       if (err) reject(Object.assign(err, { stdout, stderr }));
-      else resolve({ stdout, stderr });
+      else resolve2({ stdout, stderr });
     });
   });
 }
@@ -470,7 +488,9 @@ function parseReplannerResponse(raw) {
 }
 
 // src/lib/orchestrator.ts
-var ACTIVE_LOOP_ZOMBIE_TTL_MS = 90 * 60 * 1e3;
+var ACTIVE_LOOP_ZOMBIE_TTL_MS = Number(
+  process.env.ACTIVE_LOOP_ZOMBIE_TTL_MS
+) || 3 * 60 * 60 * 1e3;
 function classifyTier(input) {
   if (input.invocationTier === "light") return "light";
   if (input.invocationTier === "heavy") return "heavy";
@@ -510,6 +530,12 @@ var PipelineOrchestrator = class {
   blockedColumns = /* @__PURE__ */ new Set();
   /** Per-ticket advisor invocation count for the current column transit */
   advisorBudget = /* @__PURE__ */ new Map();
+  /** Count of advisor-driven retries per ticket in the current column transit.
+   *  Cleared on ticket:moved/archived/deleted and in terminalCleanup. */
+  gutterResetCount = /* @__PURE__ */ new Map();
+  gutterResetExhausted = /* @__PURE__ */ new Set();
+  /** Per-ticket deferred-dispatch signal state — used for dedup and cleanup */
+  deferredState = /* @__PURE__ */ new Map();
   /** Per-ticket model override (set by RETRY_DIFFERENT_MODEL, consumed by startTrackedLoop) */
   ticketModelOverrides = /* @__PURE__ */ new Map();
   /** Stable session ID for this orchestrator instance (pipeline run) */
@@ -555,6 +581,10 @@ var PipelineOrchestrator = class {
   get allBoardColumnNames() {
     return this.cachedBoardScope?.columns.map((c) => c.name) ?? [];
   }
+  /** Returns {name, type} for every column on the board. */
+  get allBoardColumns() {
+    return this.cachedBoardScope?.columns.map((c) => ({ name: c.name, type: c.type })) ?? [];
+  }
   /** Returns the total number of active loops. */
   get activeLoopCount() {
     return this.activeLoops.size;
@@ -633,12 +663,16 @@ var PipelineOrchestrator = class {
           } : void 0,
           builtinTools: cfg?.builtin_tools,
           allowedTools: cfg?.allowed_tools,
-          disallowedTools: cfg?.disallowed_tools
+          disallowedTools: cfg?.disallowed_tools,
+          maxGutterResetsPerTransit: cfg?.max_gutter_resets_per_transit,
+          repromptOnBranchMerged: cfg?.reprompt_on_branch_merged,
+          maxRepromptAttempts: cfg?.max_reprompt_attempts
         });
         this.columnScopes.set(col.id, colScope);
         this.loopQueues.set(col.id, []);
       })
     );
+    console.error(`[orchestrator] zombie TTL: ${ACTIVE_LOOP_ZOMBIE_TTL_MS}ms`);
   }
   /**
    * Refresh the cached column scope for a single column.
@@ -919,8 +953,8 @@ var PipelineOrchestrator = class {
     }
     for (const [ticketId, columnId] of Array.from(this.deferredTickets)) {
       try {
-        const stillBlocked = await this.deps.hasUnresolvedBlockers(ticketId);
-        if (!stillBlocked) {
+        const blocker = await this.deps.hasUnresolvedBlockers(ticketId);
+        if (!blocker.blocked) {
           this.deferredTickets.delete(ticketId);
           await this.spawnOrQueue(ticketId, columnId, true);
         } else {
@@ -934,23 +968,56 @@ var PipelineOrchestrator = class {
     }
     await this.refreshBoardScope();
     this.blockedColumns.clear();
-    for (const [columnId] of this.pipelineColumns) {
-      await this.refreshColumnScope(columnId);
-      const colScope = this.columnScopes.get(columnId);
-      if (!colScope) {
-        console.error(`  [scan] Column ${columnId}: no cached scope`);
-        continue;
-      }
-      if (this.isColumnBlocked(columnId)) {
-        this.blockedColumns.add(columnId);
-        console.error(`  [scan] Column ${columnId} (${colScope.column.name}): BLOCKED by firing constraints \u2014 skipping ${String(colScope.tickets.length)} ticket(s)`);
-        continue;
-      }
-      console.error(`  [scan] Column ${columnId} (${colScope.column.name}): ${String(colScope.tickets.length)} ticket(s)`);
-      for (const ticket of colScope.tickets) {
-        await this.spawnOrQueue(ticket.id, columnId);
-      }
-    }
+    await Promise.all(
+      Array.from(this.pipelineColumns.keys()).map(async (columnId) => {
+        await this.refreshColumnScope(columnId);
+        const colScope = this.columnScopes.get(columnId);
+        if (!colScope) {
+          console.error(`  [scan] column=${columnId} reason="no cached scope"`);
+          return;
+        }
+        if (this.isColumnBlocked(columnId)) {
+          this.blockedColumns.add(columnId);
+          console.error(
+            `  [scan] column=${columnId} name="${colScope.column.name}" tickets=${colScope.tickets.length} dispatched=0 queued=0 skipped=${colScope.tickets.length} reason="firing_constraint"`
+          );
+          for (const ticket of colScope.tickets) {
+            await this.emitDispatchDeferred(ticket.id, "firing_constraint", { columnId });
+          }
+          return;
+        }
+        let dispatched = 0;
+        let queued = 0;
+        let skipped = 0;
+        const reasons = /* @__PURE__ */ new Set();
+        for (const ticket of colScope.tickets) {
+          const wasActive = this.activeLoops.has(ticket.id) || this.spawning.has(ticket.id);
+          const wasQueued = (this.loopQueues.get(columnId) ?? []).includes(ticket.id);
+          const wasDeferred = this.deferredTickets.has(ticket.id);
+          await this.spawnOrQueue(ticket.id, columnId);
+          const nowActive = this.activeLoops.has(ticket.id) || this.spawning.has(ticket.id);
+          const nowQueued = (this.loopQueues.get(columnId) ?? []).includes(ticket.id);
+          const nowDeferred = this.deferredTickets.has(ticket.id);
+          if (!wasActive && nowActive) {
+            dispatched++;
+            reasons.add("dispatched");
+          } else if (!wasQueued && nowQueued) {
+            queued++;
+            reasons.add("capped");
+          } else if (!wasDeferred && nowDeferred) {
+            skipped++;
+            reasons.add("blocked");
+          } else {
+            skipped++;
+            reasons.add("known");
+          }
+        }
+        const reason = reasons.size === 0 ? "none" : reasons.size === 1 ? [...reasons][0] : "mixed";
+        console.error(
+          `  [scan] column=${columnId} name="${colScope.column.name}" tickets=${colScope.tickets.length} dispatched=${dispatched} queued=${queued} skipped=${skipped} reason="${reason}"`
+        );
+      })
+    );
   }
   /**
    * Handle a pipeline event (typically from WebSocket via EventQueue).
@@ -970,6 +1037,7 @@ var PipelineOrchestrator = class {
           this.knownTickets.delete(event.ticketId);
           this.spawning.delete(event.ticketId);
           this.deferredTickets.delete(event.ticketId);
+          void this.clearDispatchDeferred(event.ticketId);
           const oldQueue = this.loopQueues.get(event.fromColumnId);
           if (oldQueue) {
             const idx = oldQueue.indexOf(event.ticketId);
@@ -984,6 +1052,7 @@ var PipelineOrchestrator = class {
           if (this.isColumnBlocked(event.columnId)) {
             console.error(`  [event] ${event.type} ${event.ticketId} \u2192 column ${event.columnId}: BLOCKED by firing constraints \u2014 deferred`);
             this.deferredTickets.set(event.ticketId, event.columnId);
+            await this.emitDispatchDeferred(event.ticketId, "firing_constraint", { columnId: event.columnId });
           } else {
             await this.spawnOrQueue(event.ticketId, event.columnId, true);
           }
@@ -1033,6 +1102,9 @@ var PipelineOrchestrator = class {
         this.deferredTickets.delete(event.ticketId);
         this.spawning.delete(event.ticketId);
         this.advisorBudget.delete(event.ticketId);
+        this.gutterResetCount.delete(event.ticketId);
+        this.gutterResetExhausted.delete(event.ticketId);
+        void this.clearDispatchDeferred(event.ticketId);
         for (const [, queue] of this.loopQueues) {
           const idx = queue.indexOf(event.ticketId);
           if (idx !== -1) {
@@ -1067,15 +1139,59 @@ var PipelineOrchestrator = class {
       }
       return;
     }
+    const isMergeColumn = colConfig.name.toLowerCase().includes("merge");
+    if (isMergeColumn && colConfig.worktreeEnabled && this.deps.detectBranchMerged && this.deps.moveTicketToColumn) {
+      const ticket = this.columnScopes.get(columnId)?.tickets.find((t) => t.id === ticketId);
+      if (ticket) {
+        const wPath = renderWorktreePath(
+          ticket.ticket_number,
+          colConfig.name,
+          colConfig.worktreePathPattern,
+          { boardId: this.boardId, defaultRoot: defaultWorktreeRoot() }
+        );
+        try {
+          const mergeResult = await this.deps.detectBranchMerged({
+            worktreePath: wPath,
+            iterationStartedAt: /* @__PURE__ */ new Date(0),
+            targetBranch: colConfig.worktreeIntegrationBranch ?? "main"
+          });
+          if (mergeResult.merged) {
+            const nextColumnId = this.findNextColumnId(columnId);
+            if (nextColumnId) {
+              await this.deps.createComment(
+                ticketId,
+                `## Merge Complete (auto-finalized)
+
+Merge commit \`${mergeResult.mergeCommitSha}\` detected on \`origin/${colConfig.worktreeIntegrationBranch ?? "main"}\` at ${mergeResult.mergeCommitTime.toISOString()}. The previous agent did not record the column move before exiting; the orchestrator is finalizing the move now.`
+              );
+              await this.deps.moveTicketToColumn(ticketId, nextColumnId, {
+                reason: "merge_finalize_recovery",
+                merge_commit_sha: mergeResult.mergeCommitSha
+              });
+              console.error(
+                `  [merge-recovery] ticket=${ticketId} column=${columnId} target=${colConfig.worktreeIntegrationBranch ?? "main"} sha=${mergeResult.mergeCommitSha}`
+              );
+              return;
+            }
+          }
+        } catch {
+        }
+      }
+    }
     this.spawning.add(ticketId);
     this.reserveSlot(columnId);
     try {
-      const blocked = await this.deps.hasUnresolvedBlockers(ticketId);
-      if (blocked) {
+      const result = await this.deps.hasUnresolvedBlockers(ticketId);
+      if (result.blocked) {
         this.spawning.delete(ticketId);
         this.releaseSlot(columnId);
         this.deferredTickets.set(ticketId, columnId);
-        console.error(`  [skip] ${ticketId} has unresolved blockers \u2014 deferred`);
+        const blockerSummary = result.blockers.map((b) => `${b.ticket_number}:${b.column}`).join(",");
+        const linkIdSummary = result.linkIds.join(",");
+        console.error(
+          `  [scan] skip ticket=${ticketId} reason=blocks count=${result.blockers.length} link_ids=[${linkIdSummary}] blockers=[${blockerSummary}]`
+        );
+        void this.emitDispatchDeferred(ticketId, "unresolved_blockers", { columnId });
         void this.drainQueue(columnId).catch((err) => {
           const msg = err instanceof Error ? err.message : String(err);
           console.error(`  [error] drainQueue failed for column ${columnId}: ${msg}`);
@@ -1088,14 +1204,16 @@ var PipelineOrchestrator = class {
       this.spawning.delete(ticketId);
       this.releaseSlot(columnId);
       this.deferredTickets.set(ticketId, columnId);
-      void this.drainQueue(columnId).catch((err2) => {
-        const msg2 = err2 instanceof Error ? err2.message : String(err2);
-        console.error(`  [error] drainQueue failed for column ${columnId}: ${msg2}`);
+      void this.emitDispatchDeferred(ticketId, "unresolved_blockers", { columnId });
+      void this.drainQueue(columnId).catch((dErr) => {
+        const dMsg = dErr instanceof Error ? dErr.message : String(dErr);
+        console.error(`  [error] drainQueue failed for column ${columnId}: ${dMsg}`);
       });
       return;
     }
     try {
       await this.deps.claimTicket(ticketId);
+      await this.clearDispatchDeferred(ticketId);
       this.startTrackedLoop(ticketId, columnId, colConfig);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -1237,16 +1355,16 @@ var PipelineOrchestrator = class {
       gutterThreshold: config.gutterThreshold,
       ...effectiveModel !== void 0 && { model: effectiveModel },
       ...config.maxBudgetUsd !== void 0 && { maxBudgetUsd: config.maxBudgetUsd },
-      // Resolve worktree name (branch) and path from ticket context. When the
-      // column's agent_config specifies a path_pattern, the filesystem path is
-      // rendered from it — otherwise the name doubles as a relative path.
       ...(() => {
         const colScope = this.columnScopes.get(columnId);
         const ticket = colScope?.tickets.find((t) => t.id === ticketId);
         if (!config.worktreeEnabled || !ticket) return {};
         const wName = generateWorktreeName(ticket.ticket_number, config.name);
-        const wPath = renderWorktreePath(ticket.ticket_number, config.name, config.worktreePathPattern);
-        return wPath !== wName ? { worktreeName: wName, worktreePath: wPath } : { worktreeName: wName };
+        const wPath = renderWorktreePath(ticket.ticket_number, config.name, config.worktreePathPattern, {
+          boardId: this.boardId,
+          defaultRoot: defaultWorktreeRoot()
+        });
+        return { worktreeName: wName, worktreePath: wPath };
       })(),
       ...config.lookaheadColumnId !== void 0 && { lookaheadColumnId: config.lookaheadColumnId },
       // Resume from checkpoint iteration/gutter if provided
@@ -1254,6 +1372,8 @@ var PipelineOrchestrator = class {
       ...startGutterCount !== void 0 && { startGutterCount },
       ...startFingerprint !== void 0 && { startFingerprint },
       ...config.stuckDetection && { stuckDetection: config.stuckDetection },
+      ...config.repromptOnBranchMerged !== void 0 && { repromptOnBranchMerged: config.repromptOnBranchMerged },
+      ...config.maxRepromptAttempts !== void 0 && { maxRepromptAttempts: config.maxRepromptAttempts },
       ...this.deps.costTracker && { isBudgetExhausted: () => this.deps.costTracker.isExhausted() }
     };
     const toolRestrictions = resolveToolRestrictions(
@@ -1283,6 +1403,33 @@ var PipelineOrchestrator = class {
       })
     );
   }
+  /**
+   * Increment the gutter-reset counter and check the per-column cap.
+   * Returns false if the cap has been exceeded (and emits signal + comment).
+   * Callers should abort the retry on false.
+   */
+  async checkGutterResetCap(ticketId, colConfig) {
+    const cap = colConfig.maxGutterResetsPerTransit ?? 2;
+    const count = (this.gutterResetCount.get(ticketId) ?? 0) + 1;
+    this.gutterResetCount.set(ticketId, count);
+    if (count > cap) {
+      this.gutterResetExhausted.add(ticketId);
+      await this.emitHarnessSignal(ticketId, "agent_stalled_exhausted", {
+        resetCount: count,
+        cap
+      });
+      await this.safeAction(
+        ticketId,
+        "stalled:exhaustedComment",
+        () => this.deps.createComment(
+          ticketId,
+          `Stalled after ${String(count)} gutter reset attempt(s) (cap: ${String(cap)}) \u2014 human review needed. See 'agent_stalled_exhausted' signal for details.`
+        )
+      );
+      return false;
+    }
+    return true;
+  }
   /**
    * Phase 2: Invoke the advisor for failure recovery.
    * Returns true if the ticket should be retried, false if handled.
@@ -1386,6 +1533,10 @@ var PipelineOrchestrator = class {
     }
     switch (response.action) {
       case "RETRY_WITH_FEEDBACK": {
+        if (!await this.checkGutterResetCap(ticketId, colConfig)) {
+          this.completing.delete(ticketId);
+          return false;
+        }
         if (response.feedback) {
           await this.safeAction(
             ticketId,
@@ -1400,6 +1551,10 @@ ${response.feedback}`)
         return true;
       }
       case "RETRY_DIFFERENT_MODEL": {
+        if (!await this.checkGutterResetCap(ticketId, colConfig)) {
+          this.completing.delete(ticketId);
+          return false;
+        }
         const currentModel = result.model ?? colConfig.modelPreference ?? "default";
         const escalation = colConfig.modelRouting?.escalation ?? [];
         let nextModel;
@@ -1558,10 +1713,17 @@ ${response.feedback}`)
             );
           }
         }
+        await this.emitHarnessSignal(ticketId, "advisor_action", {
+          action: "ESCALATE",
+          reason: response.reason
+        });
         await this.safeAction(
           ticketId,
-          "advisor:createComment",
-          () => this.deps.createComment(ticketId, `ADVISOR: Escalated for human review \u2014 ${response.reason}`)
+          "advisor:escalateComment",
+          () => this.deps.createComment(
+            ticketId,
+            `Needs human review \u2014 see 'advisor_action' signal for details.`
+          )
         );
         return false;
       }
@@ -1721,6 +1883,19 @@ ${findingsText}`)
     const nextBoardCol = bs.columns.filter((c) => c.position > currentBoardCol.position && this.pipelineColumns.has(c.id)).sort((a, b) => a.position - b.position)[0];
     return nextBoardCol ? this.pipelineColumns.get(nextBoardCol.id) ?? null : null;
   }
+  /**
+   * Find the ID of the next board column by position, regardless of pipeline status.
+   * Used by merge-recovery to target the downstream column (e.g. Done) which may not
+   * be a pipeline column.
+   */
+  findNextColumnId(currentColumnId) {
+    const bs = this.cachedBoardScope;
+    if (!bs) return null;
+    const currentBoardCol = bs.columns.find((c) => c.id === currentColumnId);
+    if (!currentBoardCol) return null;
+    const nextBoardCol = bs.columns.filter((c) => c.position > currentBoardCol.position).sort((a, b) => a.position - b.position)[0];
+    return nextBoardCol?.id ?? null;
+  }
   /**
    * Called when a loop finishes. Cleans up tracking and drains the queue.
    */
@@ -1817,6 +1992,8 @@ ${findingsText}`)
       const colConfig = this.pipelineColumns.get(columnId);
       const terminalCleanup = async () => {
         this.advisorBudget.delete(ticketId);
+        this.gutterResetCount.delete(ticketId);
+        this.gutterResetExhausted.delete(ticketId);
         if (colConfig?.checkpointEnabled && this.deps.setFieldValue && result.reason !== "stopped") {
           await this.safeAction(
             ticketId,
@@ -1950,47 +2127,41 @@ ${findingsText}`)
           }
           break;
         case "max_iterations":
-          comment = `Pipeline agent reached iteration limit (${result.iterations}) without advancing. Manual review needed.`;
+          await this.emitHarnessSignal(ticketId, "agent_max_iterations", {
+            iterations: result.iterations
+          });
+          comment = `Needs human review \u2014 see 'agent_max_iterations' signal for details.`;
           break;
         case "stalled":
-          comment = `Pipeline agent stalled \u2014 no progress for ${result.gutterCount} consecutive iterations (of ${result.iterations} total). Manual review needed.`;
+          if (!this.gutterResetExhausted.has(ticketId)) {
+            await this.emitHarnessSignal(ticketId, "agent_stalled", {
+              iterations: result.iterations,
+              gutterCount: result.gutterCount
+            });
+          }
           break;
         case "error":
-          comment = `Pipeline agent encountered an error after ${result.iterations} iteration(s): ${result.lastError ?? "unknown error"}`;
+          await this.emitHarnessSignal(ticketId, "agent_error", {
+            iterations: result.iterations,
+            lastError: result.lastError ?? "unknown error"
+          });
+          comment = `Needs human review \u2014 see 'agent_error' signal for details.`;
           break;
         case "stopped":
           comment = `Pipeline agent was stopped externally after ${result.iterations} iteration(s).`;
           break;
         case "deleted":
-          comment = `Pipeline agent stopped \u2014 ticket was deleted or archived during iteration ${result.iterations}.`;
           break;
         case "budget":
           comment = `Pipeline budget exhausted after ${result.iterations} iteration(s). Increase token budget in pipeline.gates.yaml settings.budget to continue.`;
           break;
       }
-      if (result.reason !== "deleted") {
+      if (comment !== void 0) {
         await this.deps.createComment(ticketId, comment).catch((err) => {
           const msg = err instanceof Error ? err.message : String(err);
           console.error(`  [warn] Failed to write completion comment for ${ticketId}: ${msg}`);
         });
       }
-      if (result.reason === "stalled") {
-        await this.deps.createSignal(
-          ticketId,
-          `Previous pipeline run stalled after ${result.iterations} iterations with no progress. Review comments for details before retrying.`
-        ).catch((err) => {
-          const msg = err instanceof Error ? err.message : String(err);
-          console.error(`  [warn] Failed to write signal for ${ticketId}: ${msg}`);
-        });
-      } else if (result.reason === "error") {
-        await this.deps.createSignal(
-          ticketId,
-          `Previous pipeline run failed after ${result.iterations} iteration(s): ${result.lastError ?? "unknown error"}. Review comments for details before retrying.`
-        ).catch((err) => {
-          const msg = err instanceof Error ? err.message : String(err);
-          console.error(`  [warn] Failed to write signal for ${ticketId}: ${msg}`);
-        });
-      }
       await terminalCleanup();
     } finally {
       this.completing.delete(ticketId);
@@ -2112,11 +2283,12 @@ ${findingsText}`)
       this.spawning.add(nextTicketId);
       this.reserveSlot(columnId);
       try {
-        const blocked = await this.deps.hasUnresolvedBlockers(nextTicketId);
-        if (blocked) {
+        const blockerResult = await this.deps.hasUnresolvedBlockers(nextTicketId);
+        if (blockerResult.blocked) {
           this.deferredTickets.set(nextTicketId, columnId);
           this.spawning.delete(nextTicketId);
           this.releaseSlot(columnId);
+          void this.emitDispatchDeferred(nextTicketId, "unresolved_blockers", { columnId });
           continue;
         }
       } catch (err) {
@@ -2125,10 +2297,12 @@ ${findingsText}`)
         this.deferredTickets.set(nextTicketId, columnId);
         this.spawning.delete(nextTicketId);
         this.releaseSlot(columnId);
+        void this.emitDispatchDeferred(nextTicketId, "unresolved_blockers", { columnId });
         continue;
       }
       try {
         await this.deps.claimTicket(nextTicketId);
+        await this.clearDispatchDeferred(nextTicketId);
         this.startTrackedLoop(nextTicketId, columnId, colConfig);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -2157,6 +2331,63 @@ ${findingsText}`)
     const current = this.columnReservations.get(columnId) ?? 0;
     if (current > 0) this.columnReservations.set(columnId, current - 1);
   }
+  /**
+   * Emit a dispatch_deferred harness signal for a ticket.
+   * State-change dedup: same reason → no-op; different reason → delete old + create new.
+   * Best-effort: signal creation failures are logged but never thrown.
+   */
+  /**
+   * Emit a structured harness signal on a ticket. Uses createSignal (plain, non-tracked).
+   * Best-effort: failures are logged but never thrown.
+   */
+  async emitHarnessSignal(ticketId, kind, payload) {
+    const content = createHarnessSignalContent(kind, payload);
+    try {
+      await this.deps.createSignal(ticketId, content);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`[harness-signal] failed to create ${kind} signal for ${ticketId}: ${msg}`);
+    }
+  }
+  async emitDispatchDeferred(ticketId, reason, extras) {
+    if (!this.deps.createHarnessSignal) return;
+    const existing = this.deferredState.get(ticketId);
+    if (existing?.reason === reason) return;
+    if (existing && this.deps.deleteSignal) {
+      try {
+        await this.deps.deleteSignal(existing.signalId);
+      } catch {
+      }
+    }
+    const firstDeferredAt = existing?.firstDeferredAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    const content = createHarnessSignalContent("dispatch_deferred", {
+      reason,
+      firstDeferredAt,
+      ...extras
+    });
+    try {
+      const signal = await this.deps.createHarnessSignal(ticketId, content);
+      this.deferredState.set(ticketId, { reason, signalId: signal.id, firstDeferredAt });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`  [dispatch-deferred] failed to create signal for ticket ${ticketId}: ${msg}`);
+    }
+  }
+  /**
+   * Clear the dispatch_deferred harness signal for a ticket (called on dispatch success or ticket:moved).
+   * Best-effort: deletion failures are swallowed.
+   */
+  async clearDispatchDeferred(ticketId) {
+    const existing = this.deferredState.get(ticketId);
+    if (!existing) return;
+    this.deferredState.delete(ticketId);
+    if (this.deps.deleteSignal) {
+      try {
+        await this.deps.deleteSignal(existing.signalId);
+      } catch {
+      }
+    }
+  }
 };
 
 // src/lib/run-memory.ts
@@ -2408,7 +2639,7 @@ var PipelineWsClient = class _PipelineWsClient {
     this.cleanupTimers();
     const { ticket } = await this.client.post("/ws-ticket");
     const wsUrl = this.client.baseUrl.replace(/^http/, "ws") + `/ws?ticket=${ticket}&clientType=cli`;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let resolved = false;
       this.ws = new WebSocket(wsUrl);
       let subscribed = false;
@@ -2437,7 +2668,7 @@ var PipelineWsClient = class _PipelineWsClient {
             this.options.onConnect();
             if (!resolved) {
               resolved = true;
-              resolve();
+              resolve2();
             }
           }
           this.options.onEvent(event);
@@ -2549,7 +2780,7 @@ var PipelineWsClient = class _PipelineWsClient {
 
 // src/lib/logger.ts
 import { mkdirSync, writeFileSync, appendFileSync, readdirSync, rmSync, statSync, renameSync } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 var MAX_LOG_BYTES = 5 * 1024 * 1024;
 var MAX_ROTATED_FILES = 3;
 var ROTATION_CHECK_INTERVAL = 100;
@@ -2557,11 +2788,11 @@ var PipelineLogger = class {
   boardDir;
   writeCount = 0;
   constructor(baseDir, boardId) {
-    this.boardDir = join(baseDir, boardId);
+    this.boardDir = join2(baseDir, boardId);
     mkdirSync(this.boardDir, { recursive: true });
   }
   orchestrator(message) {
-    const logPath = join(this.boardDir, "orchestrator.log");
+    const logPath = join2(this.boardDir, "orchestrator.log");
     const entry = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
 `;
     appendFileSync(logPath, entry);
@@ -2593,10 +2824,10 @@ var PipelineLogger = class {
     }
   }
   iteration(ticketNumber, iterationNum, data) {
-    const ticketDir = join(this.boardDir, ticketNumber);
+    const ticketDir = join2(this.boardDir, ticketNumber);
     mkdirSync(ticketDir, { recursive: true });
     const padded = String(iterationNum).padStart(3, "0");
-    const logPath = join(ticketDir, `iteration-${padded}.log`);
+    const logPath = join2(ticketDir, `iteration-${padded}.log`);
     const entry = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       iteration: iterationNum,
@@ -2615,7 +2846,7 @@ var PipelineLogger = class {
     try {
       const entries = readdirSync(this.boardDir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join(this.boardDir, entry.name);
+        const fullPath = join2(this.boardDir, entry.name);
         if (entry.isDirectory() && entry.name !== ".") {
           try {
             const stat = statSync(fullPath);
@@ -3401,8 +3632,9 @@ var CodexProvider = class {
             execFileSync2("git", ["worktree", "add", request.workingDirectory, branch], {
               stdio: "pipe"
             });
-          } catch {
-            degraded.push("worktreeCreation");
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`worktree_creation_failed: ${msg}`);
           }
         }
       } else {
@@ -3421,17 +3653,18 @@ var CodexProvider = class {
               execFileSync2("git", ["worktree", "add", request.workingDirectory, branch], {
                 stdio: "pipe"
               });
-            } catch {
-              degraded.push("worktreeCreation");
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              throw new Error(`worktree_creation_failed: ${msg}`);
             }
           }
         }
       }
-      if (!degraded.includes("worktreeCreation") && existsSync(request.workingDirectory)) {
+      if (existsSync(request.workingDirectory)) {
         ensureWorktreeRemote(request.workingDirectory);
       }
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const [cmd, prefixArgs] = resolveCommand("codex");
       const resolvedArgs = [...prefixArgs, ...args];
       const child = spawn2(cmd, resolvedArgs, {
@@ -3482,7 +3715,7 @@ var CodexProvider = class {
           durationMs: Date.now() - startTime
         };
         if (degraded.length > 0) result.degradedCapabilities = degraded;
-        resolve(result);
+        resolve2(result);
       };
       child.on("close", (code) => finish(code));
       child.on("error", (err) => finish(1, err.message));
@@ -3522,22 +3755,22 @@ var CodexProvider = class {
         }
       }
     }
+    const WRITING_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit", "Bash", "NotebookEdit"]);
     if (request.toolRestrictions) {
       const tr = request.toolRestrictions;
-      const writingTools = ["Write", "Edit", "Bash", "NotebookEdit", "shell", "file_write", "file_edit"];
       if (tr.tools === "") {
         args.push("--sandbox", "read-only");
         degraded.push("builtinToolStripping");
-      } else if (tr.disallowedTools?.some((t) => writingTools.includes(t))) {
-        args.push("--sandbox", "read-only");
-        degraded.push("toolDenylist");
+      } else {
+        const hasWritingDeny = (tr.disallowedTools ?? []).some((t) => WRITING_TOOLS.has(t));
+        if (hasWritingDeny) {
+          args.push("--sandbox", "read-only");
+          degraded.push("toolDenylistAdvisory");
+        }
       }
       if (tr.allowedTools?.length) {
         degraded.push("toolAllowlist");
       }
-      if (tr.disallowedTools?.length && !degraded.includes("toolDenylist")) {
-        degraded.push("toolDenylist");
-      }
     }
     if (request.maxTurns) {
       degraded.push("maxTurns");
@@ -3555,8 +3788,8 @@ var CodexProvider = class {
 // src/providers/gemini-provider.ts
 import { spawn as spawn3, execFileSync as execFileSync3 } from "child_process";
 import { existsSync as existsSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, rmSync as rmSync3 } from "fs";
-import { join as join2, dirname } from "path";
-import { homedir } from "os";
+import { join as join3, dirname } from "path";
+import { homedir as homedir2 } from "os";
 import { fileURLToPath } from "url";
 import { readFileSync as readFileSync2 } from "fs";
 
@@ -3719,13 +3952,13 @@ function resolveHookScriptPath() {
   try {
     const thisDir = dirname(fileURLToPath(import.meta.url));
     const candidates = [
-      join2(thisDir, "lib", "gemini-hooks.mjs"),
+      join3(thisDir, "lib", "gemini-hooks.mjs"),
       // dist/lib/ (flat bundle)
-      join2(thisDir, "..", "lib", "gemini-hooks.mjs"),
+      join3(thisDir, "..", "lib", "gemini-hooks.mjs"),
       // dist/../lib/ (nested)
-      join2(thisDir, "..", "src", "lib", "gemini-hooks.mjs"),
+      join3(thisDir, "..", "src", "lib", "gemini-hooks.mjs"),
       // source from dist/
-      join2(thisDir, "..", "..", "src", "lib", "gemini-hooks.mjs")
+      join3(thisDir, "..", "..", "src", "lib", "gemini-hooks.mjs")
       // source from dist/providers/
     ];
     for (const p of candidates) {
@@ -3808,7 +4041,7 @@ var GeminiProvider = class _GeminiProvider {
     if (request.workingDirectory && settingsDir) {
       this.copySettingsToDir(settingsDir, request.workingDirectory);
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const [cmd, prefixArgs] = resolveCommand("gemini");
       const resolvedArgs = [...prefixArgs, ...args];
       const child = spawn3(cmd, resolvedArgs, {
@@ -3881,7 +4114,7 @@ var GeminiProvider = class _GeminiProvider {
           durationMs: Date.now() - startTime
         };
         if (degraded.length > 0) result.degradedCapabilities = degraded;
-        resolve(result);
+        resolve2(result);
       };
       child.on("close", (code) => finish(code));
       child.on("error", (err) => finish(1, err.message));
@@ -3919,9 +4152,9 @@ var GeminiProvider = class _GeminiProvider {
   }
   writeGeminiSettings(request, degraded) {
     try {
-      const baseDir = join2(homedir(), ".kantban", "pipelines", "gemini-tmp");
-      const dir = join2(baseDir, `session-${Date.now()}`);
-      const geminiDir = join2(dir, ".gemini");
+      const baseDir = join3(homedir2(), ".kantban", "pipelines", "gemini-tmp");
+      const dir = join3(baseDir, `session-${Date.now()}`);
+      const geminiDir = join3(dir, ".gemini");
       mkdirSync2(geminiDir, { recursive: true, mode: 448 });
       const settings = {};
       if (request.mcpConfig && Object.keys(request.mcpConfig.servers).length > 0) {
@@ -3945,20 +4178,20 @@ var GeminiProvider = class _GeminiProvider {
           hookConfig.disallowedTools = tr.disallowedTools ? translateToolNames(tr.disallowedTools) : null;
           if (tr.tools !== void 0) hookConfig.builtinToolsMode = tr.tools;
           const ext = IS_WINDOWS ? ".cmd" : ".sh";
-          const wrapperPath = join2(dir, `.kantban-hook-before-tool${ext}`);
-          writeFileSync3(wrapperPath, this.generateHookWrapper(hookPath, "BeforeToolSelection", join2(dir, ".kantban-hook-config.json")), { mode: 493 });
+          const wrapperPath = join3(dir, `.kantban-hook-before-tool${ext}`);
+          writeFileSync3(wrapperPath, this.generateHookWrapper(hookPath, "BeforeToolSelection", join3(dir, ".kantban-hook-config.json")), { mode: 493 });
           hooks.BeforeToolSelection = [{ matcher: "*", hooks: [{ type: "command", command: wrapperPath, timeout: 3e4 }] }];
         }
         if (request.maxTurns && request.mcpConfig) {
           hookConfig.maxTurns = request.maxTurns;
-          hookConfig.turnFile = join2(dir, ".kantban-turn-counter");
+          hookConfig.turnFile = join3(dir, ".kantban-turn-counter");
           const ext = IS_WINDOWS ? ".cmd" : ".sh";
-          const wrapperPath = join2(dir, `.kantban-hook-after-agent${ext}`);
-          writeFileSync3(wrapperPath, this.generateHookWrapper(hookPath, "AfterAgent", join2(dir, ".kantban-hook-config.json")), { mode: 493 });
+          const wrapperPath = join3(dir, `.kantban-hook-after-agent${ext}`);
+          writeFileSync3(wrapperPath, this.generateHookWrapper(hookPath, "AfterAgent", join3(dir, ".kantban-hook-config.json")), { mode: 493 });
           hooks.AfterAgent = [{ matcher: "*", hooks: [{ type: "command", command: wrapperPath, timeout: 3e4 }] }];
         }
         if (Object.keys(hookConfig).length > 0) {
-          writeFileSync3(join2(dir, ".kantban-hook-config.json"), JSON.stringify(hookConfig), { mode: 384 });
+          writeFileSync3(join3(dir, ".kantban-hook-config.json"), JSON.stringify(hookConfig), { mode: 384 });
         }
         if (Object.keys(hooks).length > 0) {
           settings.hooks = hooks;
@@ -3971,7 +4204,7 @@ var GeminiProvider = class _GeminiProvider {
         process.stderr.write(`[gemini] Hook script not found \u2014 tool scoping and turn limits unavailable
 `);
       }
-      writeFileSync3(join2(geminiDir, "settings.json"), JSON.stringify(settings, null, 2), { mode: 384 });
+      writeFileSync3(join3(geminiDir, "settings.json"), JSON.stringify(settings, null, 2), { mode: 384 });
       return dir;
     } catch (err) {
       process.stderr.write(`[gemini] Failed to write settings.json: ${err}
@@ -4037,17 +4270,29 @@ node "${hookScript}" "${event}" "${configFile}" < "$STDIN_FILE"
   }
   copySettingsToDir(settingsDir, targetDir) {
     try {
-      const sourceFile = join2(settingsDir, ".gemini", "settings.json");
-      const targetGeminiDir = join2(targetDir, ".gemini");
+      const sourceFile = join3(settingsDir, ".gemini", "settings.json");
+      const targetGeminiDir = join3(targetDir, ".gemini");
       mkdirSync2(targetGeminiDir, { recursive: true, mode: 448 });
       const content = readFileSync2(sourceFile, "utf-8");
-      writeFileSync3(join2(targetGeminiDir, "settings.json"), content, { mode: 384 });
+      writeFileSync3(join3(targetGeminiDir, "settings.json"), content, { mode: 384 });
     } catch {
     }
   }
 };
 
 // src/commands/pipeline.ts
+var execFileAsync = promisify(execFile);
+var _cachedPrimaryRepoRoot = null;
+async function getPrimaryRepoRoot() {
+  if (_cachedPrimaryRepoRoot) return _cachedPrimaryRepoRoot;
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"]);
+    _cachedPrimaryRepoRoot = resolve(stdout.trim());
+  } catch {
+    _cachedPrimaryRepoRoot = resolve(process.cwd());
+  }
+  return _cachedPrimaryRepoRoot;
+}
 function createProviderRegistry() {
   const registry = new ProviderRegistry();
   registry.register(new ClaudeProvider());
@@ -4055,9 +4300,25 @@ function createProviderRegistry() {
   registry.register(new GeminiProvider());
   return registry;
 }
-function readMcpConfigAsProviderConfig(filePath) {
-  const raw = JSON.parse(readFileSync3(filePath, "utf-8"));
-  return { servers: raw.mcpServers };
+function readMcpConfigAsProviderConfig(filePath, regenerate) {
+  function parse(path) {
+    const raw = JSON.parse(readFileSync3(path, "utf-8"));
+    return { servers: raw.mcpServers };
+  }
+  try {
+    return parse(filePath);
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      process.stderr.write(
+        `[mcp-config] regenerating missing file at ${filePath} (pid=${process.pid})
+`
+      );
+      const newPath = regenerate();
+      return parse(newPath);
+    }
+    throw err;
+  }
 }
 function parseArgs(args) {
   const positional = [];
@@ -4153,10 +4414,10 @@ Flags:
   return { boardId, once, dryRun, columnFilter, maxIterations, maxBudget, model, provider, concurrency, logRetention, yes };
 }
 function pidDir(boardId) {
-  return join3(homedir2(), ".kantban", "pipelines", boardId);
+  return join4(homedir3(), ".kantban", "pipelines", boardId);
 }
 function pidFilePath(boardId) {
-  return join3(pidDir(boardId), "orchestrator.pid");
+  return join4(pidDir(boardId), "orchestrator.pid");
 }
 function writePidFile(boardId) {
   const dir = pidDir(boardId);
@@ -4170,7 +4431,7 @@ function removePidFile(boardId) {
   }
 }
 function childManifestPath(boardId) {
-  return join3(pidDir(boardId), "children.pid");
+  return join4(pidDir(boardId), "children.pid");
 }
 function readChildManifest(boardId) {
   try {
@@ -4215,7 +4476,7 @@ function cleanupOrphanedProcesses(boardId) {
     console.log(`Killed ${String(manifestPids.length)} orphaned child process(es) from manifest`);
     removeChildManifest(boardId);
   }
-  const staleReaperPath = join3(pidDir(boardId), "reaper.pid");
+  const staleReaperPath = join4(pidDir(boardId), "reaper.pid");
   try {
     if (existsSync3(staleReaperPath)) {
       const reaperPid = parseInt(readFileSync3(staleReaperPath, "utf-8").trim(), 10);
@@ -4248,14 +4509,14 @@ Press Ctrl+C to cancel, or re-run with --yes to skip this warning.
 `);
 }
 function waitForConfirmation() {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     process.stdout.write("Continue? [y/N] ");
     process.stdin.setEncoding("utf8");
     process.stdin.once("data", (data) => {
       const answer = data.trim().toLowerCase();
-      resolve(answer === "y" || answer === "yes");
+      resolve2(answer === "y" || answer === "yes");
     });
-    process.stdin.once("end", () => resolve(false));
+    process.stdin.once("end", () => resolve2(false));
   });
 }
 async function runPipeline(client, args) {
@@ -4274,7 +4535,7 @@ async function runPipeline(client, args) {
       return;
     }
   }
-  const gateFilePath = join3(process.cwd(), "pipeline.gates.yaml");
+  const gateFilePath = join4(process.cwd(), "pipeline.gates.yaml");
   let gateConfig;
   if (!existsSync3(gateFilePath)) {
     console.error(`Error: pipeline.gates.yaml not found in ${process.cwd()}`);
@@ -4304,13 +4565,14 @@ async function runPipeline(client, args) {
       process.exit(1);
     }
   }
+  reapOrphanedMcpConfigDirs(pidDir(opts.boardId));
   const mcpConfigPath = generateMcpConfig(client.baseUrl, client.token, opts.boardId);
   const boardProviderConfig = {
     ...opts.provider ? { default_provider: opts.provider } : {},
     ...opts.provider ? { intelligence_provider: opts.provider } : {}
   };
   const intelligenceProvider = registry.resolveForIntelligence(boardProviderConfig);
-  const logBaseDir = join3(homedir2(), ".kantban", "pipelines");
+  const logBaseDir = join4(homedir3(), ".kantban", "pipelines");
   const logger = new PipelineLogger(logBaseDir, opts.boardId);
   logger.pruneOldLogs(opts.logRetention);
   let runMemory = null;
@@ -4332,6 +4594,32 @@ async function runPipeline(client, args) {
         ...opts.maxBudget !== null && { maxBudgetUsd: opts.maxBudget },
         ...opts.model !== null && { model: opts.model }
       };
+      if (effectiveConfig.worktreePath) {
+        const primaryRepoRoot = await getPrimaryRepoRoot();
+        const resolvedCwd = resolve(effectiveConfig.worktreePath);
+        const inside = resolvedCwd === primaryRepoRoot || resolvedCwd.startsWith(primaryRepoRoot + sep) || primaryRepoRoot.startsWith(resolvedCwd + sep);
+        if (inside) {
+          const errMsg = `[fatal] dispatch refused: resolved cwd "${resolvedCwd}" is inside, equal to, or a parent of the primary repo "${primaryRepoRoot}". Configure agent_config.worktree.path_pattern to a path outside the primary repo.`;
+          logger.orchestrator(errMsg);
+          await deps.createComment(ticketId, `[dispatch] failed: cwd would be inside the primary repo. Update agent_config.worktree.path_pattern to a path outside this repo.`);
+          return { reason: "error", iterations: 0, gutterCount: 0, lastError: errMsg };
+        }
+      }
+      if (effectiveConfig.worktreePath) {
+        const parent = dirname2(effectiveConfig.worktreePath);
+        try {
+          await fsPromises.mkdir(parent, { recursive: true });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          const errMsg = `[dispatch] failed ticket=${ticketId} reason=worktree_unrenderable path="${effectiveConfig.worktreePath}" error="${msg}"`;
+          logger.orchestrator(errMsg);
+          await deps.createComment(
+            ticketId,
+            `[dispatch] failed: cannot create worktree parent directory at "${parent}": ${msg}. Fix the path_pattern or its parent directory; the orchestrator will retry on the next scan.`
+          );
+          return { reason: "error", iterations: 0, gutterCount: 0, lastError: errMsg };
+        }
+      }
       const mem = runMemory;
       const colScopeForName = await client.get(
         `/projects/${projectId}/pipeline-context`,
@@ -4347,8 +4635,8 @@ async function runPipeline(client, args) {
       if (effectiveConfig.model) {
         effectiveConfig.model = registry.resolveModel(columnProvider, effectiveConfig.model);
       }
-      const columnGates = resolveGatesForColumn(gateConfig, resolvedColumnName);
-      const gateCwd = effectiveConfig.worktreePath ?? (effectiveConfig.worktreeName ? join3(process.cwd(), effectiveConfig.worktreeName) : process.cwd());
+      const { gates: columnGates } = resolveGatesForColumn(gateConfig, resolvedColumnName);
+      const gateCwd = effectiveConfig.worktreePath ?? (effectiveConfig.worktreeName ? join4(process.cwd(), effectiveConfig.worktreeName) : process.cwd());
       const effectiveMcpConfigPath = columnGates.length > 0 ? generateGateProxyMcpConfig(
         client.baseUrl,
         client.token,
@@ -4360,7 +4648,20 @@ async function runPipeline(client, args) {
         gateCwd,
         ticketId
       ) : mcpConfigPath;
-      const columnMcpConfig = readMcpConfigAsProviderConfig(effectiveMcpConfigPath);
+      const columnMcpConfig = readMcpConfigAsProviderConfig(
+        effectiveMcpConfigPath,
+        () => columnGates.length > 0 ? generateGateProxyMcpConfig(
+          client.baseUrl,
+          client.token,
+          opts.boardId,
+          gateFilePath,
+          columnId,
+          resolvedColumnName,
+          projectId,
+          gateCwd,
+          ticketId
+        ) : generateMcpConfig(client.baseUrl, client.token, opts.boardId)
+      );
       const loopDeps = {
         fetchTicketContext: (tid) => client.get(`/projects/${projectId}/pipeline-context`, { ticketId: tid }),
         fetchColumnContext: (cid) => client.get(`/projects/${projectId}/pipeline-context`, { columnId: cid }),
@@ -4468,7 +4769,7 @@ async function runPipeline(client, args) {
         };
       }
       effectiveConfig.onPostIterationGates = async (tid, iteration) => {
-        const gates = resolveGatesForColumn(gateConfig, resolvedColumnName);
+        const { gates } = resolveGatesForColumn(gateConfig, resolvedColumnName);
         if (gates.length === 0) {
           return gateSnapshotStore.record(tid, iteration, []);
         }
@@ -4504,6 +4805,12 @@ async function runPipeline(client, args) {
       contentPrefix,
       content: body
     }),
+    createHarnessSignal: (ticketId, content) => client.post(`/projects/${projectId}/signals`, {
+      scopeType: "ticket",
+      scopeId: ticketId,
+      content
+    }),
+    deleteSignal: (signalId) => client.delete(`/projects/${projectId}/signals/${signalId}`),
     claimTicket: (ticketId) => client.claimTicket(projectId, ticketId),
     fetchBlockedTickets: (ticketId) => client.get(
       `/projects/${projectId}/tickets/${ticketId}/blocked-tickets`
@@ -4512,7 +4819,27 @@ async function runPipeline(client, args) {
       const blockers = await client.get(
         `/projects/${projectId}/tickets/${ticketId}/unresolved-blockers`
       );
-      return blockers.length > 0;
+      if (!blockers || blockers.length === 0) {
+        return { blocked: false };
+      }
+      let linkIds = [];
+      try {
+        const links = await client.get(
+          `/projects/${projectId}/ticket-links?ticketId=${ticketId}&linkType=blocks`
+        );
+        linkIds = (links ?? []).filter((l) => l.target_id === ticketId && l.link_type === "blocks").map((l) => l.id);
+      } catch {
+        linkIds = [];
+      }
+      return {
+        blocked: true,
+        blockers: blockers.map((b) => ({
+          id: b.id,
+          ticket_number: b.ticket_number,
+          column: b.column
+        })),
+        linkIds
+      };
     },
     dispatchLightCall: async (ticketId, columnId) => {
       const [ticketCtx, colScope, boardScope] = await Promise.all([
@@ -4626,6 +4953,7 @@ async function runPipeline(client, args) {
     appendRunMemory: (section, content) => runMemory ? runMemory.append(section, content) : Promise.resolve(),
     cleanupWorktree: (name) => cleanupWorktree(name),
     mergeWorktree: (name, integrationBranch) => mergeWorktreeBranch(name, integrationBranch),
+    detectBranchMerged: async (opts2) => detectBranchMerged(opts2),
     // Pipeline event emission — wsClient captured by reference (set later before any loops run)
     emitPipelineEvent: (event) => {
       wsClient?.send(event);
@@ -4664,7 +4992,7 @@ async function runPipeline(client, args) {
     console.error(`Error: Failed to initialize pipeline: ${message}`);
     console.error("Check that the board exists, has pipeline columns configured, and the API is reachable.");
     cleanupMcpConfig(mcpConfigPath);
-    cleanupGateProxyConfigs(pidDir(opts.boardId));
+    cleanupGateProxyConfigs(dirname2(mcpConfigPath));
     process.exit(1);
   }
   const columnIds = orchestrator.pipelineColumnIds;
@@ -4720,7 +5048,7 @@ async function runPipeline(client, args) {
   if (columnIds.length === 0) {
     console.log('No pipeline columns found (columns need has_prompt=true and type !== "done").');
     cleanupMcpConfig(mcpConfigPath);
-    cleanupGateProxyConfigs(pidDir(opts.boardId));
+    cleanupGateProxyConfigs(dirname2(mcpConfigPath));
     return;
   }
   console.log(`Discovered ${String(columnIds.length)} pipeline column(s).`);
@@ -4734,6 +5062,15 @@ async function runPipeline(client, args) {
       `              No board column name matched (after canonicalization). These overrides will never fire.`
     );
   }
+  for (const col of orchestrator.allBoardColumns) {
+    if (col.type !== "done") continue;
+    const { source } = resolveGatesForColumn(gateConfig, col.name);
+    if (source === "override") {
+      console.warn(
+        `[gate-config] column "${col.name}" is done-type AND has an explicit override \u2014 gates will run on moves INTO this column (bypass disabled by your pipeline.gates.yaml).`
+      );
+    }
+  }
   if (opts.dryRun) {
     console.log("\n--- Dry Run Configuration ---");
     console.log(`Board ID:       ${opts.boardId}`);
@@ -4749,7 +5086,7 @@ async function runPipeline(client, args) {
     console.log(`MCP config:     ${mcpConfigPath}`);
     console.log("\n[Dry run -- no agents started]");
     cleanupMcpConfig(mcpConfigPath);
-    cleanupGateProxyConfigs(pidDir(opts.boardId));
+    cleanupGateProxyConfigs(dirname2(mcpConfigPath));
     return;
   }
   let shutdownInProgress = false;
@@ -4777,7 +5114,7 @@ Received ${signal}. Shutting down gracefully...`);
       console.log(costTracker.generateReport(gateConfig.settings?.pricing));
     }
     cleanupMcpConfig(mcpConfigPath);
-    cleanupGateProxyConfigs(pidDir(opts.boardId));
+    cleanupGateProxyConfigs(dirname2(mcpConfigPath));
     killReaper(reaperPidPath);
     removePidFile(opts.boardId);
     removeChildManifest(opts.boardId);
@@ -4808,14 +5145,14 @@ Received ${signal}. Shutting down gracefully...`);
   cleanupOrphanedProcesses(opts.boardId);
   writePidFile(opts.boardId);
   logger.orchestrator(`PID file written: ${String(process.pid)}`);
-  const reaperPidPath = join3(pidDir(opts.boardId), "reaper.pid");
+  const reaperPidPath = join4(pidDir(opts.boardId), "reaper.pid");
   const reaperProcess = spawnReaper({
     orchestratorPid: process.pid,
     manifestPath: childManifestPath(opts.boardId),
     pidFilePath: pidFilePath(opts.boardId),
     reaperPidPath,
     mcpConfigPath,
-    pipelineDir: pidDir(opts.boardId)
+    pipelineDir: dirname2(mcpConfigPath)
   });
   logger.orchestrator(`Watchdog reaper spawned (PID ${String(reaperProcess.pid ?? "unknown")})`);
   let eventQueue = null;
@@ -4900,7 +5237,7 @@ Received ${signal}. Shutting down gracefully...`);
     wsClient.stop();
     eventQueue.stop();
     cleanupMcpConfig(mcpConfigPath);
-    cleanupGateProxyConfigs(pidDir(opts.boardId));
+    cleanupGateProxyConfigs(dirname2(mcpConfigPath));
     killReaper(reaperPidPath);
     removePidFile(opts.boardId);
     removeChildManifest(opts.boardId);
@@ -4948,7 +5285,7 @@ async function waitForAllLoops(orchestrator, timeoutMs = 4 * 60 * 60 * 1e3) {
       );
       return;
     }
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
     if (activeRalphLoops.size === 0 && orchestrator.activeLoopCount === 0 && !orchestrator.hasActiveQueuedWork && !orchestrator.hasCompletingWork) {
       consecutiveIdle++;
     } else {
@@ -4998,4 +5335,4 @@ export {
   runPipeline,
   stopPipeline
 };
-//# sourceMappingURL=pipeline-EUOOLKHN.js.map
+//# sourceMappingURL=pipeline-6J64Z7VH.js.map