kantban-cli 0.1.49 → 0.1.51

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

@@ -1,6 +1,6 @@
 import {
   runGates
-} from "./chunk-DENXSVKE.js";
+} from "./chunk-GQQUH3TA.js";
 import {
   ClaudeProvider,
   RalphLoop,
@@ -8,12 +8,13 @@ import {
   cleanupGateProxyConfigs,
   cleanupMcpConfig,
   composeStuckDetectionPrompt,
+  detectBranchMerged,
   generateGateProxyMcpConfig,
   generateMcpConfig,
   parseJsonFromLlmOutput,
   parseStuckDetectionResponse,
   reapOrphanedMcpConfigDirs
-} from "./chunk-QHJZIGEE.js";
+} from "./chunk-X2CJ3ZAI.js";
 import {
   LoopCheckpointSchema,
   VerdictSchema,
@@ -31,9 +32,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 { homedir as homedir2 } from "os";
-import { join as join3, dirname as dirname2 } 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:";
@@ -57,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}`;
@@ -64,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("://");
@@ -115,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 });
     });
   });
 }
@@ -942,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 {
@@ -957,26 +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)`);
+    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 +1139,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 +1205,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 +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
@@ -1799,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.
    */
@@ -2186,8 +2283,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 +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;
@@ -2571,7 +2668,7 @@ var PipelineWsClient = class _PipelineWsClient {
             this.options.onConnect();
             if (!resolved) {
               resolved = true;
-              resolve();
+              resolve2();
             }
           }
           this.options.onEvent(event);
@@ -2683,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;
@@ -2691,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);
@@ -2727,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,
@@ -2749,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);
@@ -3535,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 {
@@ -3555,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, {
@@ -3616,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));
@@ -3689,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";
 
@@ -3853,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) {
@@ -3942,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, {
@@ -4015,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));
@@ -4053,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) {
@@ -4079,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;
@@ -4105,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}
@@ -4171,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());
@@ -4303,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);
@@ -4320,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 {
@@ -4365,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);
@@ -4398,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) {
@@ -4424,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()}`);
@@ -4461,7 +4572,7 @@ async function runPipeline(client, args) {
     ...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;
@@ -4483,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`,
@@ -4499,7 +4636,7 @@ async function runPipeline(client, args) {
         effectiveConfig.model = registry.resolveModel(columnProvider, effectiveConfig.model);
       }
       const { gates: columnGates } = resolveGatesForColumn(gateConfig, resolvedColumnName);
-      const gateCwd = effectiveConfig.worktreePath ?? (effectiveConfig.worktreeName ? join3(process.cwd(), effectiveConfig.worktreeName) : process.cwd());
+      const gateCwd = effectiveConfig.worktreePath ?? (effectiveConfig.worktreeName ? join4(process.cwd(), effectiveConfig.worktreeName) : process.cwd());
       const effectiveMcpConfigPath = columnGates.length > 0 ? generateGateProxyMcpConfig(
         client.baseUrl,
         client.token,
@@ -4682,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([
@@ -4796,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);
@@ -4987,7 +5145,7 @@ 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),
@@ -5127,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 {
@@ -5177,4 +5335,4 @@ export {
   runPipeline,
   stopPipeline
 };
-//# sourceMappingURL=pipeline-GZOSDNPF.js.map
+//# sourceMappingURL=pipeline-6J64Z7VH.js.map