@bridge_gpt/mcp-server 0.2.2 → 0.2.4

package/build/conductor/epic-reconcile.js

@@ -0,0 +1,139 @@
+/**
+ * Deterministic observed→desired reconciliation for the Epic Supervisor
+ * (BAPI-408).
+ *
+ * Executes five steps in order:
+ *   1. Fold terminal signals into Postgres via CAS
+ *   2. Compute the ready-set (pure, no LLM — Goal 8)
+ *   3. Dispatch ready tickets idempotently (key claim → spawn → correlate)
+ *   4. Action approved merges via C6 delegation
+ *   5. Schedule post-action wait hooks
+ *
+ * All durable mutations go through injected seams so the logic is testable
+ * without real network, ledger, or terminal access.
+ */
+import { computeReadySet } from "./epic-state.js";
+import { extractMergeActionIdentityFromGateEvent } from "./merge-ledger.js";
+// ---------------------------------------------------------------------------
+// reconcileEpic
+// ---------------------------------------------------------------------------
+/**
+ * Execute the deterministic observed→desired reconciliation pass. All I/O is
+ * behind injected seams; the ready-set is computed by pure code (no LLM).
+ */
+export async function reconcileEpic(access, observed, plan, deps) {
+    const result = {
+        signals_folded: 0,
+        dispatched: 0,
+        merges_actioned: 0,
+        warnings: [],
+    };
+    const escalate = deps.escalateOnce ?? (async () => undefined);
+    // Step 1: Fold terminal signals → CAS into Postgres
+    for (const signal of observed.unfolded_terminal_signals) {
+        let casResult;
+        try {
+            casResult = await deps.casTicketStatus(observed.epic_key, signal.ticket_key, signal.postgres_row_version, signal.next_status, observed.plan_version);
+        }
+        catch (err) {
+            const safeMsg = err instanceof Error ? err.constructor.name : "cas error";
+            result.warnings.push(`cas-error folding ${signal.signal_type} for ${signal.ticket_key}: ${safeMsg}`);
+            continue;
+        }
+        if (casResult.ok) {
+            result.signals_folded += 1;
+            deps.log(`[epic-reconcile] folded ${signal.signal_type} for ${signal.ticket_key} → ${signal.next_status}`);
+        }
+        else {
+            // CAS conflict: another tick already advanced this ticket — non-fatal
+            result.warnings.push(`cas-conflict folding ${signal.signal_type} for ${signal.ticket_key}`);
+        }
+    }
+    // Step 1.5: Seed planned status rows for every plan node (idempotent — ON CONFLICT DO NOTHING)
+    for (const ticket of plan.tickets) {
+        try {
+            await deps.seedTicketStatus(observed.epic_key, ticket.ticket_key, plan.plan_version);
+        }
+        catch (err) {
+            const safeMsg = err instanceof Error ? err.constructor.name : "seed error";
+            result.warnings.push(`seed-error for ${ticket.ticket_key}: ${safeMsg}`);
+        }
+    }
+    // Step 2: Compute the ready-set (pure — never calls LLM)
+    const readySet = computeReadySet(plan, observed.ticket_statuses);
+    // Step 3: Dispatch each ready ticket idempotently
+    for (const ticketKey of readySet) {
+        let claimResult;
+        try {
+            claimResult = await deps.claimDispatchKey(observed.epic_key, ticketKey, observed.plan_version);
+        }
+        catch (err) {
+            const safeMsg = err instanceof Error ? err.constructor.name : "claim error";
+            result.warnings.push(`claim-error for ${ticketKey}: ${safeMsg}`);
+            continue;
+        }
+        if (!claimResult.ok) {
+            // lease-held: another tick is dispatching this ticket concurrently
+            result.warnings.push(`dispatch-key lease-held for ${ticketKey}`);
+            continue;
+        }
+        if (claimResult.kind === "terminal") {
+            // Already dispatched and terminal — nothing to do
+            continue;
+        }
+        if (claimResult.kind === "already-spawned") {
+            // Spawn already occurred; ensure post-action wait is scheduled
+            await deps.postActionWaitSeam(observed.epic_key, ticketKey);
+            continue;
+        }
+        if (claimResult.kind === "already-exists") {
+            if (claimResult.dispatch.run_id === null) {
+                // Spawn happened on a prior tick but correlateRunId failed — the live run's
+                // terminal signals can never be correlated back to this ticket. Escalate so
+                // an operator can manually recover (set run_id or abandon the dispatch key).
+                result.warnings.push(`dispatch-orphan: ${ticketKey} has pending dispatch key with no run_id`);
+                await escalate(observed.epic_key, `dispatch-orphan:${ticketKey}`);
+            }
+            continue;
+        }
+        // kind === "claimed": proceed with spawn
+        const dispatchKey = claimResult.dispatch.dispatch_key;
+        let runId;
+        try {
+            runId = await deps.dispatchSeam(observed.epic_key, ticketKey);
+        }
+        catch (err) {
+            const safeMsg = err instanceof Error ? err.constructor.name : "dispatch error";
+            result.warnings.push(`dispatch-failed for ${ticketKey}: ${safeMsg}`);
+            continue;
+        }
+        try {
+            await deps.correlateRunId(dispatchKey, runId);
+            result.dispatched += 1;
+            deps.log(`[epic-reconcile] dispatched ${ticketKey} run_id=${runId}`);
+            await deps.postActionWaitSeam(observed.epic_key, ticketKey);
+        }
+        catch (err) {
+            const safeMsg = err instanceof Error ? err.constructor.name : "correlate error";
+            result.warnings.push(`correlate-failed for ${ticketKey}: ${safeMsg}`);
+        }
+    }
+    // Step 4: Action approved merges via C6 delegation
+    for (const event of observed.pending_merge_events) {
+        const identity = extractMergeActionIdentityFromGateEvent(event);
+        if (!identity)
+            continue;
+        try {
+            const mergeResult = await deps.processMerge(access, event);
+            if (mergeResult.processed) {
+                result.merges_actioned += 1;
+            }
+        }
+        catch (err) {
+            const safeMsg = err instanceof Error ? err.constructor.name : "merge error";
+            result.warnings.push(`merge-failed ${identity.action_key}: ${safeMsg}`);
+        }
+    }
+    // Step 5: Post-action waits are scheduled inline above per-dispatch
+    return result;
+}