agent-dealer 1.2.9 → 1.2.11

package/bundle/server/dist/coordinator/auto-merge.js

@@ -30,6 +30,7 @@ import { appendWorkflowEvent, completeWorkflowInstance, getActiveWorkflowInstanc
 import { createHumanAction, findOpenHumanAction, findOpenHumanActionByRequestId, resolveHumanAction, } from "../repository/human-actions.js";
 import { MERGE_FAILURE_EVIDENCE_KEY, MERGE_FAILURE_RESPONSE_OPTIONS } from "./human-resolution.js";
 import { isMergeConflictFailure, runMergeConflictSync } from "./merge-conflict-sync.js";
+import { startBaseAdvancedScan } from "./base-advanced-scan.js";
 import { OPERATOR_VERIFICATION_RESPONSE_OPTIONS, formatOperatorCriteria, getOperatorCriteriaForIssue, hasOperatorVerificationForHead, operatorVerificationRequestId, } from "./operator-criteria.js";
 const run = promisify(execFile);
 /** Bound each `gh` shell-out so a hang cannot freeze the coordinator process. */
@@ -147,7 +148,7 @@ export const realMergePr = async ({ cwd, number }) => {
         const reason = ghErrorReason(err, "gh pr merge failed", cwd);
         // Crash between a successful merge and the done-transition: retry must not escalate.
         if (ALREADY_MERGED.test(reason))
-            return { ok: true };
+            return { ok: true, alreadyMerged: true };
         return { ok: false, reason };
     }
 };
@@ -163,6 +164,10 @@ export function setMergePrForTests(fn) {
  * for the same issue share one Promise (set synchronously before any await).
  */
 const finalizeInflight = new Map();
+/** NOT-356: whether this process is merging the issue's PR right now. */
+export function isAutoMergeInFlight(issueId) {
+    return finalizeInflight.has(issueId);
+}
 /** Test hook — clear single-flight state between cases. */
 export function clearFinalizeInflightForTests() {
     finalizeInflight.clear();
@@ -227,7 +232,7 @@ async function finalizeAutoMergeOnce(issueId) {
             mergePr: mergePrImpl,
         });
         if (sync.outcome === "merged") {
-            merge = { ok: true };
+            merge = sync.alreadyMerged ? { ok: true, alreadyMerged: true } : { ok: true };
         }
         else if (sync.outcome === "repair_queued") {
             return {
@@ -249,7 +254,7 @@ async function finalizeAutoMergeOnce(issueId) {
     if (!merge.ok) {
         return escalateMergeFailure(issue, instance.id, `Auto-merge failed: ${merge.reason}`);
     }
-    return getDb().transaction(() => {
+    const merged = getDb().transaction(() => {
         const current = getIssue(issueId);
         const active = getActiveWorkflowInstance(issueId);
         if (!active) {
@@ -308,6 +313,14 @@ async function finalizeAutoMergeOnce(issueId) {
             triggerReflect: true,
         };
     })();
+    // NOT-356: the base just moved under every other open Dealer PR on this repo +
+    // base — probe them and resolve the idle conflicting ones. Background and
+    // self-contained: nothing it does can change this merge's result. Only for a
+    // merge this call made: a PR GitHub already reports merged (a human merged it,
+    // or a crash recovery re-runs the finalize) is not Dealer's merge.
+    if (merged.triggerReflect && !merge.alreadyMerged)
+        startBaseAdvancedScan(getIssue(issueId) ?? issue);
+    return merged;
 }
 /**
  * NOT-314: the `[operator]` merge gate. After reviewer approve and before the

package/bundle/server/dist/coordinator/auto-merge.timeout.test.js

@@ -54,3 +54,20 @@ test("NOT-151: resolveAutoMergeCwd accepts a real legacy local checkout", () =>
     if (ok.ok)
         assert.equal(ok.cwd, dir);
 });
+test("NOT-356: realMergePr marks a PR GitHub already merged, and only that, as alreadyMerged", async () => {
+    const { realMergePr } = await import("./auto-merge.js");
+    const bin = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-not356-gh-"));
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), "dealer-not356-cwd-"));
+    const savedPath = process.env.PATH;
+    process.env.PATH = `${bin}${path.delimiter}${savedPath ?? ""}`;
+    const fakeGh = (mergeBody) => fs.writeFileSync(path.join(bin, "gh"), `#!/bin/sh\nif [ "$2" = "merge" ]; then\n${mergeBody}\nfi\nexit 0\n`, { mode: 0o755 });
+    try {
+        fakeGh(`echo "GraphQL: Pull request #7 was already merged" >&2; exit 1`);
+        assert.deepEqual(await realMergePr({ cwd, number: 7 }), { ok: true, alreadyMerged: true });
+        fakeGh("exit 0");
+        assert.deepEqual(await realMergePr({ cwd, number: 7 }), { ok: true });
+    }
+    finally {
+        process.env.PATH = savedPath;
+    }
+});

package/bundle/server/dist/coordinator/base-advanced-scan.js

@@ -0,0 +1,308 @@
+import { DEFAULT_BASE_FETCH_TIMEOUT_MS, fetchFreshBase, fetchReusedBranch, probeBaseConflict, readRemoteTip, } from "../adapters/git-worktree.js";
+import { classifyIssueRepo } from "../adapters/managed-repo.js";
+import { getDb } from "../db/index.js";
+import { getIssue, listIssues } from "../repository/issues.js";
+import { getActiveWorkerSessionForIssue } from "../repository/worker-sessions.js";
+import { listWorkItemsForIssue } from "../repository/work-items.js";
+import { appendWorkflowEvent, getActiveWorkflowInstance } from "../repository/workflow-events.js";
+import { isAutoMergeInFlight } from "./auto-merge.js";
+import { BASE_ADVANCED_STATUSES, checksWaitSyncSpent, conflictRepairSpent, queueChecksWaitAfterBaseSync, queueConflictRepairRound, runMergeConflictSync, } from "./merge-conflict-sync.js";
+/** Open stages in which an issue can hold a PR Dealer opened. */
+const SIBLING_STATUSES = BASE_ADVANCED_STATUSES;
+let probeImpl = probeBaseConflict;
+/** Test hook — fake or wrap the per-sibling conflict probe. */
+export function setBaseAdvancedProbeForTests(probe) {
+    probeImpl = probe ?? probeBaseConflict;
+}
+/** Tail of the serialized scan chain per repo + base. */
+const scanChains = new Map();
+/**
+ * Start the sibling scan for a PR Dealer just merged. Never throws and never
+ * delays the caller: the work is chained behind any earlier scan for the same
+ * repo + base and runs in the background.
+ */
+export function startBaseAdvancedScan(merged) {
+    const key = `${merged.repo}\u0000${merged.baseBranch}`;
+    const prev = scanChains.get(key) ?? Promise.resolve();
+    const next = prev
+        .then(() => scanSiblingsAfterMerge(merged))
+        .then(() => undefined, (err) => {
+        console.error("[coordinator] base-advanced scan", merged.id, err);
+    });
+    scanChains.set(key, next);
+    void next.finally(() => {
+        if (scanChains.get(key) === next)
+            scanChains.delete(key);
+    });
+}
+/** Test hook — resolve once every started scan has finished. */
+export async function settleBaseAdvancedScansForTests() {
+    while (scanChains.size > 0) {
+        await Promise.all([...scanChains.values()]);
+    }
+}
+/**
+ * Probe and (when idle and conflicting) resolve every other open Dealer PR on the
+ * merged issue's repo + base. Exported for direct tests; production goes through
+ * {@link startBaseAdvancedScan}.
+ */
+export async function scanSiblingsAfterMerge(merged) {
+    const siblings = listIssues(SIBLING_STATUSES).filter((i) => i.id !== merged.id &&
+        i.repo === merged.repo &&
+        i.baseBranch === merged.baseBranch &&
+        i.prNumber != null &&
+        Boolean(i.branch));
+    if (siblings.length === 0)
+        return [];
+    const context = { mergedIssueId: merged.id, mergedPrNumber: merged.prNumber, baseBranch: merged.baseBranch };
+    let repoPath = null;
+    let base = null;
+    let setupFailure = null;
+    try {
+        repoPath = classifyIssueRepo(merged.repo).repoPath;
+        const fresh = await fetchFreshBase(repoPath, merged.baseBranch, DEFAULT_BASE_FETCH_TIMEOUT_MS);
+        if (fresh.ok)
+            base = { sha: fresh.sha, ref: fresh.ref };
+        else
+            setupFailure = `fetch origin/${merged.baseBranch} failed: ${fresh.reason}`;
+    }
+    catch (err) {
+        setupFailure = err instanceof Error ? err.message : String(err);
+    }
+    const results = [];
+    for (const sibling of siblings) {
+        const record = (action, detail) => {
+            recordBaseAdvanced(sibling.id, { ...context, baseSha: base?.sha ?? null, action, ...(detail ?? {}) });
+            results.push({ issueId: sibling.id, action });
+        };
+        try {
+            if (setupFailure || !repoPath || !base) {
+                record("skipped", { reason: setupFailure ?? "base did not resolve" });
+                continue;
+            }
+            const { action, detail } = await scanSibling(sibling, repoPath, base);
+            record(action, detail);
+        }
+        catch (err) {
+            record("failed", { reason: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    return results;
+}
+async function scanSibling(sibling, repoPath, base) {
+    const issue = getIssue(sibling.id);
+    const instance = getActiveWorkflowInstance(sibling.id);
+    if (!issue || !instance || !SIBLING_STATUSES.includes(issue.status)) {
+        return { action: "skipped", detail: { reason: "issue is no longer open" } };
+    }
+    const branch = issue.branch;
+    const prNumber = issue.prNumber;
+    const busy = activeReason(issue.id);
+    if (busy)
+        return { action: "active_worker", detail: { reason: busy } };
+    // Start from exactly what Dealer last pushed; anything else is a hand edit.
+    const reused = await fetchReusedBranch(repoPath, branch, DEFAULT_BASE_FETCH_TIMEOUT_MS);
+    if (!reused.ok)
+        return { action: "skipped", detail: { reason: `fetch origin/${branch} failed: ${reused.reason}` } };
+    if (reused.remoteSha == null)
+        return { action: "skipped", detail: { reason: `origin/${branch} does not exist` } };
+    const lastPushed = lastDealerPushedSha(issue);
+    if (reused.remoteSha !== lastPushed) {
+        return { action: "hand_edited", detail: { remoteSha: reused.remoteSha, lastPushedSha: lastPushed } };
+    }
+    const expectedHeadSha = reused.remoteSha;
+    const probe = await probeImpl({
+        worktreePath: repoPath,
+        baseRef: base.ref,
+        headRef: expectedHeadSha,
+    });
+    if (probe.state === "clean")
+        return { action: "clean", detail: { probe: "clean", headSha: expectedHeadSha } };
+    if (probe.state !== "conflict") {
+        return { action: "skipped", detail: { probe: probe.state, reason: probe.reason } };
+    }
+    const probeDetail = { probe: "conflict", files: probe.files, headSha: expectedHeadSha };
+    if (conflictRepairSpent(issue.id, instance.id).spent) {
+        return { action: "repair_spent", detail: probeDetail };
+    }
+    // Every mutation re-checks the sibling: it may have been closed, re-targeted or
+    // picked up by a worker since the checks above.
+    let drifted = false;
+    const guard = () => {
+        const drift = siblingDrift(issue, instance.id);
+        if (drift) {
+            drifted = true;
+            return drift;
+        }
+        return activeReason(issue.id);
+    };
+    // One push-only sync per episode: a spent sync goes straight to the repair round.
+    let files = probe.files;
+    if (!checksWaitSyncSpent(issue.id, instance.id)) {
+        const sync = await runMergeConflictSync({
+            issueId: issue.id,
+            instanceId: instance.id,
+            repo: issue.repo,
+            branch,
+            baseBranch: issue.baseBranch,
+            prNumber,
+            mergeReason: `${issue.baseBranch} advanced and PR #${prNumber} now conflicts with it.`,
+            entry: "base_advanced",
+            expectedHeadSha,
+            beforePush: guard,
+        });
+        if (sync.outcome === "synced") {
+            const wait = queueChecksWaitAfterBaseSync({
+                issueId: issue.id,
+                instanceId: instance.id,
+                baseBranch: issue.baseBranch,
+                branch,
+                prNumber,
+                headSha: sync.headSha,
+                guard,
+            });
+            return {
+                action: "synced",
+                detail: {
+                    ...probeDetail,
+                    syncedHeadSha: sync.headSha,
+                    ...(wait
+                        ? { workItemId: wait.id, ...(wait.kept ? { checksWait: "queued developer round" } : {}) }
+                        : { reason: "issue became busy or left its stage before the checks wait queued" }),
+                },
+            };
+        }
+        if (sync.outcome === "skipped" && sync.code === "tip_moved") {
+            return { action: "hand_edited", detail: { ...probeDetail, reason: sync.reason } };
+        }
+        if (sync.outcome === "skipped" && sync.code === "refused") {
+            return { action: drifted ? "skipped" : "active_worker", detail: { ...probeDetail, reason: sync.reason } };
+        }
+        if (sync.outcome === "escalate" || sync.outcome === "skipped") {
+            return { action: sync.outcome === "escalate" ? "failed" : "skipped", detail: { ...probeDetail, reason: sync.reason } };
+        }
+        if (sync.outcome !== "repair_needed") {
+            return { action: "skipped", detail: { ...probeDetail, reason: `unexpected sync outcome ${sync.outcome}` } };
+        }
+        if (sync.files.length > 0)
+            files = sync.files;
+    }
+    // The textual-conflict path returns before the sync's own pre-push tip read, so
+    // re-read origin right before the repair mutation: a hand edit is never touched.
+    // Bounded like the sync's own git calls: a stalled remote must not hold up the
+    // remaining siblings, and a timed-out read (null) fails closed as hand_edited.
+    const tipNow = await readRemoteTip({ cwd: repoPath, branch, timeoutMs: DEFAULT_BASE_FETCH_TIMEOUT_MS });
+    const lastPushedNow = lastDealerPushedSha(issue);
+    if (tipNow !== lastPushedNow) {
+        return { action: "hand_edited", detail: { ...probeDetail, remoteSha: tipNow, lastPushedSha: lastPushedNow } };
+    }
+    const queued = queueConflictRepairRound({
+        issueId: issue.id,
+        instanceId: instance.id,
+        baseBranch: issue.baseBranch,
+        branch,
+        files,
+        entry: "base_advanced",
+        guard,
+    });
+    if (!queued) {
+        return { action: "skipped", detail: { ...probeDetail, reason: "issue became busy or left its stage before the repair round queued" } };
+    }
+    return { action: "repair_queued", detail: { ...probeDetail, files, workItemId: queued.id, round: queued.round } };
+}
+/** Why the sibling is no longer the open PR the scan validated: closed or moved to
+ * another stage outside the open set, a different (or no) active workflow instance,
+ * or a changed branch, PR, repo or base. */
+function siblingDrift(expected, instanceId) {
+    const now = getIssue(expected.id);
+    if (!now)
+        return "issue no longer exists";
+    if (!SIBLING_STATUSES.includes(now.status))
+        return `issue left its open stage (now ${now.status})`;
+    if (getActiveWorkflowInstance(expected.id)?.id !== instanceId)
+        return "its workflow instance is no longer active";
+    if (now.branch !== expected.branch ||
+        now.prNumber !== expected.prNumber ||
+        now.repo !== expected.repo ||
+        now.baseBranch !== expected.baseBranch) {
+        return "its branch, PR, repo or base changed";
+    }
+    return null;
+}
+/** Why the sibling is not idle: a running worker session, a leased work item (an
+ * effect mid-flight), or its own auto-merge running in this process. */
+function activeReason(issueId) {
+    if (getActiveWorkerSessionForIssue(issueId))
+        return "a worker session is running";
+    if (listWorkItemsForIssue(issueId).some((w) => w.status === "leased"))
+        return "a work item is leased";
+    if (isAutoMergeInFlight(issueId))
+        return "its auto-merge is in flight";
+    return null;
+}
+/**
+ * Events that prove Dealer itself put a head on origin. `pull_request.opened` and
+ * the issue's `headSha` are deliberately absent: a publish-only handoff accepts an
+ * origin someone pushed outside the coordinator and records that observed head
+ * there, so neither says who pushed it.
+ */
+const PUSH_EVENT_TYPES = ["checkpoint.observed", "branch.pushed", "auto_merge.conflict_sync"];
+/**
+ * The single SHA Dealer last pushed to the issue branch: the latest of a developer
+ * push checkpoint, a lease push, or a push-only base sync that moved the head (in
+ * event order). Null when no event proves a push — the tip is then never Dealer's.
+ * An older Dealer head is not accepted — a reset back to it is a hand edit too.
+ */
+function lastDealerPushedSha(issue) {
+    const rows = getDb()
+        .prepare(`SELECT type, payload_json AS payloadJson FROM workflow_events
+       WHERE issue_id = ? AND type IN (${PUSH_EVENT_TYPES.map(() => "?").join(", ")})
+       ORDER BY ts ASC, rowid ASC`)
+        .all(issue.id, ...PUSH_EVENT_TYPES);
+    let last = null;
+    for (const row of rows) {
+        let p;
+        try {
+            p = JSON.parse(row.payloadJson ?? "{}");
+        }
+        catch {
+            continue; // unreadable audit payload names no head
+        }
+        let sha = null;
+        if (row.type === "checkpoint.observed")
+            sha = p.kind === "branch_pushed" ? p.observedSha : null;
+        else if (row.type === "branch.pushed")
+            sha = p.newSha ?? p.localSha;
+        // A sync whose merge left the head unchanged pushed nothing new: its head is
+        // whatever origin already held, not proof of a Dealer push.
+        else if (p.outcome === "synced" && p.mergeChangedHead !== false)
+            sha = p.headSha;
+        if (typeof sha === "string" && sha)
+            last = sha;
+    }
+    return last;
+}
+function recordBaseAdvanced(issueId, payload) {
+    try {
+        getDb().transaction(() => {
+            const issue = getIssue(issueId);
+            if (!issue)
+                return;
+            const instance = getActiveWorkflowInstance(issueId);
+            appendWorkflowEvent({
+                issueId,
+                workflowInstanceId: instance?.id ?? null,
+                workerSessionId: null,
+                type: "base.advanced",
+                actorType: "system",
+                stage: issue.status,
+                round: issue.currentRound,
+                payload,
+            });
+        })();
+    }
+    catch (err) {
+        // Audit only — never fail the scan for a sibling.
+        console.error("[coordinator] base.advanced event", issueId, err);
+    }
+}

package/bundle/server/dist/coordinator/commands.js

@@ -29,8 +29,9 @@ import { reasonForWorkerFailedEvent } from "./failure-reason.js";
 import { recordCausesForWorkerFailedEvent } from "./failure-cause.js";
 import { routeDeveloperOutcome, routeReviewerOutcome, } from "./routing.js";
 import { projectDeveloperRoute, projectReviewerRoute } from "./projection.js";
-import { MERGE_FAILURE_EVIDENCE_KEY, MERGE_FAILURE_RESPONSE_OPTIONS, PUSH_DIVERGENCE_EVIDENCE_KEY, PUSH_DIVERGENCE_RESPONSE_OPTIONS, WORKTREE_BLOCKER_EVIDENCE_KEY, normalizeResolutionNote, parseHumanResolution, resolveHumanActionOutcome, } from "./human-resolution.js";
+import { MERGE_CONFLICT_FILES_EVIDENCE_KEY, MERGE_FAILURE_EVIDENCE_KEY, MERGE_FAILURE_RESPONSE_OPTIONS, PUSH_DIVERGENCE_EVIDENCE_KEY, PUSH_DIVERGENCE_RESPONSE_OPTIONS, WORKTREE_BLOCKER_EVIDENCE_KEY, normalizeResolutionNote, parseHumanResolution, resolveHumanActionOutcome, } from "./human-resolution.js";
 import { AUTO_MERGE_INTENT, finalizeAutoMerge } from "./auto-merge.js";
+import { conflictRepairSpent, queueConflictRepairRound } from "./merge-conflict-sync.js";
 import { OPERATOR_VERIFICATION_ARTIFACT_KIND, OPERATOR_VERIFICATION_RESPONSE_OPTIONS, } from "./operator-criteria.js";
 import { externalMergeStateForIssue } from "./external-merge.js";
 import { detectNonConvergence, formatNonConvergenceReason, reviewHistoryFromEvents, } from "./non-convergence.js";
@@ -338,6 +339,17 @@ export async function applyCompletion(workItemId, leaseToken, outcome) {
     if (outcome.kind === "checks_pending") {
         return applyChecksPendingCompletion(workItemId, leaseToken, outcome);
     }
+    // NOT-354: the PR conflicts with its base, so CI will never start. The effect
+    // already ran the base sync; this re-polls the synced head, queues the one
+    // conflict-repair round, or escalates once — never a "Waiting for CI" deferral.
+    if (outcome.kind === "checks_conflicting") {
+        return applyChecksConflictCompletion(workItemId, leaseToken, outcome);
+    }
+    // NOT-355: the pre-publish probe found a base conflict before anything was pushed.
+    // Queue the one conflict-repair round (needs the lease), or escalate once.
+    if (outcome.kind === "base_conflict") {
+        return applyBaseConflictCompletion(workItemId, leaseToken, outcome);
+    }
     const routed = getDb().transaction(() => {
         const before = getWorkItem(workItemId);
         if (!before)
@@ -434,6 +446,225 @@ function applyBaseFetchDeferralCompletion(workItemId, leaseToken, failure) {
 function applyChecksPendingCompletion(workItemId, leaseToken, pending) {
     return applyDeferralCompletion(workItemId, leaseToken, pending, (item, issue, instance) => deferLeasedWorkItemForChecksPending(item, leaseToken, pending, issue, instance), (issue, instance, item) => routeChecksWaitEscalation(issue, instance, item, pending));
 }
+/**
+ * NOT-354: act on the base sync a conflicting PR's CI wait ran. A clean sync is a
+ * normal CI wait on the pushed head, anchored at the original wait start (the
+ * deferral keeps any persisted `checksWaitStartedAt`), so the ceiling is never
+ * reset. A textual conflict queues the one NOT-310 conflict-repair round while
+ * finishing this item; anything else escalates once.
+ */
+function applyChecksConflictCompletion(workItemId, leaseToken, outcome) {
+    const { sync } = outcome;
+    if (sync.result === "synced") {
+        const headSha = sync.headSha ?? outcome.headSha;
+        return applyChecksPendingCompletion(workItemId, leaseToken, {
+            kind: "checks_pending",
+            reason: `Synced ${outcome.baseBranch} into PR #${outcome.prNumber}; waiting for CI on ${headSha.slice(0, 12)} - no attempt spent`,
+            branch: outcome.branch,
+            prNumber: outcome.prNumber,
+            headSha,
+            waitStartedAt: outcome.waitStartedAt,
+        });
+    }
+    return getDb().transaction(() => {
+        const before = getWorkItem(workItemId);
+        if (!before)
+            return { applied: false, reason: "not_found" };
+        if (before.status === "done" || before.status === "dead" || before.status === "cancelled") {
+            return { applied: false, reason: "already_terminal" };
+        }
+        const issue = getIssue(before.issueId);
+        if (!issue)
+            return { applied: false, reason: "not_found" };
+        const instance = getActiveWorkflowInstance(before.issueId);
+        if (!instance || instance.id !== before.workflowInstanceId) {
+            return { applied: false, reason: "no_active_instance" };
+        }
+        if (sync.result === "repair") {
+            const queued = queueConflictRepairRound({
+                issueId: issue.id,
+                instanceId: instance.id,
+                baseBranch: outcome.baseBranch,
+                branch: outcome.branch,
+                files: sync.files,
+                entry: "checks_wait",
+                finish: { workItemId, leaseToken, result: outcome },
+            });
+            if (queued) {
+                const session = before.workerSessionId ? getWorkerSession(before.workerSessionId) : null;
+                appendWorkflowEvent({
+                    issueId: issue.id,
+                    workflowInstanceId: instance.id,
+                    workerSessionId: before.workerSessionId,
+                    type: "worker.completed",
+                    actorType: "developer",
+                    stage: getIssue(issue.id).status,
+                    round: issue.currentRound,
+                    payload: {
+                        ...workerSessionPayload({
+                            runtime: session?.runtime,
+                            model: session?.model,
+                            sessionId: before.workerSessionId ?? "",
+                            worktreePath: session?.worktreePath,
+                        }),
+                        outcome: outcome.kind,
+                        ...(isPublishOnlyItem(before) ? { publishOnly: true } : {}),
+                    },
+                });
+                return {
+                    applied: true,
+                    issueStatus: getIssue(issue.id).status,
+                    nextWorkItemId: queued.id,
+                    humanActionId: null,
+                    instanceCompleted: false,
+                };
+            }
+            // Lease lost, or the issue left its developer stage — a lost lease applies
+            // nothing; otherwise fall through to the single escalation.
+            if (!getWorkItem(workItemId) || getWorkItem(workItemId).leaseToken !== leaseToken) {
+                return { applied: false, reason: "lease_lost" };
+            }
+        }
+        const item = finishWorkItem(workItemId, leaseToken, { status: "done", result: outcome });
+        if (!item)
+            return { applied: false, reason: "lease_lost" };
+        const reason = sync.result === "escalate"
+            ? sync.reason
+            : `PR #${outcome.prNumber} conflicts with ${outcome.baseBranch}; the conflict-repair round could not be queued.`;
+        const evidence = sync.result === "escalate" ? sync.evidence : { checksConflict: true };
+        return routeChecksConflictEscalation(issue, instance, item, outcome, reason, evidence, "checksConflict");
+    })();
+}
+/**
+ * NOT-355: the pre-publish probe found the unpushed branch conflicts with its base.
+ * Queue one conflict-repair round naming the files while finishing this item — the
+ * developer merges the base and the next round's normal push proceeds. When this
+ * episode already spent its conflict-repair round (the probe still conflicts after
+ * it), escalate once with the file list instead; never a second round.
+ */
+function applyBaseConflictCompletion(workItemId, leaseToken, outcome) {
+    return getDb().transaction(() => {
+        const before = getWorkItem(workItemId);
+        if (!before)
+            return { applied: false, reason: "not_found" };
+        if (before.status === "done" || before.status === "dead" || before.status === "cancelled") {
+            return { applied: false, reason: "already_terminal" };
+        }
+        const issue = getIssue(before.issueId);
+        if (!issue)
+            return { applied: false, reason: "not_found" };
+        const instance = getActiveWorkflowInstance(before.issueId);
+        if (!instance || instance.id !== before.workflowInstanceId) {
+            return { applied: false, reason: "no_active_instance" };
+        }
+        const facts = { kind: outcome.kind, branch: outcome.branch, baseBranch: outcome.baseBranch, prNumber: null, headSha: outcome.headSha };
+        const filesText = outcome.files.length > 0 ? ` Conflicting files: ${outcome.files.join(", ")}.` : "";
+        const spent = conflictRepairSpent(issue.id, instance.id).spent;
+        if (!spent) {
+            const queued = queueConflictRepairRound({
+                issueId: issue.id,
+                instanceId: instance.id,
+                baseBranch: outcome.baseBranch,
+                branch: outcome.branch,
+                files: outcome.files,
+                entry: "pre_publish",
+                finish: { workItemId, leaseToken, result: outcome },
+            });
+            if (queued) {
+                const session = before.workerSessionId ? getWorkerSession(before.workerSessionId) : null;
+                appendWorkflowEvent({
+                    issueId: issue.id,
+                    workflowInstanceId: instance.id,
+                    workerSessionId: before.workerSessionId,
+                    type: "worker.completed",
+                    actorType: "developer",
+                    stage: getIssue(issue.id).status,
+                    round: issue.currentRound,
+                    payload: {
+                        ...workerSessionPayload({
+                            runtime: session?.runtime,
+                            model: session?.model,
+                            sessionId: before.workerSessionId ?? "",
+                            worktreePath: session?.worktreePath,
+                        }),
+                        outcome: outcome.kind,
+                    },
+                });
+                return {
+                    applied: true,
+                    issueStatus: getIssue(issue.id).status,
+                    nextWorkItemId: queued.id,
+                    humanActionId: null,
+                    instanceCompleted: false,
+                };
+            }
+            if (!getWorkItem(workItemId) || getWorkItem(workItemId).leaseToken !== leaseToken) {
+                return { applied: false, reason: "lease_lost" };
+            }
+        }
+        const item = finishWorkItem(workItemId, leaseToken, { status: "done", result: outcome });
+        if (!item)
+            return { applied: false, reason: "lease_lost" };
+        const reason = spent
+            ? `Branch ${outcome.branch} conflicts with ${outcome.baseBranch} and was not published. ` +
+                `Dealer already ran one conflict-repair round; the branch still conflicts.${filesText}`
+            : `Branch ${outcome.branch} conflicts with ${outcome.baseBranch} and was not published; ` +
+                `the conflict-repair round could not be queued.${filesText}`;
+        return routeChecksConflictEscalation(issue, instance, item, facts, reason, { [MERGE_CONFLICT_FILES_EVIDENCE_KEY]: outcome.files }, "baseProbeConflict");
+    })();
+}
+/** NOT-354: the one escalation for a conflicting PR — same shape as the CI-wait
+ * ceiling escalation, naming the PR, base, and (when known) the conflicting files.
+ * NOT-355 reuses it for an unpublished branch (`prNumber` null) under its own key. */
+function routeChecksConflictEscalation(issue, instance, item, outcome, reason, evidence, factsKey) {
+    const ev = eventEmitter(issue, instance, item.workerSessionId, "needs_human", issue.currentRound);
+    const session = item.workerSessionId ? getWorkerSession(item.workerSessionId) : null;
+    for (const type of capEscalationEvents()) {
+        ev.emit(type, {
+            actorType: "developer",
+            payload: {
+                ...workerSessionPayload({
+                    runtime: session?.runtime ?? null,
+                    model: session?.model ?? null,
+                    sessionId: item.workerSessionId ?? "",
+                    worktreePath: session?.worktreePath,
+                }),
+                outcome: outcome.kind,
+                reason,
+                branch: outcome.branch,
+                baseBranch: outcome.baseBranch,
+                prNumber: outcome.prNumber,
+                headSha: outcome.headSha,
+            },
+        });
+    }
+    applyProjectionTransition(issue, { issueStatus: "needs_human", currentOwner: "human", currentIntent: reason, events: capEscalationEvents() }, {});
+    const action = createHumanAction({
+        issueId: issue.id,
+        workflowInstanceId: instance.id,
+        actionType: "policy_escalation",
+        reason,
+        question: questionFor("policy_escalation", reason),
+        evidence: {
+            ...evidence,
+            [factsKey]: {
+                branch: outcome.branch,
+                baseBranch: outcome.baseBranch,
+                prNumber: outcome.prNumber,
+                headSha: outcome.headSha,
+            },
+        },
+        responseOptions: responseOptionsFor("policy_escalation"),
+    });
+    ev.emit("human_action.requested", { payload: { actionType: "policy_escalation", actionId: action.id } });
+    return {
+        applied: true,
+        issueStatus: "needs_human",
+        nextWorkItemId: null,
+        humanActionId: action.id,
+        instanceCompleted: false,
+    };
+}
 /**
  * NOT-311: the CI wait passed its ceiling — hand to a human with the PR and head SHA
  * CI never proved, without spending infra attempts. Mirrors the usage-cap ceiling