kantban-cli 0.1.47 → 0.1.49

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

@@ -1,6 +1,6 @@
 import {
   runGates
-} from "./chunk-O47Q6CNM.js";
+} from "./chunk-DENXSVKE.js";
 import {
   ClaudeProvider,
   RalphLoop,
@@ -11,8 +11,9 @@ import {
   generateGateProxyMcpConfig,
   generateMcpConfig,
   parseJsonFromLlmOutput,
-  parseStuckDetectionResponse
-} from "./chunk-UKWQ6VUQ.js";
+  parseStuckDetectionResponse,
+  reapOrphanedMcpConfigDirs
+} from "./chunk-QHJZIGEE.js";
 import {
   LoopCheckpointSchema,
   VerdictSchema,
@@ -20,7 +21,7 @@ import {
   parseGateConfig,
   parseTimeout,
   resolveGatesForColumn
-} from "./chunk-VDCHOIQI.js";
+} from "./chunk-4R27WTCJ.js";
 import {
   IS_WINDOWS,
   crossSpawnOptions,
@@ -32,7 +33,13 @@ import {
 // 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 { join as join3, dirname as dirname2 } from "path";
+
+// 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) {
@@ -470,7 +477,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 +519,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 +570,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 +652,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.
@@ -944,6 +967,9 @@ var PipelineOrchestrator = class {
       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)`);
+        for (const ticket of colScope.tickets) {
+          await this.emitDispatchDeferred(ticket.id, "firing_constraint", { columnId });
+        }
         continue;
       }
       console.error(`  [scan] Column ${columnId} (${colScope.column.name}): ${String(colScope.tickets.length)} ticket(s)`);
@@ -970,6 +996,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 +1011,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 +1061,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) {
@@ -1076,6 +1107,7 @@ var PipelineOrchestrator = class {
         this.releaseSlot(columnId);
         this.deferredTickets.set(ticketId, columnId);
         console.error(`  [skip] ${ticketId} has unresolved blockers \u2014 deferred`);
+        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,6 +1120,7 @@ var PipelineOrchestrator = class {
       this.spawning.delete(ticketId);
       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}`);
@@ -1096,6 +1129,7 @@ var PipelineOrchestrator = class {
     }
     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);
@@ -1254,6 +1288,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 +1319,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 +1449,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 +1467,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 +1629,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;
       }
@@ -1817,6 +1895,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 +2030,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);
@@ -2117,6 +2191,7 @@ ${findingsText}`)
           this.deferredTickets.set(nextTicketId, columnId);
           this.spawning.delete(nextTicketId);
           this.releaseSlot(columnId);
+          void this.emitDispatchDeferred(nextTicketId, "unresolved_blockers", { columnId });
           continue;
         }
       } catch (err) {
@@ -2125,10 +2200,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 +2234,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
@@ -3522,22 +3656,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");
@@ -4055,9 +4189,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 = [];
@@ -4304,6 +4454,7 @@ 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 } : {},
@@ -4347,7 +4498,7 @@ async function runPipeline(client, args) {
       if (effectiveConfig.model) {
         effectiveConfig.model = registry.resolveModel(columnProvider, effectiveConfig.model);
       }
-      const columnGates = resolveGatesForColumn(gateConfig, resolvedColumnName);
+      const { gates: columnGates } = resolveGatesForColumn(gateConfig, resolvedColumnName);
       const gateCwd = effectiveConfig.worktreePath ?? (effectiveConfig.worktreeName ? join3(process.cwd(), effectiveConfig.worktreeName) : process.cwd());
       const effectiveMcpConfigPath = columnGates.length > 0 ? generateGateProxyMcpConfig(
         client.baseUrl,
@@ -4360,7 +4511,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 +4632,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 +4668,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`
@@ -4664,7 +4834,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 +4890,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 +4904,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 +4928,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 +4956,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);
@@ -4815,7 +4994,7 @@ Received ${signal}. Shutting down gracefully...`);
     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 +5079,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);
@@ -4998,4 +5177,4 @@ export {
   runPipeline,
   stopPipeline
 };
-//# sourceMappingURL=pipeline-EUOOLKHN.js.map
+//# sourceMappingURL=pipeline-GZOSDNPF.js.map