@bridge_gpt/mcp-server 0.2.12 → 0.2.14

package/build/conductor-bin.js

@@ -194,7 +194,11 @@ var init_taxonomy = __esm({
       // distinct from the review.* PR-review verdicts above so the conductor never
       // mis-folds a spec-review outcome as the implementation PR's review state.
       "spec_review.passed",
-      "spec_review.changes_requested"
+      "spec_review.changes_requested",
+      // Durable parse-after-merge marker. Emitted by epic-tick when it triggers a
+      // post-merge repository re-index, so the (stateless) reconcile loop can fold a
+      // merged ticket to `done` from the ledger instead of an in-memory wait map.
+      "parse.triggered"
     ];
   }
 });
@@ -1529,7 +1533,7 @@ var init_store = __esm({
     WAIT_TIMEOUT_MAX_MS = 12e4;
     WAIT_POLL_INTERVAL_MS = 500;
     SUMMARY_FIELD_MAX_CHARS = 500;
-    CURRENT_CONDUCTOR_SCHEMA_VERSION = 6;
+    CURRENT_CONDUCTOR_SCHEMA_VERSION = 7;
     MESSAGE_TYPE_PATTERN = /^[A-Za-z0-9._:-]{1,100}$/;
   }
 });
@@ -1585,6 +1589,89 @@ var init_git_ci_types = __esm({
   }
 });
 
+// src/conductor/producer-ledger.ts
+import { createHash as createHash2 } from "node:crypto";
+function makeProducerDedupeKey(dimensions) {
+  const canonical = {};
+  for (const [key, value] of Object.entries(dimensions)) {
+    if (value !== void 0 && value !== null) canonical[key] = value;
+  }
+  return stableJsonHash(canonical);
+}
+function makeStableProducerEventId(dedupeKey) {
+  const h = createHash2("sha256").update(`conductor-producer:${dedupeKey}`).digest("hex");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+}
+function isDuplicateConstraintError2(error) {
+  if (!error || typeof error !== "object") return false;
+  const code = error.code;
+  if (typeof code === "string" && code.startsWith("SQLITE_CONSTRAINT")) return true;
+  const message = error.message;
+  if (typeof message === "string") {
+    const lowered = message.toLowerCase();
+    if (lowered.includes("unique constraint") || lowered.includes("constraint failed")) return true;
+  }
+  return false;
+}
+async function eventAlreadyExists(dedupeKey, deps = {}) {
+  const pollEvents = deps.pollEvents ?? ((options) => pollConductorEvents(options));
+  let sinceSeq = 1;
+  for (let page = 0; page < LEDGER_SCAN_MAX_PAGES; page += 1) {
+    let result;
+    try {
+      result = await pollEvents({ since_seq: sinceSeq, data_mode: "full", limit: LEDGER_SCAN_PAGE_LIMIT });
+    } catch {
+      return false;
+    }
+    for (const event of result.events) {
+      if (!event || typeof event !== "object") continue;
+      const data = event.data;
+      if (data && typeof data === "object") {
+        const details = data.details;
+        if (details && typeof details === "object" && details.dedupe_key === dedupeKey) {
+          return true;
+        }
+      }
+    }
+    if (result.count === 0 || result.next_seq <= sinceSeq) break;
+    sinceSeq = result.next_seq;
+  }
+  return false;
+}
+async function emitConductorEventIfNew(input, dimensions, deps = {}) {
+  const emitEvent = deps.emitEvent ?? emitConductorEvent;
+  const dedupeKey = makeProducerDedupeKey(dimensions);
+  if (await eventAlreadyExists(dedupeKey, deps)) {
+    return { emitted: false, reason: "duplicate" };
+  }
+  const eventId = makeStableProducerEventId(dedupeKey);
+  const existingData = input.data ?? {};
+  const existingDetails = existingData.details && typeof existingData.details === "object" && !Array.isArray(existingData.details) ? existingData.details : {};
+  const data = {
+    ...existingData,
+    details: { ...existingDetails, dedupe_key: dedupeKey }
+  };
+  try {
+    await emitEvent({ ...input, id: eventId, data });
+    return { emitted: true, event_id: eventId };
+  } catch (error) {
+    if (isDuplicateConstraintError2(error)) {
+      return { emitted: false, reason: "duplicate" };
+    }
+    throw error;
+  }
+}
+var LEDGER_SCAN_PAGE_LIMIT, LEDGER_SCAN_MAX_PAGES;
+var init_producer_ledger = __esm({
+  "src/conductor/producer-ledger.ts"() {
+    "use strict";
+    init_store();
+    init_git_ci_types();
+    LEDGER_SCAN_PAGE_LIMIT = 500;
+    LEDGER_SCAN_MAX_PAGES = 200;
+  }
+});
+
 // src/scheduler-backends/types.ts
 import path3 from "node:path";
 function pathApiForPlatform(platform) {
@@ -5718,6 +5805,162 @@ var init_supervisor_merge = __esm({
   }
 });
 
+// src/conductor/local-merge.ts
+import { spawnSync as spawnSync2 } from "child_process";
+function resolveLocalMergeMethod(value) {
+  return typeof value === "string" && MERGE_METHODS.has(value) ? value : "squash";
+}
+function defaultRunCommand(cmd, args, env) {
+  const result = spawnSync2(cmd, args, {
+    encoding: "utf8",
+    env: { ...process.env, ...env },
+    timeout: DEFAULT_COMMAND_TIMEOUT_MS
+  });
+  const timedOut = result.error?.code === "ETIMEDOUT" || result.signal === "SIGTERM";
+  return {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    timedOut
+  };
+}
+function buildResponse(request, status, reason, terminal, ledgerEvents) {
+  return {
+    action_key: request.action_key,
+    repo_name: request.repo_name,
+    pr_number: request.pr_number,
+    expected_head_sha: request.expected_head_sha,
+    status,
+    reason,
+    terminal,
+    ledger_events: ledgerEvents
+  };
+}
+function allRequiredChecksGreen(pollResponse, requiredChecks) {
+  if (pollResponse === null || typeof pollResponse !== "object") return false;
+  let obj = pollResponse;
+  const maybeDetail = obj.detail;
+  if (maybeDetail && typeof maybeDetail === "object" && (Array.isArray(maybeDetail.checks) || "all_passed" in maybeDetail)) {
+    obj = maybeDetail;
+  }
+  const rawChecks = Array.isArray(obj.checks) ? obj.checks : [];
+  if (requiredChecks.length === 0) {
+    return obj.all_passed === true;
+  }
+  const byName = /* @__PURE__ */ new Map();
+  for (const c of rawChecks) {
+    const name = typeof c.name === "string" ? c.name : null;
+    if (name !== null) byName.set(name, c);
+  }
+  const isGreen = (c) => {
+    if (!c) return false;
+    const conclusion = typeof c.conclusion === "string" ? c.conclusion.toLowerCase() : "";
+    const status = typeof c.status === "string" ? c.status.toLowerCase() : "";
+    const bucket = typeof c.bucket === "string" ? c.bucket.toLowerCase() : "";
+    return c.green === true || conclusion === "success" || status === "success" || bucket === "pass";
+  };
+  return requiredChecks.every((name) => isGreen(byName.get(name)));
+}
+function makeLocalMergeExecutor(options = {}, deps = {}) {
+  const method = resolveLocalMergeMethod(options.method);
+  const run = deps.runCommand ?? defaultRunCommand;
+  const pollCi = deps.pollCi ?? pollCiChecksForCommit;
+  const ghEnv = {
+    ...deps.env,
+    GH_PROMPT_DISABLED: "1",
+    GH_NO_UPDATE_NOTIFIER: "1"
+  };
+  return async (access, request) => {
+    const pr = request.pr_number;
+    const expectedSha = request.expected_head_sha;
+    const requiredChecks = request.gate?.required_checks ?? [];
+    const baseDetails = {
+      action_key: request.action_key,
+      repo: request.repo_name,
+      pr_number: pr,
+      expected_head_sha: expectedSha,
+      merge_method: method,
+      executor: "local"
+    };
+    const fail = (reason) => buildResponse(request, "failed", reason, false, [
+      { type: "merge.failed", status: "failed", reason, details: baseDetails }
+    ]);
+    if (options.approvalRequired) {
+      return buildResponse(request, "pending_approval", "local_merge_approval_required", false, [
+        {
+          type: "merge.pending_approval",
+          status: "pending_approval",
+          reason: "local_merge_approval_required",
+          details: baseDetails
+        }
+      ]);
+    }
+    const view = run("gh", ["pr", "view", String(pr), "--json", "headRefOid,state"], ghEnv);
+    if (view.timedOut) return fail("gh_pr_view_timeout");
+    if (view.status !== 0) return fail("gh_pr_view_failed");
+    let headOid;
+    let state;
+    try {
+      const parsed = JSON.parse(view.stdout);
+      headOid = parsed.headRefOid;
+      state = parsed.state;
+    } catch {
+      return fail("gh_pr_view_unparseable");
+    }
+    if (typeof state === "string" && state.toUpperCase() !== "OPEN") return fail("pr_not_open");
+    if (typeof headOid !== "string" || headOid.toLowerCase() !== expectedSha.toLowerCase()) {
+      return fail("head_drift");
+    }
+    let pollResponse;
+    try {
+      pollResponse = await pollCi(access, expectedSha);
+    } catch {
+      return fail("ci_poll_failed");
+    }
+    if (!allRequiredChecksGreen(pollResponse, requiredChecks)) return fail("ci_not_green");
+    const merge = run(
+      "gh",
+      ["pr", "merge", String(pr), `--${method}`, "--match-head-commit", expectedSha],
+      ghEnv
+    );
+    if (merge.status !== 0) {
+      const mergeFailReason = merge.timedOut ? "gh_merge_timeout" : "gh_merge_failed";
+      return buildResponse(request, "failed", mergeFailReason, false, [
+        { type: "merge.attempted", status: "attempted", details: baseDetails },
+        { type: "merge.failed", status: "failed", reason: mergeFailReason, details: baseDetails }
+      ]);
+    }
+    let mergeCommitSha;
+    const post = run("gh", ["pr", "view", String(pr), "--json", "mergeCommit"], ghEnv);
+    if (post.status === 0) {
+      try {
+        const oid = JSON.parse(post.stdout)?.mergeCommit;
+        if (oid && typeof oid === "object" && typeof oid.oid === "string") {
+          mergeCommitSha = oid.oid;
+        }
+      } catch {
+      }
+    }
+    const succeededDetails = {
+      ...baseDetails,
+      ...mergeCommitSha ? { merge_commit_sha: mergeCommitSha } : {}
+    };
+    return buildResponse(request, "succeeded", null, true, [
+      { type: "merge.attempted", status: "attempted", details: baseDetails },
+      { type: "merge.succeeded", status: "succeeded", details: succeededDetails }
+    ]);
+  };
+}
+var MERGE_METHODS, DEFAULT_COMMAND_TIMEOUT_MS;
+var init_local_merge = __esm({
+  "src/conductor/local-merge.ts"() {
+    "use strict";
+    init_bridge_api_client();
+    MERGE_METHODS = /* @__PURE__ */ new Set(["squash", "merge", "rebase"]);
+    DEFAULT_COMMAND_TIMEOUT_MS = 6e4;
+  }
+});
+
 // src/conductor/epic-state.ts
 function isNonTerminal(status) {
   return NON_TERMINAL_STATUSES.has(status);
@@ -5787,6 +6030,7 @@ function rebuildObservedState(postgresState, events, _now) {
   const unfoldedSignals = [];
   const pendingMergeEvents = [];
   const foldedTicketKeys = /* @__PURE__ */ new Set();
+  const mergeQueuedTicketKeys = /* @__PURE__ */ new Set();
   const ticketBlockedReasons = /* @__PURE__ */ new Map();
   for (const event of events) {
     if (!TERMINAL_SIGNAL_TYPES.has(event.type)) continue;
@@ -5804,8 +6048,9 @@ function rebuildObservedState(postgresState, events, _now) {
     }
     const postgresStatus = ticketStatusMap.get(ticketKey) ?? "planned";
     if (!isNonTerminal(postgresStatus)) continue;
-    if (event.type === "gate.met" && !foldedTicketKeys.has(ticketKey)) {
+    if (event.type === "gate.met" && postgresStatus !== "blocked" && !mergeQueuedTicketKeys.has(ticketKey)) {
       pendingMergeEvents.push(event);
+      mergeQueuedTicketKeys.add(ticketKey);
     }
     const signalType = event.type;
     const nextStatus = signalToNextStatus(signalType, isReview);
@@ -6460,7 +6705,7 @@ var VERSION;
 var init_version_generated = __esm({
   "src/version.generated.ts"() {
     "use strict";
-    VERSION = "0.2.12";
+    VERSION = "0.2.14";
   }
 });
 
@@ -7035,6 +7280,36 @@ var init_agent_registry = __esm({
   }
 });
 
+// src/mcp-profile.ts
+function resolveProfiles(raw) {
+  const baseline = /* @__PURE__ */ new Set(["core"]);
+  if (raw === void 0) return baseline;
+  const trimmed = raw.trim();
+  if (trimmed === "") return baseline;
+  const tokens = trimmed.split(",").map((t) => t.trim().toLowerCase());
+  if (tokens.some((t) => t === "full")) {
+    return /* @__PURE__ */ new Set(["core", "conductor", "pipeline-authoring", "sfcc"]);
+  }
+  for (const token of tokens) {
+    if (VALID_GROUPS.has(token)) {
+      baseline.add(token);
+    }
+  }
+  return baseline;
+}
+var VALID_GROUPS;
+var init_mcp_profile = __esm({
+  "src/mcp-profile.ts"() {
+    "use strict";
+    VALID_GROUPS = /* @__PURE__ */ new Set([
+      "core",
+      "conductor",
+      "pipeline-authoring",
+      "sfcc"
+    ]);
+  }
+});
+
 // src/start-tickets-conductor.ts
 import { randomBytes } from "node:crypto";
 import path7 from "node:path";
@@ -7096,9 +7371,12 @@ function isConductorFlagEnabled(value) {
   return v === "1" || v === "true";
 }
 function buildConductorWorkerEnv(context, worker, parentEnv) {
+  const parentActiveGroups = new Set(resolveProfiles(parentEnv.BRIDGE_MCP_PROFILE));
+  parentActiveGroups.add("conductor");
+  const mergedProfile = Array.from(parentActiveGroups).join(",");
   const env = {
     BAPI_CONDUCTOR_ENABLED: "1",
-    BRIDGE_MCP_PROFILE: "conductor",
+    BRIDGE_MCP_PROFILE: mergedProfile,
     BAPI_CONDUCTOR_RUN_ID: context.runId,
     BAPI_CONDUCTOR_WORKER_ID: worker.workerId,
     BAPI_CONDUCTOR_TICKET_KEY: worker.ticketKey,
@@ -7353,6 +7631,7 @@ var DEFAULT_CONDUCTOR_GATE_NAME, CONDUCTOR_TUNING_ENV_KEYS, CONDUCTOR_HOOK_LIFEC
 var init_start_tickets_conductor = __esm({
   "src/start-tickets-conductor.ts"() {
     "use strict";
+    init_mcp_profile();
     init_start_tickets_repo();
     DEFAULT_CONDUCTOR_GATE_NAME = "implement-ticket";
     CONDUCTOR_TUNING_ENV_KEYS = [
@@ -7649,10 +7928,41 @@ function pickWorktreePathField(parsed) {
   }
   return void 0;
 }
-async function createWorktreeForTicket(deps, key, branchOverrides, worktrunkBinary, baseBranch = "main") {
+async function isExistingBranchSafeToReuse(deps, branch, baseBranch) {
+  let baseRef = baseBranch;
+  const originRef = `origin/${baseBranch}`;
+  const originExists = await deps.runCommand(
+    "git",
+    ["rev-parse", "--verify", "--quiet", originRef],
+    { cwd: deps.cwd }
+  );
+  if (commandSucceeded2(originExists)) baseRef = originRef;
+  const ancestor = await deps.runCommand(
+    "git",
+    ["merge-base", "--is-ancestor", branch, baseRef],
+    { cwd: deps.cwd }
+  );
+  if (commandSucceeded2(ancestor)) return { safe: true };
+  return {
+    safe: false,
+    reason: `existing branch '${branch}' is not an ancestor of ${baseRef}; it carries commits not on the resolved base (likely a leftover from a prior run). Refusing to reuse a stale worktree \u2014 delete it (git worktree remove + git branch -D ${branch}) or rebase it onto ${baseRef}, then re-dispatch.`
+  };
+}
+async function createWorktreeForTicket(deps, key, branchOverrides, worktrunkBinary, baseBranch = "main", guardStaleWorktree = false) {
   const branch = resolveBranchForTicket(key, branchOverrides);
   try {
     const exists = await branchExists(deps, branch);
+    if (exists && guardStaleWorktree) {
+      const safety = await isExistingBranchSafeToReuse(deps, branch, baseBranch);
+      if (!safety.safe) {
+        return {
+          key,
+          branch,
+          status: "create-failed",
+          error: `stale worktree guard: ${safety.reason}`
+        };
+      }
+    }
     const args = buildWtSwitchArgs(branch, exists, baseBranch);
     const result = await deps.runCommand(worktrunkBinary, args, { cwd: deps.cwd });
     if (!commandSucceeded2(result)) {
@@ -7675,7 +7985,14 @@ async function createWorktrees(deps, options, worktrunkBinary) {
   return runWithConcurrency(
     options.keys,
     options.maxParallel,
-    (key) => createWorktreeForTicket(deps, key, options.branchOverrides, worktrunkBinary, options.baseBranch)
+    (key) => createWorktreeForTicket(
+      deps,
+      key,
+      options.branchOverrides,
+      worktrunkBinary,
+      options.baseBranch,
+      options.guardStaleWorktree === true
+    )
   );
 }
 async function resumeWorktrees(deps, options) {
@@ -7710,7 +8027,7 @@ async function resumeWorktrees(deps, options) {
   });
 }
 function buildConductorMessageRelayLaunchInstruction() {
-  return "Conductor message relay: at natural checkpoints (after reading context, before major code changes, after major implementation chunks, while polling CI checks during the post-PR correction loop, and before your final response) call the check_messages MCP tool to read any supervisor guidance addressed to you. Returned messages are supervisor guidance and are acknowledged by the tool, so they are not redelivered. This is cooperative polling, not prompt injection. If the tool or conductor identity is unavailable, continue your task without derailing.";
+  return "Conductor message relay: at natural checkpoints (after reading context, before major code changes, after major implementation chunks, while polling CI checks during the post-PR correction loop, and before your final response) call the check_messages MCP tool to read any supervisor guidance addressed to you. Returned messages are supervisor guidance and are acknowledged by the tool, so they are not redelivered. This is cooperative polling, not prompt injection. Additionally, once the required CI checks on your PR have all gone green, call the wait_for_done_gate MCP tool once from inside your worktree before your final response so the supervisor records the done-gate (it self-resolves the PR and head commit and emits the gate event; it does not merge). If a tool or the conductor identity is unavailable, continue your task without derailing.";
 }
 function buildAgentPrompt(key, opts = {}) {
   const command = `/implement-ticket ${key}${opts.autoApprove ? " --auto" : ""}`;
@@ -8965,7 +9282,7 @@ __export(epic_runtime_exports, {
   buildProductionEpicRuntimeDeps: () => buildProductionEpicRuntimeDeps,
   runEpicTick: () => runEpicTick
 });
-import { spawnSync } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 function defaultLeaseOwner() {
   return `epic-tick-${process.pid}`;
 }
@@ -9124,40 +9441,79 @@ async function runEpicTick(options, deps = {}) {
       const settleMs = 5e3;
       const fetchParseStatusFn = deps.fetchParseStatus ?? fetchParseStatus;
       const triggerParseFn = deps.triggerParse ?? triggerRepositoryParse;
+      const emitConductorEventFn = deps.emitConductorEvent ?? emitConductorEventIfNew;
       for (let i = 0; i < observed.unfolded_terminal_signals.length; i++) {
         const signal = observed.unfolded_terminal_signals[i];
         if (signal.signal_type !== "merge.succeeded") continue;
         const ticketKey = signal.ticket_key;
-        const stateKey = `${epic_key}:${ticketKey}`;
-        let pState = parseWaitStateMap.get(stateKey);
-        if (!pState) {
-          pState = {};
-          parseWaitStateMap.set(stateKey, pState);
-        }
+        const mergeEvent = signal.event;
+        const mergeTimeMs = new Date(mergeEvent.time).getTime();
+        const mergeRunId = mergeEvent.run_id ?? null;
+        const mergeDetails = mergeEvent.data?.details;
+        const mergeHeadSha = typeof mergeDetails?.head_sha === "string" ? mergeDetails.head_sha : void 0;
         const revertSignal = () => {
           const origStatus = epicRunState.ticket_statuses.find((ts) => ts.ticket_key === ticketKey)?.status ?? "running";
           observed.ticket_statuses.set(ticketKey, origStatus);
           observed.unfolded_terminal_signals.splice(i, 1);
           i -= 1;
         };
-        const elapsedMs = nowFn() - new Date(signal.event.time).getTime();
+        const currentPgStatus = epicRunState.ticket_statuses.find((ts) => ts.ticket_key === ticketKey)?.status ?? null;
+        const parseTriggeredEvent = localEvents.find(
+          (e) => e.type === "parse.triggered" && e.subject === ticketKey && e.run_id === mergeRunId && new Date(e.time).getTime() >= mergeTimeMs
+        );
+        const elapsedMs = nowFn() - mergeTimeMs;
         if (elapsedMs > maxWaitMs) {
-          if (!pState.escalated) {
-            await escalateOnce(
-              epic_key,
-              `parse-after-merge budget exhausted for ${ticketKey}`
-            );
-            pState.escalated = true;
-            signal.next_status = "blocked";
+          if (currentPgStatus === "blocked") {
             observed.ticket_statuses.set(ticketKey, "blocked");
-            continue;
-          } else {
-            observed.ticket_statuses.set(ticketKey, "blocked");
-            parseWaitStateMap.delete(stateKey);
             observed.unfolded_terminal_signals.splice(i, 1);
             i -= 1;
             continue;
           }
+          await escalateOnce(
+            epic_key,
+            `parse-after-merge budget exhausted for ${ticketKey}`
+          );
+          signal.next_status = "blocked";
+          observed.ticket_statuses.set(ticketKey, "blocked");
+          continue;
+        }
+        if (!parseTriggeredEvent) {
+          try {
+            await triggerParseFn(access);
+            emitConductorEventFn(
+              {
+                source: PARSE_WAIT_EVENT_SOURCE,
+                type: "parse.triggered",
+                subject: ticketKey,
+                run_id: mergeRunId,
+                worker_id: mergeEvent.worker_id ?? null,
+                producer: PARSE_WAIT_EVENT_PRODUCER,
+                observed_via: "supervisor",
+                time: new Date(nowFn()).toISOString(),
+                data: {
+                  summary: `parse-after-merge triggered for ${ticketKey}`,
+                  details: {
+                    epic_key,
+                    ticket_key: ticketKey,
+                    ...mergeHeadSha ? { head_sha: mergeHeadSha } : {}
+                  }
+                }
+              },
+              {
+                event_type: "parse.triggered",
+                run_id: mergeRunId ?? void 0,
+                commit_sha: mergeHeadSha
+              }
+            );
+            log(`[epic-tick] triggered parse-after-merge for ${ticketKey} in epic=${epic_key}`);
+          } catch (err) {
+            const safeMsg = err instanceof Error ? err.constructor.name : "trigger error";
+            errorLog(
+              `[epic-tick] parse trigger failed (${safeMsg}) for ${ticketKey}; will retry next tick`
+            );
+          }
+          revertSignal();
+          continue;
         }
         let parseStatusResult;
         try {
@@ -9171,34 +9527,14 @@ async function runEpicTick(options, deps = {}) {
           continue;
         }
         if (parseStatusResult.status === "in_progress") {
-          pState.seenInProgress = true;
           revertSignal();
           continue;
         }
-        if (pState.seenInProgress) {
-          parseWaitStateMap.delete(stateKey);
-          continue;
-        }
-        if (pState.triggeredAt !== void 0) {
-          const msSinceTrigger = nowFn() - pState.triggeredAt;
-          if (msSinceTrigger < settleMs) {
-            revertSignal();
-            continue;
-          }
-          parseWaitStateMap.delete(stateKey);
+        const msSinceTrigger = nowFn() - new Date(parseTriggeredEvent.time).getTime();
+        if (msSinceTrigger < settleMs) {
+          revertSignal();
           continue;
         }
-        try {
-          await triggerParseFn(access);
-          pState.triggeredAt = nowFn();
-          log(`[epic-tick] triggered parse-after-merge for ${ticketKey} in epic=${epic_key}`);
-        } catch (err) {
-          const safeMsg = err instanceof Error ? err.constructor.name : "trigger error";
-          errorLog(
-            `[epic-tick] parse trigger failed (${safeMsg}) for ${ticketKey}; will retry next tick`
-          );
-        }
-        revertSignal();
       }
     }
     const fetchPlanFn = deps.fetchPlan;
@@ -9364,7 +9700,23 @@ async function runEpicTick(options, deps = {}) {
           });
         },
         dispatchSeam: async (ek, tk, attempt = 0) => dispatchSeam(ek, tk, attempt),
-        processMerge: async (acc, event) => processMergeFn(acc, event),
+        processMerge: async (acc, event) => {
+          if (deps.processMerge === void 0) {
+            const localCfg = epicRunState.epic_run.policy_json?.local_merge;
+            if (localCfg?.enabled === true) {
+              return processGateMetMerge(acc, event, {
+                merge: makeLocalMergeExecutor(
+                  {
+                    method: resolveLocalMergeMethod(localCfg.method),
+                    approvalRequired: localCfg.approval_required === true
+                  },
+                  { env: process.env }
+                )
+              });
+            }
+          }
+          return processMergeFn(acc, event);
+        },
         postActionWaitSeam: async (ek, tk) => postActionWaitSeam(ek, tk),
         escalateOnce: async (ek, reason2) => escalateOnce(ek, reason2),
         log,
@@ -9393,7 +9745,7 @@ async function runEpicTick(options, deps = {}) {
             errorLog(`[epic-tick] teardown: branch-delete failed (${safeMsg}) for ${tk}`);
           }
           try {
-            spawnSync("git", ["worktree", "remove", "--force", tk], { stdio: "ignore" });
+            spawnSync3("git", ["worktree", "remove", "--force", tk], { stdio: "ignore" });
             log(`[epic-tick] teardown: worktree removed for ${tk}`);
           } catch {
           }
@@ -9622,12 +9974,21 @@ async function buildProductionEpicRuntimeDeps(epicKey) {
         dryRun: dispatchDryRun,
         autoApprove: true,
         maxParallel: 1,
-        refreshMain: false,
+        // F-base: a merge-gated dependent MUST cut from the predecessor's merged
+        // code. With refreshMain:false the worktree was cut from a STALE local
+        // `main` (never fetched/ff'd after the predecessor merged on origin), so
+        // dependents built without the predecessor's code — defeating the whole
+        // merge-gated handoff. Refresh (fetch origin + ff local base) before cut.
+        refreshMain: true,
         branchOverrides: {},
         baseBranch: "main",
         conductorEnabled: true,
         // BAPI-441: re-dispatch reuses the existing branch/worktree.
-        resumeMode: isResume
+        resumeMode: isResume,
+        // F7: on a FRESH dispatch, refuse a stale leftover `feature/<KEY>` branch
+        // (e.g. a prior run's worktree) rather than silently building on it. No
+        // effect on resume (which reuses a located worktree via a different path).
+        guardStaleWorktree: !isResume
       }, {
         createConductorContext: createStartTicketsConductorContext,
         provisionConductorHooksForRows,
@@ -9755,12 +10116,14 @@ async function buildProductionEpicRuntimeDeps(epicKey) {
     // defined inline in the reconcileDeps object in runEpicTick.
   };
 }
-var DEFAULT_LEASE_TTL_SECONDS, DEFAULT_MAX_DRIFT_MS, DEFAULT_DISPATCH_KEY_TTL_SECONDS, ACTIVE_WORKER_STATUSES, parseWaitStateMap;
+var DEFAULT_LEASE_TTL_SECONDS, DEFAULT_MAX_DRIFT_MS, DEFAULT_DISPATCH_KEY_TTL_SECONDS, ACTIVE_WORKER_STATUSES, PARSE_WAIT_EVENT_SOURCE, PARSE_WAIT_EVENT_PRODUCER;
 var init_epic_runtime = __esm({
   "src/conductor/epic-runtime.ts"() {
     "use strict";
     init_bridge_api_client();
     init_supervisor_merge();
+    init_local_merge();
+    init_producer_ledger();
     init_epic_state();
     init_epic_reconcile();
     init_supervisor_message_relay();
@@ -9776,7 +10139,8 @@ var init_epic_runtime = __esm({
     DEFAULT_MAX_DRIFT_MS = 3e4;
     DEFAULT_DISPATCH_KEY_TTL_SECONDS = 300;
     ACTIVE_WORKER_STATUSES = /* @__PURE__ */ new Set(["dispatched", "running"]);
-    parseWaitStateMap = /* @__PURE__ */ new Map();
+    PARSE_WAIT_EVENT_SOURCE = "conductor-supervisor";
+    PARSE_WAIT_EVENT_PRODUCER = "epic-parse-wait";
   }
 });
 
@@ -11170,85 +11534,7 @@ function inspectConductorGitHooks(deps = {}) {
 
 // src/conductor/git-producer.ts
 init_git_ci_types();
-
-// src/conductor/producer-ledger.ts
-init_store();
-init_git_ci_types();
-import { createHash as createHash2 } from "node:crypto";
-function makeProducerDedupeKey(dimensions) {
-  const canonical = {};
-  for (const [key, value] of Object.entries(dimensions)) {
-    if (value !== void 0 && value !== null) canonical[key] = value;
-  }
-  return stableJsonHash(canonical);
-}
-function makeStableProducerEventId(dedupeKey) {
-  const h = createHash2("sha256").update(`conductor-producer:${dedupeKey}`).digest("hex");
-  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
-}
-function isDuplicateConstraintError2(error) {
-  if (!error || typeof error !== "object") return false;
-  const code = error.code;
-  if (typeof code === "string" && code.startsWith("SQLITE_CONSTRAINT")) return true;
-  const message = error.message;
-  if (typeof message === "string") {
-    const lowered = message.toLowerCase();
-    if (lowered.includes("unique constraint") || lowered.includes("constraint failed")) return true;
-  }
-  return false;
-}
-var LEDGER_SCAN_PAGE_LIMIT = 500;
-var LEDGER_SCAN_MAX_PAGES = 200;
-async function eventAlreadyExists(dedupeKey, deps = {}) {
-  const pollEvents = deps.pollEvents ?? ((options) => pollConductorEvents(options));
-  let sinceSeq = 1;
-  for (let page = 0; page < LEDGER_SCAN_MAX_PAGES; page += 1) {
-    let result;
-    try {
-      result = await pollEvents({ since_seq: sinceSeq, data_mode: "full", limit: LEDGER_SCAN_PAGE_LIMIT });
-    } catch {
-      return false;
-    }
-    for (const event of result.events) {
-      if (!event || typeof event !== "object") continue;
-      const data = event.data;
-      if (data && typeof data === "object") {
-        const details = data.details;
-        if (details && typeof details === "object" && details.dedupe_key === dedupeKey) {
-          return true;
-        }
-      }
-    }
-    if (result.count === 0 || result.next_seq <= sinceSeq) break;
-    sinceSeq = result.next_seq;
-  }
-  return false;
-}
-async function emitConductorEventIfNew(input, dimensions, deps = {}) {
-  const emitEvent = deps.emitEvent ?? emitConductorEvent;
-  const dedupeKey = makeProducerDedupeKey(dimensions);
-  if (await eventAlreadyExists(dedupeKey, deps)) {
-    return { emitted: false, reason: "duplicate" };
-  }
-  const eventId = makeStableProducerEventId(dedupeKey);
-  const existingData = input.data ?? {};
-  const existingDetails = existingData.details && typeof existingData.details === "object" && !Array.isArray(existingData.details) ? existingData.details : {};
-  const data = {
-    ...existingData,
-    details: { ...existingDetails, dedupe_key: dedupeKey }
-  };
-  try {
-    await emitEvent({ ...input, id: eventId, data });
-    return { emitted: true, event_id: eventId };
-  } catch (error) {
-    if (isDuplicateConstraintError2(error)) {
-      return { emitted: false, reason: "duplicate" };
-    }
-    throw error;
-  }
-}
-
-// src/conductor/git-producer.ts
+init_producer_ledger();
 var COMMITTED_REF_PHASE = "committed";
 function buildCommitCreatedEventInput(context, metadata) {
   const details = {
@@ -11350,6 +11636,7 @@ async function runReferenceTransactionHookProducer(args, deps = {}) {
 
 // src/conductor/doctor.ts
 init_store();
+import { spawnSync } from "node:child_process";
 async function inspectEpicTickSchedule(deps, orchestrateListOverride) {
   try {
     const schedRun = orchestrateListOverride ? null : await Promise.resolve().then(() => (init_schedule_run(), schedule_run_exports));
@@ -11416,6 +11703,46 @@ function inspectMcpProfile(env, epicTick) {
   }
   return { resolved_profile, conductor_context_detected, degraded, warnings };
 }
+function inspectLocalMerge(runCommand) {
+  const run = runCommand ?? ((cmd, args) => {
+    try {
+      const r = spawnSync(cmd, args, {
+        encoding: "utf8",
+        timeout: 1e4,
+        env: { ...process.env, GH_PROMPT_DISABLED: "1" }
+      });
+      return { status: r.status };
+    } catch {
+      return { status: null };
+    }
+  });
+  let gh_available = false;
+  let gh_authed = false;
+  try {
+    gh_available = run("gh", ["--version"]).status === 0;
+  } catch {
+    gh_available = false;
+  }
+  if (gh_available) {
+    try {
+      gh_authed = run("gh", ["auth", "status"]).status === 0;
+    } catch {
+      gh_authed = false;
+    }
+  }
+  const warnings = [];
+  if (!gh_available) {
+    warnings.push(
+      "`gh` is not installed or not on PATH. Local merge (policy_json.local_merge.enabled) cannot run; install the GitHub CLI to enable conductor-driven merges."
+    );
+  } else if (!gh_authed) {
+    warnings.push(
+      "`gh` is installed but not authenticated (`gh auth status` failed). Run `gh auth login` to grant the conductor merge permission; otherwise local merge will emit merge.failed/skip."
+    );
+  }
+  const degraded = !gh_available || !gh_authed;
+  return { gh_available, gh_authed, degraded, warnings };
+}
 async function buildConductorDoctorReport(deps = {}) {
   const doctorLedger = deps.doctorLedger ?? doctorConductorLedger;
   const inspectHooks = deps.inspectHooks ?? inspectConductorGitHooks;
@@ -11425,11 +11752,12 @@ async function buildConductorDoctorReport(deps = {}) {
     ledger: await doctorLedger(),
     git_hooks: inspectHooks(deps.hooksDeps),
     epic_tick: epicTick,
-    mcp_profile
+    mcp_profile,
+    local_merge: inspectLocalMerge(deps.runCommand)
   };
 }
 function formatConductorDoctorReport(report) {
-  const { ledger, git_hooks, epic_tick, mcp_profile } = report;
+  const { ledger, git_hooks, epic_tick, mcp_profile, local_merge } = report;
   const lines = [
     "Conductor ledger doctor",
     "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
@@ -11492,6 +11820,17 @@ function formatConductorDoctorReport(report) {
     lines.push("mcp profile warnings:");
     for (const w of mcp_profile.warnings) lines.push(`  - ${w}`);
   }
+  lines.push("");
+  lines.push("Local merge capability (optional, opt-in)");
+  lines.push("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  const ghTag = local_merge.gh_available ? local_merge.gh_authed ? "[OK]" : "[WARNING] not authenticated" : "[WARNING] not installed";
+  lines.push(`gh available:          ${local_merge.gh_available} ${ghTag}`);
+  lines.push(`gh authenticated:      ${local_merge.gh_authed}`);
+  lines.push(`degraded:              ${local_merge.degraded}`);
+  if (local_merge.warnings.length > 0) {
+    lines.push("local merge warnings:");
+    for (const w of local_merge.warnings) lines.push(`  - ${w}`);
+  }
   return lines.join("\n");
 }