@bridge_gpt/mcp-server 0.2.10 → 0.2.12

package/build/conductor/cli.js

@@ -336,13 +336,13 @@ export function parseEmitEventArgs(argv, deps = {}) {
     return { input, json: bools.has("--json"), help: false };
 }
 /** Run the `emit-event` command. Prints the inserted event summary. */
-export function runEmitEventCommand(argv, deps = {}) {
+export async function runEmitEventCommand(argv, deps = {}) {
     const parsed = parseEmitEventArgs(argv, deps);
     if (parsed.help) {
         console.log(getConductorUsage());
         return 0;
     }
-    const result = emitConductorEvent(parsed.input);
+    const result = await emitConductorEvent(parsed.input);
     if (parsed.json) {
         console.log(JSON.stringify(result));
     }
@@ -442,13 +442,13 @@ export function parseSendMessageArgs(argv, deps = {}) {
  * Run `send-message`. Prints compact JSON when `--json` is set; otherwise a
  * sanitized human summary (message id / status / type only — NEVER the payload).
  */
-export function runSendMessageCommand(argv, deps = {}) {
+export async function runSendMessageCommand(argv, deps = {}) {
     const parsed = parseSendMessageArgs(argv, deps);
     if (parsed.help) {
         console.log(getConductorUsage());
         return 0;
     }
-    const result = sendWorkerMessage(parsed.input);
+    const result = await sendWorkerMessage(parsed.input);
     if (parsed.json) {
         console.log(JSON.stringify(result));
     }
@@ -495,13 +495,13 @@ export function parseCheckMessagesArgs(argv) {
  * Run `check-messages`. Prints compact JSON when `--json` is set; otherwise a
  * sanitized human summary (counts + per-message id/type only — NEVER payloads).
  */
-export function runCheckMessagesCommand(argv) {
+export async function runCheckMessagesCommand(argv) {
     const parsed = parseCheckMessagesArgs(argv);
     if (parsed.help) {
         console.log(getConductorUsage());
         return 0;
     }
-    const result = checkWorkerMessages(parsed.input);
+    const result = await checkWorkerMessages(parsed.input);
     if (parsed.json) {
         console.log(JSON.stringify(result));
         return 0;
@@ -590,7 +590,7 @@ export function parseGitHookArgs(argv) {
  * warning) so a conductor producer failure never blocks the git commit/ref update
  * the hook is attached to.
  */
-export function runGitHookCommand(argv) {
+export async function runGitHookCommand(argv) {
     let parsed;
     try {
         parsed = parseGitHookArgs(argv);
@@ -602,7 +602,7 @@ export function runGitHookCommand(argv) {
     }
     try {
         if (parsed.subcommand === "post-commit") {
-            runPostCommitHookProducer();
+            await runPostCommitHookProducer();
             return 0;
         }
         // reference-transaction: read the captured updates from the stdin file.
@@ -625,7 +625,7 @@ export function runGitHookCommand(argv) {
                 }
             }
         }
-        runReferenceTransactionHookProducer({ phase: parsed.phase ?? "", stdin });
+        await runReferenceTransactionHookProducer({ phase: parsed.phase ?? "", stdin });
         return 0;
     }
     catch {
@@ -996,13 +996,13 @@ export async function runSuperviseCommand(argv) {
     return result.exit_code;
 }
 /** Run the explicit `purge` command. Prints deleted row counts. */
-export function runPurgeCommand(argv) {
+export async function runPurgeCommand(argv) {
     const { bools } = tokenizeFlags(argv, new Set(), DIAGNOSTIC_BOOL_FLAGS);
     if (bools.has("--help")) {
         console.log(getConductorUsage());
         return 0;
     }
-    const result = purgeConductorLedger();
+    const result = await purgeConductorLedger();
     if (bools.has("--json")) {
         console.log(JSON.stringify(result));
         return 0;
@@ -1035,7 +1035,7 @@ export async function runConductorCli(argv) {
     try {
         switch (parsed.command) {
             case "emit-event":
-                return runEmitEventCommand(parsed.argv);
+                return await runEmitEventCommand(parsed.argv);
             case "supervise":
                 return await runSuperviseCommand(parsed.argv);
             case "epic-tick":
@@ -1045,17 +1045,17 @@ export async function runConductorCli(argv) {
             case "epic-status":
                 return await runEpicStatusCommand(parsed.argv);
             case "send-message":
-                return runSendMessageCommand(parsed.argv);
+                return await runSendMessageCommand(parsed.argv);
             case "check-messages":
-                return runCheckMessagesCommand(parsed.argv);
+                return await runCheckMessagesCommand(parsed.argv);
             case "doctor":
                 return await runDoctorCommand(parsed.argv);
             case "purge":
-                return runPurgeCommand(parsed.argv);
+                return await runPurgeCommand(parsed.argv);
             case "install-git-hooks":
                 return runInstallGitHooksCommand(parsed.argv);
             case "git-hook":
-                return runGitHookCommand(parsed.argv);
+                return await runGitHookCommand(parsed.argv);
             default:
                 console.error('Error: Unknown command. Run "conductor --help" for usage.');
                 return 1;

package/build/conductor/doctor.js

@@ -116,7 +116,7 @@ export async function buildConductorDoctorReport(deps = {}) {
     const epicTick = await inspectEpicTickSchedule(deps.scheduleDeps, deps.orchestrateList);
     const mcp_profile = inspectMcpProfile(deps.env ?? process.env, epicTick);
     return {
-        ledger: doctorLedger(),
+        ledger: await doctorLedger(),
         git_hooks: inspectHooks(deps.hooksDeps),
         epic_tick: epicTick,
         mcp_profile,

package/build/conductor/epic-reconcile.js

@@ -17,7 +17,7 @@
  * All durable mutations go through injected seams so the logic is testable
  * without real network, ledger, or terminal access.
  */
-import { computeReadySet, decideRemediation } from "./epic-state.js";
+import { computeReadySet, decideRemediation, DEFAULT_MAX_SPEC_REVIEW_ATTEMPTS } from "./epic-state.js";
 import { extractMergeActionIdentityFromGateEvent } from "./merge-ledger.js";
 // ---------------------------------------------------------------------------
 // reconcileEpic
@@ -84,21 +84,26 @@ export async function reconcileEpic(access, observed, plan, deps, supervisorConf
     const readySet = computeReadySet(plan, observed.ticket_statuses);
     // Step 3: Dispatch each ready ticket idempotently.
     //
-    // NOTE (BAPI-442): an earlier draft performed a synchronous two-phase
-    // planned → ready_for_review → ready spec re-review here — it spawned
-    // /review-ticket and then dispatched implementation in the SAME tick. That did
-    // not actually gate implementation on the review (the verdict was never
-    // consulted and the review run_id was discarded), and it overloaded the
-    // BAPI-436 "ready_for_review" (awaiting-merge) state, leaving a liveness gap
-    // if the conductor crashed between the CAS and the dispatch. That path has
-    // been removed. `auto_rereview_enabled` is reserved until real review-gating —
-    // a distinct `reviewing` status, review-run correlation, multi-tick re-entry,
-    // and a spec-review verdict signal — is built (BAPI-445). Until then a ready
-    // ticket dispatches implementation directly regardless of the flag.
+    // BAPI-445 — pre-implementation spec re-review sequencing gate (Phase 1). When
+    // `auto_rereview_enabled` is on and the review seam is wired, a `planned` ready
+    // ticket must first pass a spec re-review: this loop advances it
+    // planned → reviewing, spawns the review run under a `:review` dispatch role,
+    // correlates its run_id, and STOPS — implementation does NOT dispatch in the
+    // same tick (honouring the product directive: "wait for review to complete
+    // before implementation begins"). The reviewing → ready (or → blocked) fold
+    // happens on a later tick once the review completes/votes; only THEN does this
+    // loop dispatch implementation. Gating only on `planned` (not `ready`) is
+    // deliberate: a `ready` ticket already passed review (reviewing → ready) or the
+    // flag is off, so re-gating it would loop forever.
     for (const ticketKey of readySet) {
-        if (supervisorConfig?.auto_rereview_enabled) {
-            deps.log(`[epic-reconcile] auto_rereview_enabled is set but review-gating is not yet ` +
-                `implemented (BAPI-445); dispatching ${ticketKey} directly`);
+        const currentStatus = observed.ticket_statuses.get(ticketKey) ?? "planned";
+        if (supervisorConfig?.auto_rereview_enabled &&
+            deps.dispatchReviewSeam &&
+            currentStatus === "planned") {
+            await enterSpecReview(observed, deps, result, escalate, ticketKey);
+            // Either the review was dispatched, or a benign race/failure was logged;
+            // in every case implementation must NOT dispatch this tick.
+            continue;
         }
         let claimResult;
         try {
@@ -155,6 +160,115 @@ export async function reconcileEpic(access, observed, plan, deps, supervisorConf
             result.warnings.push(`correlate-failed for ${ticketKey}: ${safeMsg}`);
         }
     }
+    // Step 3.2: Reviewing recovery (BAPI-445 Phase 1 re-entry). computeReadySet
+    // never surfaces a `reviewing` ticket (it is mid-flight, not ready), so a
+    // ticket whose spec-review run died before completing would be stranded
+    // forever without this pass. Iterate `reviewing` tickets explicitly (mirroring
+    // how the remediation pass iterates `blocked` tickets): if the review run is
+    // dead and the dedicated review-attempt cap is not yet exhausted, reclaim an
+    // attempt-scoped `:review` dispatch key and re-dispatch the review; once the
+    // cap is exhausted, escalate. This uses its OWN attempt counter — it never
+    // touches the BAPI-441 remediation budget.
+    if (supervisorConfig?.auto_rereview_enabled &&
+        deps.dispatchReviewSeam &&
+        deps.readReviewWorkerLiveness) {
+        const dispatchReviewSeam = deps.dispatchReviewSeam;
+        const readReviewWorkerLiveness = deps.readReviewWorkerLiveness;
+        const maxReviewAttempts = supervisorConfig.max_spec_review_attempts ?? DEFAULT_MAX_SPEC_REVIEW_ATTEMPTS;
+        for (const [ticketKey, status] of observed.ticket_statuses) {
+            if (status !== "reviewing")
+                continue;
+            try {
+                const liveness = await readReviewWorkerLiveness(observed.epic_key, ticketKey);
+                if (liveness.alive)
+                    continue; // review still running — wait across ticks
+                const priorAttempts = deps.countReviewAttempts
+                    ? deps.countReviewAttempts(ticketKey)
+                    : 0;
+                if (priorAttempts >= maxReviewAttempts) {
+                    await escalate(observed.epic_key, `spec-review-liveness-exhausted:${ticketKey}`);
+                    deps.log(`[epic-reconcile] spec-review liveness exhausted for ${ticketKey} ` +
+                        `(attempts=${priorAttempts} max=${maxReviewAttempts}) → escalate`);
+                    continue;
+                }
+                // Reclaim a fresh attempt-scoped review dispatch key. `priorAttempts`
+                // (>= 1 once the initial review dispatched) doubles as the next attempt
+                // index, so the key differs from every prior review run's key.
+                const attempt = priorAttempts;
+                let claim;
+                try {
+                    claim = await deps.claimDispatchKey(observed.epic_key, ticketKey, observed.plan_version, "review", attempt);
+                }
+                catch (err) {
+                    const safeMsg = err instanceof Error ? err.constructor.name : "claim error";
+                    result.warnings.push(`review-reclaim-error for ${ticketKey}: ${safeMsg}`);
+                    continue;
+                }
+                if (!claim.ok) {
+                    result.warnings.push(`review-dispatch-key lease-held for ${ticketKey}`);
+                    continue;
+                }
+                if (claim.kind !== "claimed") {
+                    if (claim.kind === "already-exists" && claim.dispatch.run_id === null) {
+                        result.warnings.push(`review-dispatch-orphan: ${ticketKey} has pending review dispatch key with no run_id`);
+                        await escalate(observed.epic_key, `dispatch-orphan:${ticketKey}`);
+                    }
+                    continue;
+                }
+                const dispatchKey = claim.dispatch.dispatch_key;
+                let runId;
+                try {
+                    runId = await dispatchReviewSeam(observed.epic_key, ticketKey, attempt);
+                }
+                catch (err) {
+                    const safeMsg = err instanceof Error ? err.constructor.name : "dispatch error";
+                    result.warnings.push(`review-redispatch-failed for ${ticketKey}: ${safeMsg}`);
+                    continue;
+                }
+                try {
+                    await deps.correlateRunId(dispatchKey, runId);
+                    deps.log(`[epic-reconcile] re-dispatched spec re-review for ${ticketKey} ` +
+                        `run_id=${runId} attempt=${attempt}`);
+                }
+                catch (err) {
+                    const safeMsg = err instanceof Error ? err.constructor.name : "correlate error";
+                    result.warnings.push(`review-correlate-failed for ${ticketKey}: ${safeMsg}`);
+                }
+            }
+            catch (err) {
+                const safeMsg = err instanceof Error ? err.constructor.name : "reviewing recovery error";
+                result.warnings.push(`reviewing-recovery-error for ${ticketKey}: ${safeMsg}`);
+            }
+        }
+    }
+    // Step 3.4: Spec-review verdict gate (BAPI-445 Phase 2). A ticket blocked by a
+    // changes-requested SPEC review is a spec problem, not a code bug: escalate it
+    //
+    // NOTE: this block is reachable only once the verdict EMISSION primitive
+    // (`emitSpecReviewVerdict` in spec-review-producer.ts) is wired into the
+    // review-ticket completion flow so a `spec_review.changes_requested` event is
+    // folded to `blocked` with this reason. Until that Phase 2 integration lands,
+    // no ticket carries the `spec_review.changes_requested` blocked reason and this
+    // pass is a no-op. That is FAIL-SAFE: a completed review with no verdict does
+    // NOT advance `reviewing → ready` (epic-state filters review-run incidental
+    // terminals), so implementation never proceeds without an explicit pass —
+    // a stranded `reviewing` ticket is escalated by the recovery branch above.
+    // once for operator attention and EXCLUDE it from the BAPI-441 remediation pass
+    // below so it never spends the implementation remediation budget (no nudge, no
+    // redispatch, no budget counter increment). Runs independently of the
+    // remediation seams so a spec rejection is always surfaced.
+    const specRejectedTickets = new Set();
+    for (const [ticketKey, status] of observed.ticket_statuses) {
+        if (status !== "blocked")
+            continue;
+        if (observed.ticket_blocked_reasons?.get(ticketKey) !== "spec_review.changes_requested") {
+            continue;
+        }
+        specRejectedTickets.add(ticketKey);
+        await escalate(observed.epic_key, `spec-review-rejected:${ticketKey}`);
+        deps.log(`[epic-reconcile] spec-review changes-requested for ${ticketKey} → escalate ` +
+            `(remediation budget bypassed)`);
+    }
     // Step 3.5: Remediation pass (BAPI-441) — re-act on blocked tickets under
     // budget. Keyed off the folded "blocked" status + per-ticket counters, NOT a
     // computeReadySet change (the ready-set still returns only planned tickets).
@@ -173,6 +287,10 @@ export async function reconcileEpic(access, observed, plan, deps, supervisorConf
         for (const [ticketKey, status] of observed.ticket_statuses) {
             if (status !== "blocked")
                 continue;
+            // BAPI-445: a spec-review rejection was already escalated in Step 3.4 and
+            // must never enter the implementation remediation budget. Skip it here.
+            if (specRejectedTickets.has(ticketKey))
+                continue;
             // Per-ticket try/catch so a single ticket's failure never aborts the pass.
             try {
                 const counters = observed.ticket_remediation_counters?.get(ticketKey) ?? {
@@ -192,7 +310,10 @@ export async function reconcileEpic(access, observed, plan, deps, supervisorConf
                 const attemptKind = decision;
                 // The folding reason frames the nudge (message type + digest). Default to
                 // the review path when the ledger no longer carries the blocking event.
-                const reason = observed.ticket_blocked_reasons?.get(ticketKey) ?? "review.changes_requested";
+                // spec_review.changes_requested is impossible here (skipped above) but
+                // narrow explicitly so the remediation seams keep their tight reason type.
+                const blockedReason = observed.ticket_blocked_reasons?.get(ticketKey);
+                const reason = blockedReason === "ci.failed" ? "ci.failed" : "review.changes_requested";
                 // A nudge needs a worker to address it to. The liveness scan already
                 // resolved the worker id from the same heartbeat that proved the worker
                 // alive; if it is missing we cannot relay, so skip BEFORE recording an
@@ -254,3 +375,79 @@ export async function reconcileEpic(access, observed, plan, deps, supervisorConf
     // Step 5: Post-action waits are scheduled inline above per-dispatch
     return result;
 }
+// ---------------------------------------------------------------------------
+// enterSpecReview (BAPI-445 Phase 1 — planned → reviewing + spawn review run)
+// ---------------------------------------------------------------------------
+/**
+ * Advance a `planned` ready ticket into the pre-implementation spec re-review:
+ * CAS planned → reviewing, claim the `:review` dispatch key, spawn the review
+ * run, and correlate its run_id. Every failure is absorbed as a per-ticket
+ * warning so the rest of the reconcile pass still runs.
+ *
+ * Deliberately does NOT mutate the local `observed.ticket_statuses` map: the CAS
+ * is durable in Postgres (the NEXT tick's snapshot shows `reviewing`), and
+ * leaving the local status as `planned` keeps the same-tick reviewing-recovery
+ * pass from mistaking this freshly-spawned review for a stranded one and
+ * double-dispatching it.
+ */
+async function enterSpecReview(observed, deps, result, escalate, ticketKey) {
+    const dispatchReviewSeam = deps.dispatchReviewSeam;
+    if (!dispatchReviewSeam)
+        return; // caller-guarded; defensive
+    // CAS planned → reviewing (durable). Idempotency: if another tick already
+    // advanced the ticket, the CAS conflicts and we bail benignly.
+    const rowVersion = observed.ticket_row_versions.get(ticketKey) ?? 0;
+    let cas;
+    try {
+        cas = await deps.casTicketStatus(observed.epic_key, ticketKey, rowVersion, "reviewing", observed.plan_version);
+    }
+    catch (err) {
+        const safeMsg = err instanceof Error ? err.constructor.name : "cas error";
+        result.warnings.push(`review-cas-error for ${ticketKey}: ${safeMsg}`);
+        return;
+    }
+    if (!cas.ok) {
+        result.warnings.push(`review-cas-conflict advancing ${ticketKey} → reviewing`);
+        return;
+    }
+    // Claim the :review dispatch key (attempt 0), then spawn + correlate.
+    let claim;
+    try {
+        claim = await deps.claimDispatchKey(observed.epic_key, ticketKey, observed.plan_version, "review", 0);
+    }
+    catch (err) {
+        const safeMsg = err instanceof Error ? err.constructor.name : "claim error";
+        result.warnings.push(`review-claim-error for ${ticketKey}: ${safeMsg}`);
+        return;
+    }
+    if (!claim.ok) {
+        result.warnings.push(`review-dispatch-key lease-held for ${ticketKey}`);
+        return;
+    }
+    if (claim.kind !== "claimed") {
+        if (claim.kind === "already-exists" && claim.dispatch.run_id === null) {
+            result.warnings.push(`review-dispatch-orphan: ${ticketKey} has pending review dispatch key with no run_id`);
+            await escalate(observed.epic_key, `dispatch-orphan:${ticketKey}`);
+        }
+        return;
+    }
+    const dispatchKey = claim.dispatch.dispatch_key;
+    let runId;
+    try {
+        runId = await dispatchReviewSeam(observed.epic_key, ticketKey, 0);
+    }
+    catch (err) {
+        const safeMsg = err instanceof Error ? err.constructor.name : "dispatch error";
+        result.warnings.push(`review-dispatch-failed for ${ticketKey}: ${safeMsg}`);
+        return;
+    }
+    try {
+        await deps.correlateRunId(dispatchKey, runId);
+        deps.log(`[epic-reconcile] dispatched spec re-review for ${ticketKey} ` +
+            `run_id=${runId} (planned → reviewing; implementation deferred)`);
+    }
+    catch (err) {
+        const safeMsg = err instanceof Error ? err.constructor.name : "correlate error";
+        result.warnings.push(`review-correlate-failed for ${ticketKey}: ${safeMsg}`);
+    }
+}

package/build/conductor/epic-runtime.js

@@ -75,6 +75,9 @@ export async function runEpicTick(options, deps = {}) {
     const errorLog = deps.errorLog ?? ((msg) => process.stderr.write(`${msg}\n`));
     const escalateOnce = deps.escalateOnce ?? defaultEscalateOnce;
     const dispatchSeam = deps.dispatchSeam ?? defaultDispatchSeam;
+    // BAPI-445: optional review dispatch seam. When absent the spec re-review
+    // sequencing gate stays off (a ready ticket dispatches implementation directly).
+    const dispatchReviewSeamFn = deps.dispatchReviewSeam;
     const processMergeFn = deps.processMerge ?? processGateMetMerge;
     const postActionWaitSeam = deps.postActionWaitSeam ?? defaultPostActionWaitSeam;
     const fetchLocalEvents = deps.fetchLocalEvents ??
@@ -203,7 +206,7 @@ export async function runEpicTick(options, deps = {}) {
         const dispatchedRunIds = epicRunState.dispatches
             .map((d) => d.run_id)
             .filter((rid) => typeof rid === "string" && rid.length > 0);
-        const localEvents = fetchLocalEvents(epic_key, dispatchedRunIds);
+        const localEvents = await fetchLocalEvents(epic_key, dispatchedRunIds);
         const observed = rebuildObservedState(epicRunState, localEvents, nowFn());
         workerCount = [...observed.ticket_statuses.values()].filter((s) => ACTIVE_WORKER_STATUSES.has(s)).length;
         // Step 3.5: Run post-action waits (parse-after-merge)
@@ -386,19 +389,35 @@ export async function runEpicTick(options, deps = {}) {
                 if (ts.dispatch_run_id)
                     ticketRunIdMap.set(ts.ticket_key, ts.dispatch_run_id);
             }
+            // BAPI-445: split dispatch records by role. `:review`-suffixed dispatch keys
+            // are the pre-implementation spec re-review runs; they must be EXCLUDED from
+            // the implementation liveness map (so BAPI-441 remediation liveness only ever
+            // targets the implementation run) and tracked in a separate review map +
+            // per-ticket attempt counter consumed by the reviewing recovery branch.
             const latestDispatchByTicket = new Map();
+            const reviewLatestDispatchByTicket = new Map();
+            const reviewAttemptCounts = new Map();
             for (const d of epicRunState.dispatches) {
+                const isReview = d.dispatch_key.endsWith(":review");
+                if (isReview) {
+                    reviewAttemptCounts.set(d.ticket_key, (reviewAttemptCounts.get(d.ticket_key) ?? 0) + 1);
+                }
                 if (!d.run_id)
                     continue;
                 const updatedAt = new Date(d.updated_at).getTime();
-                const prev = latestDispatchByTicket.get(d.ticket_key);
+                const target = isReview ? reviewLatestDispatchByTicket : latestDispatchByTicket;
+                const prev = target.get(d.ticket_key);
                 if (!prev || updatedAt >= prev.updatedAt) {
-                    latestDispatchByTicket.set(d.ticket_key, { runId: d.run_id, updatedAt });
+                    target.set(d.ticket_key, { runId: d.run_id, updatedAt });
                 }
             }
             for (const [tk, info] of latestDispatchByTicket) {
                 ticketRunIdMap.set(tk, info.runId);
             }
+            const reviewTicketRunIdMap = new Map();
+            for (const [tk, info] of reviewLatestDispatchByTicket) {
+                reviewTicketRunIdMap.set(tk, info.runId);
+            }
             const resolvePrNumber = (ticketKey) => {
                 const raw = prBindings[ticketKey];
                 if (typeof raw === "number" && Number.isInteger(raw) && raw >= 1)
@@ -435,13 +454,30 @@ export async function runEpicTick(options, deps = {}) {
                         planVersion,
                     });
                 },
-                claimDispatchKey: async (ek, tk, planVersion) => recordEpicDispatch(access, {
+                claimDispatchKey: async (ek, tk, planVersion, role, attempt = 0) => recordEpicDispatch(access, {
                     epicKey: ek,
                     ticketKey: tk,
                     planVersion,
                     leaseOwner: lease_owner,
                     ttlSeconds: DEFAULT_DISPATCH_KEY_TTL_SECONDS,
+                    attempt,
+                    // BAPI-445: a review-role claim appends ":review" to the dispatch key
+                    // so the run-id maps above can separate review runs from impl runs.
+                    reviewRole: role === "review",
                 }),
+                // BAPI-445 spec re-review seams. dispatchReviewSeam is wired only when the
+                // factory provides it (gate stays off otherwise); the liveness + attempt
+                // accessors read the review-scoped maps built above.
+                dispatchReviewSeam: dispatchReviewSeamFn
+                    ? async (ek, tk, attempt = 0) => dispatchReviewSeamFn(ek, tk, attempt)
+                    : undefined,
+                readReviewWorkerLiveness: async (_ek, tk) => {
+                    const runId = reviewTicketRunIdMap.get(tk);
+                    if (!runId)
+                        return { alive: false, workerId: null };
+                    return extractWorkerLiveness(localEvents, runId, nowFn(), livenessWindowSeconds);
+                },
+                countReviewAttempts: (tk) => reviewAttemptCounts.get(tk) ?? 0,
                 correlateRunId: async (dispatchKey, runId) => {
                     await transitionEpicDispatch(access, {
                         dispatchKey,
@@ -802,7 +838,53 @@ export async function buildProductionEpicRuntimeDeps(epicKey) {
         }
         return runId;
     };
-    const fetchLocalEvents = (_ek, runIds) => {
+    const dispatchReviewSeam = async (ek, tk, attempt = 0) => {
+        // BAPI-445: spawn the pre-implementation spec re-review as the review-tickets
+        // automation kind — ALWAYS a review, regardless of the ticket's own plan-node
+        // automation kind (which is an implementation kind). fetchPlan must have run
+        // first so cachedPlanVersion is populated (same guard as dispatchSeam).
+        if (cachedPlanVersion === 0) {
+            throw new Error(`dispatchReviewSeam called before fetchPlan for epic ${ek} ticket ${tk}; cachedPlanVersion is 0`);
+        }
+        const dispatchDryRun = process.env.BAPI_CONDUCTOR_DISPATCH_DRY_RUN === "1";
+        // Deliberately omit `dispatch_key` from the identity: the reconcile pass owns
+        // the idempotent :review key claim (recordEpicDispatch with reviewRole) and the
+        // run_spawned correlation. orchestrateReviewTickets still mints the run_id and
+        // injects BAPI_CONDUCTOR_RUN_ID into the review agent's environment, which is
+        // exactly the correlation channel the Python review orchestrator reads to stamp
+        // the spec_review.* verdict event with this review run's id (Phase 2).
+        const identity = {
+            epic_key: ek,
+            epic_run_id: ek,
+            plan_version: cachedPlanVersion,
+        };
+        const deps = createDefaultStartTicketsDeps();
+        const result = await orchestrateReviewTickets(deps, {
+            keys: [tk],
+            epic: identity,
+            agentName: "claude",
+            dryRun: dispatchDryRun,
+            maxParallel: 1,
+            auto: true,
+            // Product directive: the spec re-review is `/review-ticket --auto --rounds=2`.
+            rounds: 2,
+            reviewOverrides: {},
+        });
+        if (!result.ok) {
+            throw new Error(`spec re-review dispatch failed: ${result.error}`);
+        }
+        let runId = result.rows[0]?.runId;
+        if (!runId && dispatchDryRun) {
+            // Dry-run produced no real run_id; substitute a synthetic, attempt-scoped id
+            // so the reconcile correlate step still records the :review dispatch row.
+            runId = `dry-run:review:${ek}:${tk}:${cachedPlanVersion}:r${attempt}`;
+        }
+        if (!runId) {
+            throw new Error(`spec re-review dispatch returned no runId for ticket ${tk}`);
+        }
+        return runId;
+    };
+    const fetchLocalEvents = async (_ek, runIds) => {
         // Workers and the epic-tick process share the same local SQLite ledger
         // (~/.config/bridge/events.db). pollConductorEvents opens it read-only.
         //
@@ -831,7 +913,7 @@ export async function buildProductionEpicRuntimeDeps(epicKey) {
         // cap total iterations defensively against a non-advancing cursor.
         const MAX_PAGES = 10_000;
         for (let page = 0; page < MAX_PAGES; page += 1) {
-            const result = pollConductorEvents({
+            const result = await pollConductorEvents({
                 data_mode: "full",
                 since_seq: sinceSeq,
                 limit: POLL_LIMIT_MAX,
@@ -897,6 +979,7 @@ export async function buildProductionEpicRuntimeDeps(epicKey) {
     return {
         fetchPlan,
         dispatchSeam,
+        dispatchReviewSeam,
         fetchLocalEvents,
         escalateOnce,
         postActionWaitSeam,