@bridge_gpt/mcp-server 0.2.12 → 0.2.14

package/build/conductor/epic-runtime.js

@@ -20,6 +20,8 @@
 import { spawnSync } from "child_process";
 import { resolveConductorBridgeApiAccess, claimEpicSupervisionLease, fetchEpicRunState, advanceEpicTicketStatus, createEpicTicketStatus, recordEpicDispatch, transitionEpicDispatch, fetchParseStatus, triggerRepositoryParse, getEpicPlan, buildEpicDispatchKey, fetchEffectiveSupervisorConfig, fetchEffectiveSupervisorSetup, fetchPrReviewStatus, remediateEpicTicket, deletePullRequestBranch, transitionJiraStatus, } from "./bridge-api-client.js";
 import { processGateMetMerge } from "./supervisor-merge.js";
+import { makeLocalMergeExecutor, resolveLocalMergeMethod } from "./local-merge.js";
+import { emitConductorEventIfNew } from "./producer-ledger.js";
 import { rebuildObservedState, extractWorkerLiveness, } from "./epic-state.js";
 import { reconcileEpic } from "./epic-reconcile.js";
 import { buildSupervisorRemediationWorkerMessage } from "./supervisor-message-relay.js";
@@ -38,12 +40,15 @@ const DEFAULT_LEASE_TTL_SECONDS = 120;
 const DEFAULT_MAX_DRIFT_MS = 30_000;
 const DEFAULT_DISPATCH_KEY_TTL_SECONDS = 300; // independent of supervision lease TTL
 const ACTIVE_WORKER_STATUSES = new Set(["dispatched", "running"]);
+// ---------------------------------------------------------------------------
+// Module-private helpers
+// ---------------------------------------------------------------------------
 /**
- * Module-level transient map keyed by `"${epicKey}:${ticketKey}"`. Cleared on
- * parse completion or budget exhaustion. Process-restart safe: re-derived from
- * the parse lock status on the next tick.
+ * Source + producer tags for the durable `parse.triggered` marker that the
+ * parse-after-merge wait emits from the epic-tick process.
  */
-const parseWaitStateMap = new Map();
+const PARSE_WAIT_EVENT_SOURCE = "conductor-supervisor";
+const PARSE_WAIT_EVENT_PRODUCER = "epic-parse-wait";
 function defaultLeaseOwner() {
     return `epic-tick-${process.pid}`;
 }
@@ -220,17 +225,22 @@ export async function runEpicTick(options, deps = {}) {
             const settleMs = 5000;
             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();
+                // rebuildObservedState only surfaces a merge.succeeded whose run_id maps to
+                // a tracked dispatch, so mergeRunId is non-null and in the run-scoped
+                // localEvents read — binding the parse.triggered marker to it guarantees a
+                // later tick re-reads it. The merged PR head SHA (pre-merge) lives under
+                // the merge.* event's data.details; used only as an extra dedupe dimension.
+                const mergeRunId = mergeEvent.run_id ?? null;
+                const mergeDetails = mergeEvent.data?.details;
+                const mergeHeadSha = typeof mergeDetails?.head_sha === "string" ? mergeDetails.head_sha : undefined;
                 const revertSignal = () => {
                     const origStatus = epicRunState.ticket_statuses.find((ts) => ts.ticket_key === ticketKey)?.status ??
                         "running";
@@ -238,27 +248,72 @@ export async function runEpicTick(options, deps = {}) {
                     observed.unfolded_terminal_signals.splice(i, 1);
                     i -= 1;
                 };
-                const elapsedMs = nowFn() - new Date(signal.event.time).getTime();
-                // Budget exhaustion: escalate once, then permanently block
+                const currentPgStatus = epicRunState.ticket_statuses.find((ts) => ts.ticket_key === ticketKey)?.status ?? null;
+                // DURABLE wait state (replaces the former in-memory parseWaitStateMap, which
+                // was lost between stateless epic-tick processes → re-triggered the parse on
+                // every idle tick and never folded to `done`). The marker is a
+                // `parse.triggered` ledger event correlated to this ticket's dispatch run_id
+                // and emitted strictly after the merge — so its presence is the skew-free
+                // signal that the post-merge parse was already kicked off.
+                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;
+                // Budget exhaustion (measured from the durable merge.succeeded time):
+                // escalate once (gated on the durable Postgres status, not an in-memory
+                // flag) then block. A subsequent tick finds it already blocked and drops
+                // the signal without re-escalating or re-CASing.
                 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");
-                        // Let the signal remain so the reconcile pass CASes once to blocked
-                        continue;
-                    }
-                    else {
-                        // Already escalated: map to blocked and skip redundant CAS
-                        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");
+                    // Let the signal remain so the reconcile pass CASes once to blocked.
+                    continue;
+                }
+                if (!parseTriggeredEvent) {
+                    // No durable trigger for this merge yet — fire the parse and record the
+                    // marker, then hold at ready_for_review for a later tick to fold.
+                    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 ?? undefined,
+                            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;
                 }
-                // Poll the parse lock
+                // A durable parse.triggered exists for this merge — poll the live lock.
                 let parseStatusResult;
                 try {
                     parseStatusResult = await fetchParseStatusFn(access);
@@ -270,38 +325,26 @@ export async function runEpicTick(options, deps = {}) {
                     continue;
                 }
                 if (parseStatusResult.status === "in_progress") {
-                    pState.seenInProgress = true;
+                    // Parse still running — hold.
                     revertSignal();
                     continue;
                 }
-                // status === "idle" — evaluate race guard and completion
-                if (pState.seenInProgress) {
-                    // Previously observed in_progress: the parse finished normally
-                    parseWaitStateMap.delete(stateKey);
-                    continue; // let the signal proceed to CAS → done
-                }
-                if (pState.triggeredAt !== undefined) {
-                    const msSinceTrigger = nowFn() - pState.triggeredAt;
-                    if (msSinceTrigger < settleMs) {
-                        // Idle observed before the async job acquired its lock (race window)
-                        revertSignal();
-                        continue;
-                    }
-                    // Settle window elapsed without in_progress: treat as instantaneous completion
-                    parseWaitStateMap.delete(stateKey);
-                    continue; // let the signal proceed to CAS → done
-                }
-                // No trigger yet — fire it now
-                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`);
+                // status === "idle". If the marker is younger than the settle window, the
+                // async parse may not have acquired its lock yet (idle is a false negative)
+                // — hold one more tick. Past the settle window, idle means the post-merge
+                // parse has completed (or finished instantly), so let the merge.succeeded
+                // signal proceed to CAS → done.
+                //
+                // KNOWN LIMITATION: /jira/parse-status only reports {in_progress, idle} —
+                // it cannot distinguish a FAILED parse from a completed one, so an instant
+                // parse failure folds to `done` here. Pre-existing; tracked as P2 (surface
+                // a parse failure/last_error from parse-status).
+                const msSinceTrigger = nowFn() - new Date(parseTriggeredEvent.time).getTime();
+                if (msSinceTrigger < settleMs) {
+                    revertSignal();
+                    continue;
                 }
-                revertSignal();
+                // Completed: do not revert — the signal proceeds to CAS → done.
             }
         }
         // Step 4: Fetch + assert plan integrity (only if fetchPlan injected)
@@ -486,7 +529,27 @@ export 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) => {
+                    // F4: when policy_json.local_merge.enabled is set (opt-in, default OFF)
+                    // and the caller did not inject a processMerge stub, run the real merge
+                    // pipeline with a LOCAL executor swapped in for the backend route — the
+                    // merge happens here using the agent's own `gh` credentials, so the
+                    // hosted backend never needs global GitHub write scope. Otherwise the
+                    // default backend-route path is unchanged for all existing users.
+                    if (deps.processMerge === undefined) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        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, reason) => escalateOnce(ek, reason),
                 log,
@@ -812,12 +875,21 @@ export 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,
+                // 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,

package/build/conductor/epic-state.js

@@ -193,6 +193,14 @@ export function rebuildObservedState(postgresState, events, _now) {
     const pendingMergeEvents = [];
     // Track which tickets already have a folded signal (one override per ticket)
     const foldedTicketKeys = new Set();
+    // Track which tickets already have a gate.met queued for merge this tick, so a
+    // second gate.met for the same ticket never double-enqueues. Distinct from
+    // foldedTicketKeys: a prior run.stopped fold (→ ready_for_review) must NOT
+    // suppress a later gate.met's merge enqueue (both map to ready_for_review;
+    // only gate.met enqueues a merge, and the worker frequently emits run.stopped
+    // BEFORE a post-hoc gate.met). Only a fold to a non-mergeable status (blocked)
+    // suppresses the merge — handled via the effective-status check below.
+    const mergeQueuedTicketKeys = new Set();
     // BAPI-441: per-ticket latest blocking reason (ci.failed / review.changes_requested),
     // tracked across the full ledger so an already-blocked ticket still carries a
     // reason for the remediation pass to frame the nudge.
@@ -233,12 +241,19 @@ export function rebuildObservedState(postgresState, events, _now) {
         const postgresStatus = ticketStatusMap.get(ticketKey) ?? "planned";
         if (!isNonTerminal(postgresStatus))
             continue;
-        // Only queue for merge actioning if this ticket hasn't already been folded
-        // this tick. Without this guard, two gate.met events for the same ticket
-        // would both enqueue, and a ci.failed → gate.met sequence would enqueue a
-        // merge action for a ticket whose effective status is "blocked".
-        if (event.type === "gate.met" && !foldedTicketKeys.has(ticketKey)) {
+        // Queue gate.met for merge actioning unless (a) this ticket's effective
+        // status this tick is non-mergeable ("blocked" — e.g. a ci.failed that
+        // folded earlier in the same batch, or a Postgres-blocked ticket whose
+        // ci.failed re-folds every tick), or (b) a gate.met for it is already
+        // queued. `postgresStatus` already reflects same-tick folds (the loop
+        // mutates `ticketStatusMap`), so a prior run.stopped fold leaves it
+        // "ready_for_review" and the merge proceeds — fixing the deadlock where a
+        // worker's run.stopped (lower seq) suppressed a later operator/CI gate.met.
+        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);

package/build/conductor/local-merge.js

@@ -0,0 +1,212 @@
+/**
+ * Client-side (local) conductor merge executor (F4).
+ *
+ * Performs the GitHub merge in the epic-tick process using the agent's OWN
+ * granted `gh` credentials, instead of the hosted Bridge API merge route (which
+ * would require the backend to hold global GitHub write scope — the reason a
+ * smoke-test merge failed with `provider_unauthorized`). Opt-in only: the runtime
+ * selects this executor when `policy_json.local_merge.enabled === true`.
+ *
+ * It mirrors the backend merge guard's decision order — approval precondition →
+ * re-read PR head (drift / not-open guard) → revalidate required CI for the EXACT
+ * head SHA → provider merge — and returns the SAME `merge.*` ledger events the
+ * backend route returns, so the rest of {@link processGateMetMerge} is unchanged.
+ *
+ * Subprocess safety: argument arrays (never a shell string), a validated numeric
+ * PR number, a merge method from a fixed allowlist, `GH_PROMPT_DISABLED` to avoid
+ * interactive hangs, and no token/secret ever logged. Default OFF everywhere.
+ */
+import { spawnSync } from "child_process";
+import { pollCiChecksForCommit, } from "./bridge-api-client.js";
+const MERGE_METHODS = new Set(["squash", "merge", "rebase"]);
+/**
+ * Hard wall-clock cap on every `gh` subprocess. The epic-tick runs in a single
+ * stateless process with no separate scheduler thread — a `gh` call that hangs
+ * (network stall, an auth prompt that slips past GH_PROMPT_DISABLED) would block
+ * the Node event loop indefinitely, freezing the whole tick. Killing at 60s
+ * yields a `timedOut` result the executor maps to a distinct `*_timeout` reason.
+ */
+const DEFAULT_COMMAND_TIMEOUT_MS = 60_000;
+/** Coerce an untrusted method value to a safe allowlisted method (default squash). */
+export function resolveLocalMergeMethod(value) {
+    return typeof value === "string" && MERGE_METHODS.has(value)
+        ? value
+        : "squash";
+}
+function defaultRunCommand(cmd, args, env) {
+    const result = spawnSync(cmd, args, {
+        encoding: "utf8",
+        env: { ...process.env, ...env },
+        timeout: DEFAULT_COMMAND_TIMEOUT_MS,
+    });
+    // On timeout spawnSync kills the child (status: null, signal: "SIGTERM") and
+    // sets `error.code === "ETIMEDOUT"`. Surface that as a first-class flag.
+    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,
+    };
+}
+/**
+ * Decide whether every required CI check is green for the polled head SHA. When
+ * the gate lists no required checks, fall back to the poll's `all_passed` flag.
+ * Defensive against the poll response's exact shape: a check counts as green if
+ * any of `conclusion==="success"`, `status==="success"`, `green===true`, or
+ * `bucket==="pass"`.
+ */
+export function allRequiredChecksGreen(pollResponse, requiredChecks) {
+    if (pollResponse === null || typeof pollResponse !== "object")
+        return false;
+    let obj = pollResponse;
+    // pollCiChecksForCommit returns the `{available, reason, action, detail}`
+    // envelope; checks/all_passed live under `detail`. Unwrap it (envelope-
+    // tolerant, mirroring normalizeCiSnapshot) — reading the top level alone made
+    // every required check look missing → merge always failed ci_not_green.
+    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 = 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)));
+}
+/**
+ * Build a `(access, request) => Promise<ConductorMergeResponse>` that performs the
+ * merge locally via `gh`. Drop-in replacement for `mergePullRequestForGate` used
+ * by {@link processGateMetMerge}'s `merge` seam.
+ */
+export function makeLocalMergeExecutor(options = {}, deps = {}) {
+    const method = resolveLocalMergeMethod(options.method);
+    const run = deps.runCommand ?? defaultRunCommand;
+    const pollCi = deps.pollCi ?? pollCiChecksForCommit;
+    // Non-interactive + no-noise env for gh; the caller's env (incl. any token)
+    // is overlaid first, then the safety pins.
+    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 },
+        ]);
+        // 1. Approval precondition — never merge when approval is required.
+        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,
+                },
+            ]);
+        }
+        // 2. Re-read PR head + open-state (head-drift / closed guard).
+        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");
+        }
+        // 3. Revalidate required CI green for the exact head SHA.
+        let pollResponse;
+        try {
+            pollResponse = await pollCi(access, expectedSha);
+        }
+        catch {
+            return fail("ci_poll_failed");
+        }
+        if (!allRequiredChecksGreen(pollResponse, requiredChecks))
+            return fail("ci_not_green");
+        // 4. Provider merge.
+        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 },
+            ]);
+        }
+        // 5. Best-effort resolve the squash/merge commit SHA for the audit trail.
+        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 {
+                /* best-effort only */
+            }
+        }
+        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 },
+        ]);
+    };
+}

package/build/conductor/pr-ci-producer.js

@@ -9,7 +9,7 @@
  * check. All event types come from the existing conductor taxonomy and use only
  * allowlisted top-level data keys.
  */
-import { GIT_CI_PRODUCER, } from "./git-ci-types.js";
+import { GIT_CI_PRODUCER, REVIEW_STATE, } from "./git-ci-types.js";
 import { evaluateDoneGate, normalizeCiSnapshot, parseDoneGateConfig } from "./done-gate.js";
 import { observeReviewWithResolved } from "./pr-review-producer.js";
 import { fetchEffectiveSupervisorSetup, fetchActiveEpicRuns, fetchEpicRunState, pollCiChecksForCommit, resolveConductorBridgeApiAccess, } from "./bridge-api-client.js";
@@ -455,7 +455,17 @@ export async function observePrCiFromPollResponse(commitRef, pollResponse, deps
                 rawConfig = undefined;
             }
             const gateConfig = parseDoneGateConfig(rawConfig);
-            if (gateConfig.enabled && gateConfig.valid) {
+            // F6: this poll-driven path observes CI only — it has NO review snapshot
+            // (unlike observeWithResolved, which fetches one via observeReviewWithResolved).
+            // A composite gate with any review_state condition can therefore never be
+            // satisfied here and would only fail closed silently. Rather than pretend to
+            // be a gate path, refuse to evaluate review-gated configs and defer to
+            // `wait_for_done_gate` (the complete observer). CI-only gates still emit here.
+            const requiresReview = gateConfig.conditions.some((c) => c.type === REVIEW_STATE);
+            if (gateConfig.enabled && gateConfig.valid && requiresReview) {
+                result.reason = "review-gated config: gate.met deferred to wait_for_done_gate (poll path is CI-only)";
+            }
+            if (gateConfig.enabled && gateConfig.valid && !requiresReview) {
                 const evaluation = evaluateDoneGate(gateConfig, binding, snapshot, now());
                 if (evaluation.met) {
                     result.gate_met = true;

package/build/conductor/store.js

@@ -180,11 +180,14 @@ export function resolveConductorStoreConfig(env = process.env) {
  * event type to the same CHECK vocabulary. Bumped to 6 in BAPI-445 because the
  * pre-implementation spec re-review verdict feature adds the `spec_review.passed`
  * and `spec_review.changes_requested` event types to the same `events.type`
- * CHECK vocabulary. Older ledgers stamped at a lower version are rebuilt by
- * {@link migrateConductorSchemaIfNeeded} so their CHECK clause accepts the
- * current taxonomy.
+ * CHECK vocabulary. Bumped to 7 because the durable parse-after-merge fold adds
+ * the `parse.triggered` event type to the same `events.type` CHECK vocabulary
+ * (replacing the in-memory parse-wait map so stateless epic-tick invocations can
+ * fold a merged ticket to `done`). Older ledgers stamped at a lower version are
+ * rebuilt by {@link migrateConductorSchemaIfNeeded} so their CHECK clause accepts
+ * the current taxonomy.
  */
-export const CURRENT_CONDUCTOR_SCHEMA_VERSION = 6;
+export const CURRENT_CONDUCTOR_SCHEMA_VERSION = 7;
 /** Render the taxonomy `CHECK (type IN (...))` clause from the single source of truth. */
 function buildTypeCheckClause() {
     const list = SEMANTIC_EVENT_TYPES.map((t) => `'${t}'`).join(", ");

package/build/conductor/taxonomy.js

@@ -43,6 +43,10 @@ export const SEMANTIC_EVENT_TYPES = [
     // mis-folds a spec-review outcome as the implementation PR's review state.
     "spec_review.passed",
     "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",
 ];
 /**
  * Type guard: returns `true` only when `value` is one of the exact taxonomy