merge-steward 0.10.2 → 0.10.3

package/dist/cli/commands/queue.js

@@ -1,10 +1,10 @@
 import { SqliteStore } from "../../db/sqlite-store.js";
-import { buildSummary } from "../../service.js";
 import { TERMINAL_STATUSES } from "../../types.js";
 import { UsageError } from "../types.js";
 import { parseIntegerFlag } from "../args.js";
 import { formatJson, writeOutput } from "../output.js";
 import { loadRepoConfigById, resolveRepoId, fetchLocalJson } from "../system.js";
+import { buildQueueSummary } from "../../watch/dashboard-model.js";
 async function readQueueSnapshot(config, eventLimit) {
     try {
         const query = new URLSearchParams({ eventLimit: String(eventLimit) });
@@ -21,7 +21,7 @@ async function readQueueSnapshot(config, eventLimit) {
                     repoId: config.repoId,
                     repoFullName: config.repoFullName,
                     baseBranch: config.baseBranch,
-                    summary: buildSummary(entries),
+                    summary: buildQueueSummary(entries),
                     runtime: {
                         tickInProgress: false,
                         lastTickStartedAt: null,

package/dist/reconciler-core.d.ts

@@ -0,0 +1,33 @@
+import type { GitOperations, CIRunner, GitHubPRApi, EvictionReporter, SpeculativeBranchBuilder } from "./interfaces.ts";
+import type { QueueStore } from "./store.ts";
+import type { QueueEntry, ReconcileEvent, ReconcileAction } from "./types.ts";
+export interface ReconcileContext {
+    store: QueueStore;
+    repoId: string;
+    baseBranch: string;
+    remotePrefix: string;
+    git: GitOperations;
+    ci: CIRunner;
+    github: GitHubPRApi;
+    eviction: EvictionReporter;
+    specBuilder: SpeculativeBranchBuilder;
+    speculativeDepth: number;
+    flakyRetries: number;
+    onEvent: (event: ReconcileEvent) => void;
+}
+export declare const SPEC_BRANCH_PREFIX = "mq-spec-";
+export declare const FAILED_CONCLUSIONS: Set<string>;
+export declare const CLEAN_SPEC: {
+    readonly specBranch: null;
+    readonly specSha: null;
+    readonly specBasedOn: null;
+};
+export declare const CLEAN_CI: {
+    readonly ciRunId: null;
+    readonly ciRetries: 0;
+};
+export declare function emit(ctx: ReconcileContext, entry: QueueEntry, action: ReconcileAction, extra?: Partial<ReconcileEvent>): void;
+export declare function ref(ctx: ReconcileContext, name: string): string;
+export declare function specBranchName(entryId: string): string;
+export declare function isBudgetExhausted(entry: QueueEntry): boolean;
+export declare function isRetryGated(entry: QueueEntry, currentBaseSha: string): boolean;

package/dist/reconciler-core.js

@@ -0,0 +1,19 @@
+export const SPEC_BRANCH_PREFIX = "mq-spec-";
+export const FAILED_CONCLUSIONS = new Set(["failure"]);
+export const CLEAN_SPEC = { specBranch: null, specSha: null, specBasedOn: null };
+export const CLEAN_CI = { ciRunId: null, ciRetries: 0 };
+export function emit(ctx, entry, action, extra) {
+    ctx.onEvent({ at: new Date().toISOString(), entryId: entry.id, prNumber: entry.prNumber, action, ...extra });
+}
+export function ref(ctx, name) {
+    return ctx.remotePrefix + name;
+}
+export function specBranchName(entryId) {
+    return `${SPEC_BRANCH_PREFIX}${entryId}`;
+}
+export function isBudgetExhausted(entry) {
+    return entry.retryAttempts >= entry.maxRetries;
+}
+export function isRetryGated(entry, currentBaseSha) {
+    return entry.lastFailedBaseSha === currentBaseSha;
+}

package/dist/reconciler-evict.d.ts

@@ -0,0 +1,12 @@
+import type { FailureClass, QueueEntry } from "./types.ts";
+import type { ReconcileContext } from "./reconciler-core.ts";
+export declare function cleanupSpec(ctx: ReconcileContext, entry: QueueEntry): Promise<void>;
+export declare function invalidateDownstream(ctx: ReconcileContext, allActive: QueueEntry[], afterIndex: number): Promise<void>;
+export declare function evictEntry(ctx: ReconcileContext, entry: QueueEntry, failureClass: FailureClass, extra?: {
+    conflictFiles?: string[];
+    failedChecks?: Array<{
+        name: string;
+        conclusion: string;
+        url?: string;
+    }>;
+}): Promise<void>;

package/dist/reconciler-evict.js

@@ -0,0 +1,70 @@
+import { randomUUID } from "node:crypto";
+import { selectDownstream } from "./invalidation.js";
+import { CLEAN_SPEC, emit, ref } from "./reconciler-core.js";
+import { INVALIDATION_PATCH } from "./invalidation.js";
+export async function cleanupSpec(ctx, entry) {
+    if (entry.specBranch) {
+        await ctx.specBuilder.deleteSpeculative(entry.specBranch).catch(() => {
+            // Best-effort cleanup — branch may not exist.
+        });
+    }
+}
+export async function invalidateDownstream(ctx, allActive, afterIndex) {
+    const targets = selectDownstream(allActive, allActive[afterIndex].position);
+    for (const downstream of targets) {
+        emit(ctx, downstream, "invalidated", { detail: `base changed after position ${afterIndex}` });
+        await cleanupSpec(ctx, downstream);
+        ctx.store.transition(downstream.id, "preparing_head", INVALIDATION_PATCH, "invalidated: base changed");
+    }
+}
+export async function evictEntry(ctx, entry, failureClass, extra) {
+    await cleanupSpec(ctx, entry);
+    let baseSha = entry.baseSha;
+    if (!baseSha) {
+        try {
+            baseSha = await ctx.git.headSha(ref(ctx, ctx.baseBranch));
+        }
+        catch {
+            baseSha = "unknown";
+        }
+    }
+    const events = ctx.store.listEvents(entry.id);
+    const retryHistory = [];
+    for (const event of events) {
+        const eventBaseSha = event.baseSha || "unknown";
+        if (event.fromStatus === "preparing_head" && event.toStatus === "validating") {
+            retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome: "passed_to_validation" });
+        }
+        else if (event.fromStatus === "validating" && event.toStatus === "preparing_head") {
+            retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome: "ci_failed_retry" });
+        }
+        else if (event.fromStatus === "preparing_head" && event.toStatus === "preparing_head") {
+            retryHistory.push({ at: event.at, baseSha: eventBaseSha, outcome: "conflict_retry" });
+        }
+    }
+    const context = {
+        version: 1,
+        failureClass,
+        baseSha,
+        prHeadSha: entry.headSha,
+        queuePosition: entry.position,
+        conflictFiles: extra?.conflictFiles,
+        failedChecks: extra?.failedChecks,
+        baseBranch: ctx.baseBranch,
+        branch: entry.branch,
+        issueKey: entry.issueKey,
+        retryHistory,
+    };
+    const incident = {
+        id: randomUUID(),
+        entryId: entry.id,
+        at: new Date().toISOString(),
+        failureClass,
+        context,
+        outcome: "open",
+    };
+    ctx.store.insertIncident(incident);
+    emit(ctx, entry, "evicted", { failureClass });
+    ctx.store.transition(entry.id, "evicted", CLEAN_SPEC, `evicted: ${failureClass}`);
+    await ctx.eviction.reportEviction(entry, incident);
+}

package/dist/reconciler-merge.d.ts

@@ -0,0 +1,3 @@
+import type { QueueEntry } from "./types.ts";
+import type { ReconcileContext } from "./reconciler-core.ts";
+export declare function mergeHead(ctx: ReconcileContext, entry: QueueEntry): Promise<void>;

package/dist/reconciler-merge.js

@@ -0,0 +1,84 @@
+import { CLEAN_CI, CLEAN_SPEC, emit, isBudgetExhausted, ref } from "./reconciler-core.js";
+import { cleanupSpec, evictEntry, invalidateDownstream } from "./reconciler-evict.js";
+export async function mergeHead(ctx, entry) {
+    emit(ctx, entry, "merge_revalidating");
+    const prStatus = await ctx.github.getStatus(entry.prNumber);
+    if (prStatus.merged) {
+        emit(ctx, entry, "merge_external");
+        ctx.store.transition(entry.id, "merged", CLEAN_SPEC, "merged externally");
+        await cleanupSpec(ctx, entry);
+        return;
+    }
+    if (!prStatus.reviewApproved) {
+        const detail = prStatus.reviewDecision === "CHANGES_REQUESTED"
+            ? "blocking review present, waiting for approval"
+            : prStatus.reviewDecision === "REVIEW_REQUIRED"
+                ? "required approval missing"
+                : `review gate not satisfied (${prStatus.reviewDecision ?? "unknown"})`;
+        emit(ctx, entry, "merge_waiting_approval", { detail });
+        return;
+    }
+    if (prStatus.headSha !== entry.headSha) {
+        emit(ctx, entry, "branch_mismatch", { detail: `PR head: expected ${entry.headSha.slice(0, 8)}, got ${prStatus.headSha.slice(0, 8)}` });
+        const allActive = ctx.store.listActive(ctx.repoId);
+        ctx.store.updateHead(entry.id, prStatus.headSha);
+        await invalidateDownstream(ctx, allActive, 0);
+        return;
+    }
+    if (!entry.specBranch || !entry.specSha) {
+        ctx.store.transition(entry.id, "preparing_head", { ...CLEAN_CI, ...CLEAN_SPEC }, "no spec branch, re-prepare");
+        return;
+    }
+    try {
+        await ctx.git.fetch();
+        const currentBase = await ctx.git.headSha(ref(ctx, ctx.baseBranch));
+        const isFF = await ctx.git.isAncestor(currentBase, entry.specSha);
+        if (!isFF) {
+            emit(ctx, entry, "branch_mismatch", { detail: `spec is not a fast-forward from main (${currentBase.slice(0, 8)})` });
+            const allActive = ctx.store.listActive(ctx.repoId);
+            ctx.store.transition(entry.id, "preparing_head", { ...CLEAN_CI, ...CLEAN_SPEC }, "main diverged, re-prepare");
+            await invalidateDownstream(ctx, allActive, 0);
+            return;
+        }
+    }
+    catch {
+        // Can't verify — proceed and let push fail if needed.
+    }
+    if (ctx.ci.getMainStatus) {
+        const mainStatus = await ctx.ci.getMainStatus(ctx.baseBranch);
+        if (mainStatus !== "pass") {
+            emit(ctx, entry, "main_broken", { detail: "main unhealthy at merge time, re-preparing" });
+            ctx.store.transition(entry.id, "preparing_head", { ...CLEAN_CI, ...CLEAN_SPEC }, "main unhealthy at merge time");
+            return;
+        }
+    }
+    try {
+        await ctx.git.push(entry.specBranch, false, ctx.baseBranch);
+    }
+    catch {
+        emit(ctx, entry, "merge_rejected", { detail: "push to main failed" });
+        const allActive = ctx.store.listActive(ctx.repoId);
+        if (isBudgetExhausted(entry)) {
+            emit(ctx, entry, "budget_exhausted");
+            await evictEntry(ctx, entry, "integration_conflict");
+        }
+        else {
+            ctx.store.transition(entry.id, "preparing_head", {
+                retryAttempts: entry.retryAttempts + 1,
+                ...CLEAN_CI,
+                ...CLEAN_SPEC,
+            }, `push failed, retry ${entry.retryAttempts + 1}/${entry.maxRetries}`);
+        }
+        await invalidateDownstream(ctx, allActive, 0);
+        return;
+    }
+    emit(ctx, entry, "merge_succeeded");
+    ctx.store.transition(entry.id, "merged", CLEAN_SPEC, "spec pushed to main");
+    await cleanupSpec(ctx, entry);
+    try {
+        await ctx.github.deleteBranch(entry.prNumber);
+    }
+    catch {
+        /* cosmetic */
+    }
+}

package/dist/reconciler-prepare.d.ts

@@ -0,0 +1,3 @@
+import type { QueueEntry } from "./types.ts";
+import type { ReconcileContext } from "./reconciler-core.ts";
+export declare function prepareEntry(ctx: ReconcileContext, entry: QueueEntry, isHead: boolean, prevEntry: QueueEntry | null): Promise<void>;

package/dist/reconciler-prepare.js

@@ -0,0 +1,134 @@
+import { CLEAN_CI, CLEAN_SPEC, emit, isBudgetExhausted, isRetryGated, ref, specBranchName } from "./reconciler-core.js";
+import { evictEntry } from "./reconciler-evict.js";
+function summarizeCheckNames(checks, limit = 3) {
+    const names = [...new Set(checks.map((check) => check.name))];
+    if (names.length <= limit) {
+        return names.join(", ");
+    }
+    return `${names.slice(0, limit).join(", ")} +${names.length - limit} more`;
+}
+function describeMainBroken(failingChecks, pendingChecks) {
+    const parts = [];
+    if (failingChecks.length > 0) {
+        parts.push(`failing ${summarizeCheckNames(failingChecks)}`);
+    }
+    if (pendingChecks.length > 0) {
+        parts.push(`pending ${summarizeCheckNames(pendingChecks)}`);
+    }
+    return parts.length > 0 ? `main checks unhealthy: ${parts.join("; ")}` : "main checks unhealthy";
+}
+export async function prepareEntry(ctx, entry, isHead, prevEntry) {
+    emit(ctx, entry, "fetch_started");
+    await ctx.git.fetch();
+    const base = isHead ? ref(ctx, ctx.baseBranch) : prevEntry?.specBranch ?? null;
+    if (!base)
+        return;
+    const baseSha = await ctx.git.headSha(base);
+    const currentRef = await ctx.git.headSha(ref(ctx, entry.branch));
+    if (currentRef !== entry.headSha) {
+        emit(ctx, entry, "branch_mismatch", { detail: `expected ${entry.headSha.slice(0, 8)}, got ${currentRef.slice(0, 8)}` });
+        ctx.store.updateHead(entry.id, currentRef);
+        return;
+    }
+    if (isHead) {
+        if (ctx.ci.getMainStatus) {
+            const mainStatus = await ctx.ci.getMainStatus(ctx.baseBranch);
+            if (mainStatus !== "pass") {
+                let mainChecks = [];
+                try {
+                    mainChecks = await ctx.github.listChecksForRef(ref(ctx, ctx.baseBranch));
+                }
+                catch {
+                    mainChecks = [];
+                }
+                const failingChecks = mainChecks.filter((check) => check.conclusion === "failure");
+                const pendingChecks = mainChecks.filter((check) => check.conclusion === "pending");
+                emit(ctx, entry, "main_broken", {
+                    baseSha,
+                    failingChecks,
+                    pendingChecks,
+                    detail: describeMainBroken(failingChecks, pendingChecks),
+                });
+                return;
+            }
+        }
+        if (isBudgetExhausted(entry) && entry.lastFailedBaseSha !== null) {
+            emit(ctx, entry, "budget_exhausted", { baseSha });
+            await evictEntry(ctx, entry, "integration_conflict");
+            return;
+        }
+        if (isRetryGated(entry, baseSha)) {
+            try {
+                const prStatus = await ctx.github.getStatus(entry.prNumber);
+                if (prStatus.mergeStateStatus === "DIRTY") {
+                    emit(ctx, entry, "budget_exhausted", {
+                        baseSha,
+                        detail: "retry gated and GitHub still reports merge conflict",
+                    });
+                    await evictEntry(ctx, entry, "integration_conflict");
+                    return;
+                }
+                emit(ctx, entry, "retry_gated", { baseSha, detail: "local conflict but GitHub reports CLEAN, retrying" });
+                ctx.store.transition(entry.id, "preparing_head", {
+                    lastFailedBaseSha: null,
+                    ...CLEAN_CI,
+                    ...CLEAN_SPEC,
+                }, "GitHub reports CLEAN, clearing retry gate");
+            }
+            catch {
+                emit(ctx, entry, "retry_gated", { baseSha, detail: "base unchanged since last conflict" });
+            }
+            return;
+        }
+    }
+    const specName = specBranchName(entry.id);
+    emit(ctx, entry, "spec_build_started", { specBranch: specName, baseSha, ...(prevEntry ? { dependsOn: prevEntry.id } : {}) });
+    const branchSuffix = entry.branch.replace(/^.*\//, "").replace(/-/g, " ");
+    const mergeMessage = `Merge PR #${entry.prNumber}: ${branchSuffix}`;
+    let result;
+    try {
+        result = await ctx.specBuilder.buildSpeculative(entry.branch, base, specName, mergeMessage);
+    }
+    catch (err) {
+        if (isHead) {
+            const detail = `git error during spec build: ${err instanceof Error ? err.message : String(err)}`;
+            emit(ctx, entry, "branch_unreachable", { baseSha, detail });
+            await evictEntry(ctx, entry, "branch_local");
+        }
+        else {
+            emit(ctx, entry, "invalidated", { detail: "stale spec branch, rebuilding" });
+            ctx.store.transition(prevEntry.id, "preparing_head", { ...CLEAN_CI, ...CLEAN_SPEC }, "spec branch missing, rebuilding");
+            ctx.store.transition(entry.id, "preparing_head", { ...CLEAN_CI, ...CLEAN_SPEC }, "stale dependency, rebuilding");
+        }
+        return;
+    }
+    if (!result.success) {
+        emit(ctx, entry, "spec_build_conflict", { baseSha, conflictFiles: result.conflictFiles });
+        if (isBudgetExhausted(entry)) {
+            emit(ctx, entry, "budget_exhausted");
+            await evictEntry(ctx, entry, "integration_conflict", result.conflictFiles ? { conflictFiles: result.conflictFiles } : undefined);
+        }
+        else {
+            ctx.store.transition(entry.id, "preparing_head", {
+                retryAttempts: entry.retryAttempts + 1,
+                lastFailedBaseSha: baseSha,
+                ...CLEAN_CI,
+                ...CLEAN_SPEC,
+            }, `conflict on ${baseSha.slice(0, 8)}, retry ${entry.retryAttempts + 1}/${entry.maxRetries}`);
+        }
+        return;
+    }
+    const specSha = result.sha ?? entry.headSha;
+    emit(ctx, entry, "spec_build_succeeded", { specBranch: specName, ...(prevEntry ? { dependsOn: prevEntry.id } : {}) });
+    await ctx.git.push(specName, true);
+    const runId = await ctx.ci.triggerRun(specName, specSha);
+    emit(ctx, entry, "ci_triggered", { ciRunId: runId, specBranch: specName });
+    ctx.store.transition(entry.id, "validating", {
+        baseSha,
+        ciRunId: runId,
+        lastFailedBaseSha: null,
+        specBranch: specName,
+        specSha,
+        specBasedOn: isHead ? null : prevEntry.id,
+    }, `spec ready, CI ${runId.slice(0, 12)}`);
+}

package/dist/reconciler-sanitize.d.ts

@@ -0,0 +1,3 @@
+import type { QueueEntry } from "./types.ts";
+import type { ReconcileContext } from "./reconciler-core.ts";
+export declare function sanitizeEntry(ctx: ReconcileContext, entry: QueueEntry): Promise<boolean>;

package/dist/reconciler-sanitize.js

@@ -0,0 +1,36 @@
+import { CLEAN_SPEC, emit } from "./reconciler-core.js";
+import { cleanupSpec } from "./reconciler-evict.js";
+export async function sanitizeEntry(ctx, entry) {
+    const canonical = ctx.store.getEntryByPR(ctx.repoId, entry.prNumber);
+    if (canonical && canonical.id !== entry.id) {
+        emit(ctx, entry, "sanitized_duplicate", {
+            detail: `superseded by entry ${canonical.id}`,
+        });
+        await cleanupSpec(ctx, entry);
+        ctx.store.dequeue(entry.id);
+        return true;
+    }
+    try {
+        const prStatus = await ctx.github.getStatus(entry.prNumber);
+        if (prStatus.merged) {
+            emit(ctx, entry, "merge_external", {
+                detail: `PR #${entry.prNumber} already merged on GitHub (detected in sanitize)`,
+            });
+            await cleanupSpec(ctx, entry);
+            ctx.store.transition(entry.id, "merged", CLEAN_SPEC, "merged externally (sanitize)");
+            return true;
+        }
+        if (!prStatus.mergeable && !prStatus.merged) {
+            emit(ctx, entry, "sanitized_closed", {
+                detail: `PR #${entry.prNumber} is closed on GitHub`,
+            });
+            await cleanupSpec(ctx, entry);
+            ctx.store.dequeue(entry.id);
+            return true;
+        }
+    }
+    catch {
+        // GitHub probe failed — don't block the tick.
+    }
+    return false;
+}

package/dist/reconciler-validate.d.ts

@@ -0,0 +1,3 @@
+import type { QueueEntry } from "./types.ts";
+import type { ReconcileContext } from "./reconciler-core.ts";
+export declare function checkValidation(ctx: ReconcileContext, entry: QueueEntry, allActive: QueueEntry[], index: number): Promise<void>;

package/dist/reconciler-validate.js

@@ -0,0 +1,58 @@
+import { CLEAN_CI, CLEAN_SPEC, emit, isBudgetExhausted, ref } from "./reconciler-core.js";
+import { classifyFailure } from "./classify.js";
+import { evictEntry, invalidateDownstream } from "./reconciler-evict.js";
+const FAILED_CONCLUSIONS = new Set(["failure"]);
+export async function checkValidation(ctx, entry, allActive, index) {
+    if (!entry.ciRunId) {
+        const branch = entry.specBranch ?? entry.branch;
+        const sha = entry.specSha ?? entry.headSha;
+        const runId = await ctx.ci.triggerRun(branch, sha);
+        emit(ctx, entry, "ci_triggered", { ciRunId: runId });
+        ctx.store.transition(entry.id, "validating", { ciRunId: runId }, `CI triggered: ${runId.slice(0, 12)}`);
+        return;
+    }
+    const status = await ctx.ci.getStatus(entry.ciRunId);
+    switch (status) {
+        case "pending":
+            emit(ctx, entry, "ci_pending", { ciRunId: entry.ciRunId });
+            break;
+        case "pass":
+            emit(ctx, entry, "ci_passed", { ciRunId: entry.ciRunId });
+            if (index === 0) {
+                ctx.store.transition(entry.id, "merging", undefined, "CI passed, ready to merge");
+            }
+            break;
+        case "fail": {
+            emit(ctx, entry, "ci_failed", { ciRunId: entry.ciRunId });
+            if (entry.ciRetries < ctx.flakyRetries) {
+                emit(ctx, entry, "ci_flaky_retry", { detail: `retry ${entry.ciRetries + 1}/${ctx.flakyRetries}` });
+                const branch = entry.specBranch ?? entry.branch;
+                const sha = entry.specSha ?? entry.headSha;
+                const runId = await ctx.ci.triggerRun(branch, sha);
+                ctx.store.transition(entry.id, "validating", {
+                    ciRunId: runId,
+                    ciRetries: entry.ciRetries + 1,
+                }, `flaky retry ${entry.ciRetries + 1}/${ctx.flakyRetries}`);
+            }
+            else if (isBudgetExhausted(entry)) {
+                emit(ctx, entry, "budget_exhausted");
+                const branchChecks = await ctx.github.listChecks(entry.prNumber);
+                const mainChecks = await ctx.github.listChecksForRef(ref(ctx, ctx.baseBranch));
+                const failedChecks = branchChecks
+                    .filter((c) => FAILED_CONCLUSIONS.has(c.conclusion))
+                    .map((c) => ({ name: c.name, conclusion: c.conclusion, ...(c.url ? { url: c.url } : {}) }));
+                await evictEntry(ctx, entry, classifyFailure(branchChecks, mainChecks), { failedChecks });
+                await invalidateDownstream(ctx, allActive, index);
+            }
+            else {
+                ctx.store.transition(entry.id, "preparing_head", {
+                    retryAttempts: entry.retryAttempts + 1,
+                    ...CLEAN_CI,
+                    ...CLEAN_SPEC,
+                }, `CI failed, retry ${entry.retryAttempts + 1}/${entry.maxRetries}`);
+                await invalidateDownstream(ctx, allActive, index);
+            }
+            break;
+        }
+    }
+}

package/dist/reconciler.d.ts

@@ -1,18 +1,3 @@
-import type { GitOperations, CIRunner, GitHubPRApi, EvictionReporter, SpeculativeBranchBuilder } from "./interfaces.ts";
-import type { QueueStore } from "./store.ts";
-import type { ReconcileEvent } from "./types.ts";
-export interface ReconcileContext {
-    store: QueueStore;
-    repoId: string;
-    baseBranch: string;
-    remotePrefix: string;
-    git: GitOperations;
-    ci: CIRunner;
-    github: GitHubPRApi;
-    eviction: EvictionReporter;
-    specBuilder: SpeculativeBranchBuilder;
-    speculativeDepth: number;
-    flakyRetries: number;
-    onEvent: (event: ReconcileEvent) => void;
-}
+import type { ReconcileContext } from "./reconciler-core.ts";
+export type { ReconcileContext } from "./reconciler-core.ts";
 export declare function reconcile(ctx: ReconcileContext): Promise<void>;