kantban-cli 0.1.49 → 0.1.52

package/dist/{pipeline-GZOSDNPF.js → pipeline-NRG2Q2TE.js}

@@ -1,19 +1,26 @@
 import {
   runGates
-} from "./chunk-DENXSVKE.js";
+} from "./chunk-GQQUH3TA.js";
 import {
   ClaudeProvider,
   RalphLoop,
   classifyTrajectory,
   cleanupGateProxyConfigs,
   cleanupMcpConfig,
+  cleanupWorktree,
   composeStuckDetectionPrompt,
+  defaultWorktreeRoot,
+  detectBranchMerged,
+  ensureWorktreeRemote,
   generateGateProxyMcpConfig,
   generateMcpConfig,
+  generateWorktreeName,
+  mergeWorktreeBranch,
   parseJsonFromLlmOutput,
   parseStuckDetectionResponse,
-  reapOrphanedMcpConfigDirs
-} from "./chunk-QHJZIGEE.js";
+  reapOrphanedMcpConfigDirs,
+  renderWorktreePath
+} from "./chunk-3A4B7CUH.js";
 import {
   LoopCheckpointSchema,
   VerdictSchema,
@@ -31,9 +38,11 @@ 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 { 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 homedir2 } from "os";
-import { join as join3, dirname as dirname2 } from "path";
+import { join as join3, dirname as dirname2, resolve, sep } from "path";
+import { promisify } from "util";
 
 // src/lib/harness-signal.ts
 var HARNESS_SIGNAL_PREFIX = "@harness:";
@@ -55,142 +64,6 @@ function resolveToolRestrictions(builtinTools, allowedTools, disallowedTools) {
   };
 }
 
-// src/lib/worktree.ts
-import { execFile as defaultExecFile, execFileSync } from "child_process";
-function generateWorktreeName(ticketNumber, columnName) {
-  const slug = columnSlug(columnName);
-  return `kantban-${ticketNumber}-${slug}`;
-}
-function columnSlug(columnName) {
-  return columnName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-}
-function renderWorktreePath(ticketNumber, columnName, pathPattern) {
-  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);
-}
-function isPlausibleRemoteUrl(url) {
-  return url.includes("/") || url.includes("@") || url.includes("://");
-}
-function ensureWorktreeRemote(worktreePath) {
-  try {
-    const remotes = normalizeEol(execFileSync("git", ["-C", worktreePath, "remote"], {
-      stdio: "pipe",
-      encoding: "utf-8"
-    })).trim();
-    if (remotes.split("\n").includes("origin")) {
-      const currentUrl = normalizeEol(execFileSync("git", ["-C", worktreePath, "remote", "get-url", "origin"], {
-        stdio: "pipe",
-        encoding: "utf-8"
-      })).trim();
-      if (isPlausibleRemoteUrl(currentUrl)) return;
-      console.error(`[worktree] Invalid origin URL in ${worktreePath}: "${currentUrl}" \u2014 fixing`);
-      execFileSync("git", ["-C", worktreePath, "remote", "remove", "origin"], {
-        stdio: "pipe"
-      });
-    }
-    const originUrl = normalizeEol(execFileSync("git", ["remote", "get-url", "origin"], {
-      stdio: "pipe",
-      encoding: "utf-8"
-    })).trim();
-    if (originUrl && isPlausibleRemoteUrl(originUrl)) {
-      execFileSync("git", ["-C", worktreePath, "remote", "add", "origin", originUrl], {
-        stdio: "pipe"
-      });
-      console.error(`[worktree] Added missing origin remote to ${worktreePath}: ${originUrl}`);
-    } else {
-      console.error(`[worktree] WARNING: main repo origin URL is also invalid: "${originUrl}"`);
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`[worktree] Failed to ensure remote for ${worktreePath}: ${msg}`);
-  }
-}
-async function cleanupWorktree(worktreeName, exec = defaultExecFile) {
-  let target = worktreeName;
-  try {
-    const path = await findWorktreeForBranch(exec, worktreeName);
-    if (!path) return true;
-    target = path;
-  } catch {
-    return true;
-  }
-  return new Promise((resolve) => {
-    exec("git", ["worktree", "remove", "--force", target], (err) => {
-      if (err) {
-        console.error(`[worktree] cleanup failed for ${worktreeName} (${target}): ${err.message}`);
-        resolve(false);
-      } else {
-        resolve(true);
-      }
-    });
-  });
-}
-function execPromise(exec, cmd, args) {
-  return new Promise((resolve, reject) => {
-    exec(cmd, args, (err, stdout, stderr) => {
-      if (err) reject(Object.assign(err, { stdout, stderr }));
-      else resolve({ stdout, stderr });
-    });
-  });
-}
-async function findWorktreeForBranch(exec, branch) {
-  try {
-    const { stdout } = await execPromise(exec, "git", ["worktree", "list", "--porcelain"]);
-    const targetRef = `refs/heads/${branch}`;
-    let currentPath = null;
-    for (const line of normalizeEol(stdout).split("\n")) {
-      if (line.startsWith("worktree ")) currentPath = line.slice("worktree ".length);
-      if (line.startsWith("branch ") && line.slice("branch ".length) === targetRef && currentPath) {
-        return currentPath;
-      }
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function mergeWorktreeBranch(worktreeName, integrationBranch, exec = defaultExecFile) {
-  try {
-    try {
-      await execPromise(exec, "git", ["rev-parse", "--verify", worktreeName]);
-    } catch {
-      return true;
-    }
-    await execPromise(exec, "git", ["branch", integrationBranch, "HEAD"]).catch(() => {
-    });
-    const checkedOutPath = await findWorktreeForBranch(exec, integrationBranch);
-    if (checkedOutPath) {
-      await execPromise(exec, "git", ["-C", checkedOutPath, "merge", "--no-edit", worktreeName]);
-      console.error(`[worktree] merged ${worktreeName} \u2192 ${integrationBranch}`);
-      return true;
-    }
-    const { stdout: baseOut } = await execPromise(exec, "git", ["merge-base", integrationBranch, worktreeName]);
-    const mergeBase = baseOut.trim();
-    const { stdout: integrationSha } = await execPromise(exec, "git", ["rev-parse", integrationBranch]);
-    if (integrationSha.trim() === mergeBase) {
-      const { stdout: worktreeSha } = await execPromise(exec, "git", ["rev-parse", worktreeName]);
-      await execPromise(exec, "git", ["update-ref", `refs/heads/${integrationBranch}`, worktreeSha.trim()]);
-      console.error(`[worktree] fast-forward merged ${worktreeName} \u2192 ${integrationBranch}`);
-      return true;
-    }
-    const tmpWorktree = `merge-tmp-${Date.now()}`;
-    try {
-      await execPromise(exec, "git", ["worktree", "add", tmpWorktree, integrationBranch]);
-      await execPromise(exec, "git", ["-C", tmpWorktree, "merge", "--no-edit", worktreeName]);
-      console.error(`[worktree] merged ${worktreeName} \u2192 ${integrationBranch}`);
-    } finally {
-      await execPromise(exec, "git", ["worktree", "remove", "--force", tmpWorktree]).catch(() => {
-      });
-    }
-    return true;
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(`[worktree] merge failed for ${worktreeName} \u2192 ${integrationBranch}: ${msg}`);
-    return false;
-  }
-}
-
 // src/lib/constraint-evaluator.ts
 function resolveColumn(board, columnId, subjectRef) {
   const ref = subjectRef ?? "self";
@@ -942,8 +815,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 {
@@ -957,26 +830,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)`);
+    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) {
-          await this.emitDispatchDeferred(ticket.id, "firing_constraint", { columnId });
+          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");
+          }
         }
-        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);
-      }
-    }
+        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).
@@ -1098,15 +1001,58 @@ 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);
@@ -1121,9 +1067,9 @@ var PipelineOrchestrator = class {
       this.releaseSlot(columnId);
       this.deferredTickets.set(ticketId, columnId);
       void this.emitDispatchDeferred(ticketId, "unresolved_blockers", { 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.drainQueue(columnId).catch((dErr) => {
+        const dMsg = dErr instanceof Error ? dErr.message : String(dErr);
+        console.error(`  [error] drainQueue failed for column ${columnId}: ${dMsg}`);
       });
       return;
     }
@@ -1271,16 +1217,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
@@ -1799,6 +1745,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.
    */
@@ -2186,8 +2145,8 @@ ${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);
@@ -2542,7 +2501,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;
@@ -2571,7 +2530,7 @@ var PipelineWsClient = class _PipelineWsClient {
             this.options.onConnect();
             if (!resolved) {
               resolved = true;
-              resolve();
+              resolve2();
             }
           }
           this.options.onEvent(event);
@@ -3386,7 +3345,7 @@ var ProviderRegistry = class {
 };
 
 // src/providers/codex-provider.ts
-import { spawn as spawn2, execFileSync as execFileSync2 } from "child_process";
+import { spawn as spawn2, execFileSync } from "child_process";
 import { existsSync, rmSync as rmSync2 } from "fs";
 
 // src/providers/codex-jsonl-parser.ts
@@ -3527,45 +3486,47 @@ var CodexProvider = class {
       const branch = request.branch ?? request.workingDirectory;
       if (!existsSync(request.workingDirectory)) {
         try {
-          execFileSync2("git", ["worktree", "add", "-b", branch, request.workingDirectory, "HEAD"], {
+          execFileSync("git", ["worktree", "add", "-b", branch, request.workingDirectory, "HEAD"], {
             stdio: "pipe"
           });
         } catch {
           try {
-            execFileSync2("git", ["worktree", "add", request.workingDirectory, branch], {
+            execFileSync("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 {
         try {
-          execFileSync2("git", ["-C", request.workingDirectory, "rev-parse", "--git-dir"], {
+          execFileSync("git", ["-C", request.workingDirectory, "rev-parse", "--git-dir"], {
             stdio: "pipe"
           });
         } catch {
           try {
             rmSync2(request.workingDirectory, { recursive: true, force: true });
-            execFileSync2("git", ["worktree", "add", "-b", branch, request.workingDirectory, "HEAD"], {
+            execFileSync("git", ["worktree", "add", "-b", branch, request.workingDirectory, "HEAD"], {
               stdio: "pipe"
             });
           } catch {
             try {
-              execFileSync2("git", ["worktree", "add", request.workingDirectory, branch], {
+              execFileSync("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, {
@@ -3616,7 +3577,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));
@@ -3687,7 +3648,7 @@ var CodexProvider = class {
 };
 
 // src/providers/gemini-provider.ts
-import { spawn as spawn3, execFileSync as execFileSync3 } from "child_process";
+import { spawn as spawn3, execFileSync as execFileSync2 } 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";
@@ -3899,12 +3860,12 @@ var GeminiProvider = class _GeminiProvider {
     if (request.workingDirectory) {
       if (!existsSync2(request.workingDirectory)) {
         try {
-          execFileSync3("git", ["worktree", "add", "-b", request.workingDirectory, request.workingDirectory, "HEAD"], {
+          execFileSync2("git", ["worktree", "add", "-b", request.workingDirectory, request.workingDirectory, "HEAD"], {
             stdio: "pipe"
           });
         } catch {
           try {
-            execFileSync3("git", ["worktree", "add", request.workingDirectory, request.workingDirectory], {
+            execFileSync2("git", ["worktree", "add", request.workingDirectory, request.workingDirectory], {
               stdio: "pipe"
             });
           } catch {
@@ -3913,18 +3874,18 @@ var GeminiProvider = class _GeminiProvider {
         }
       } else {
         try {
-          execFileSync3("git", ["-C", request.workingDirectory, "rev-parse", "--git-dir"], {
+          execFileSync2("git", ["-C", request.workingDirectory, "rev-parse", "--git-dir"], {
             stdio: "pipe"
           });
         } catch {
           try {
             rmSync3(request.workingDirectory, { recursive: true, force: true });
-            execFileSync3("git", ["worktree", "add", "-b", request.workingDirectory, request.workingDirectory, "HEAD"], {
+            execFileSync2("git", ["worktree", "add", "-b", request.workingDirectory, request.workingDirectory, "HEAD"], {
               stdio: "pipe"
             });
           } catch {
             try {
-              execFileSync3("git", ["worktree", "add", request.workingDirectory, request.workingDirectory], {
+              execFileSync2("git", ["worktree", "add", request.workingDirectory, request.workingDirectory], {
                 stdio: "pipe"
               });
             } catch {
@@ -3942,7 +3903,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, {
@@ -4015,7 +3976,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));
@@ -4182,6 +4143,18 @@ node "${hookScript}" "${event}" "${configFile}" < "$STDIN_FILE"
 };
 
 // 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());
@@ -4398,14 +4371,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) {
@@ -4483,6 +4456,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`,
@@ -4682,7 +4681,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([
@@ -4796,6 +4815,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);
@@ -5127,7 +5147,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 {
@@ -5177,4 +5197,4 @@ export {
   runPipeline,
   stopPipeline
 };
-//# sourceMappingURL=pipeline-GZOSDNPF.js.map
+//# sourceMappingURL=pipeline-NRG2Q2TE.js.map