agent-dealer 1.2.9 → 1.2.10

package/bundle/server/dist/adapters/github.js

@@ -25,6 +25,10 @@ export function parsePrView(json) {
     };
 }
 export const PR_VIEW_FIELDS = "number,url,baseRefName,headRefName,headRefOid,isDraft";
+/** Normalizes `gh pr view --json mergeable` output; anything unrecognized is UNKNOWN. */
+export function parsePrMergeableState(raw) {
+    return raw === "CONFLICTING" || raw === "MERGEABLE" ? raw : "UNKNOWN";
+}
 const FAILURE_STATES = new Set([
     "failure",
     "error",
@@ -394,6 +398,15 @@ export function createGithubAdapter(exec = defaultExec) {
                 return null;
             }
         },
+        async prMergeableState({ cwd, number }) {
+            try {
+                const raw = await ghPrView(exec, cwd, "mergeable", String(number));
+                return parsePrMergeableState(raw?.mergeable);
+            }
+            catch {
+                return "UNKNOWN";
+            }
+        },
         async publishReview({ cwd, number, event, bodyFilePath }) {
             const result = await runReview(exec, cwd, number, event, bodyFilePath);
             if (result.ok || event === "COMMENT" || !OWN_PR_REVIEW_PATTERN.test(result.reason)) {

package/bundle/server/dist/adapters/github.test.js

@@ -114,6 +114,19 @@ test("viewPr: a retry can find the already-created PR by explicit branch even wi
     const view = await createGithubAdapter(exec).viewPr({ cwd: "/repo", branch: "issue-4e5eb611" });
     assert.equal(view?.number, 42);
 });
+test("NOT-354: prMergeableState reads `mergeable` by PR number; unknown values and failures are UNKNOWN", async () => {
+    const conflicting = queuedExec([{ stdout: JSON.stringify({ mergeable: "CONFLICTING" }) }]);
+    assert.equal(await createGithubAdapter(conflicting.exec).prMergeableState({ cwd: "/repo", number: 42 }), "CONFLICTING");
+    assert.deepEqual(conflicting.calls[0], ["pr", "view", "42", "--json", "mergeable"]);
+    const mergeable = queuedExec([{ stdout: JSON.stringify({ mergeable: "MERGEABLE" }) }]);
+    assert.equal(await createGithubAdapter(mergeable.exec).prMergeableState({ cwd: "/repo", number: 42 }), "MERGEABLE");
+    const unknown = queuedExec([{ stdout: JSON.stringify({ mergeable: "UNKNOWN" }) }]);
+    assert.equal(await createGithubAdapter(unknown.exec).prMergeableState({ cwd: "/repo", number: 42 }), "UNKNOWN");
+    const odd = queuedExec([{ stdout: JSON.stringify({ mergeable: "something-new" }) }]);
+    assert.equal(await createGithubAdapter(odd.exec).prMergeableState({ cwd: "/repo", number: 42 }), "UNKNOWN");
+    const failing = queuedExec([{ error: "HTTP 502" }]);
+    assert.equal(await createGithubAdapter(failing.exec).prMergeableState({ cwd: "/repo", number: 42 }), "UNKNOWN");
+});
 test("checksSnapshot looks up the PR's check rollup by explicit selector (number preferred), never a bare `gh pr view`", async () => {
     const success = { stdout: JSON.stringify({ statusCheckRollup: [{ conclusion: "success" }] }) };
     const byNumber = queuedExec([success]);

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

@@ -31,6 +31,7 @@ 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 { AUTO_MERGE_INTENT, finalizeAutoMerge } from "./auto-merge.js";
+import { 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,12 @@ 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);
+    }
     const routed = getDb().transaction(() => {
         const before = getWorkItem(workItemId);
         if (!before)
@@ -434,6 +441,146 @@ 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);
+    })();
+}
+/** 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. */
+function routeChecksConflictEscalation(issue, instance, item, outcome, reason, evidence) {
+    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,
+            checksConflict: {
+                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

package/bundle/server/dist/coordinator/developer-effect.js

@@ -17,6 +17,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { parsePhaseBudget, parseProfileSnapshot, roleCeiling } from "@agent-dealer/shared";
+import { runMergeConflictSync } from "./merge-conflict-sync.js";
 import { getTaskSnapshot } from "./commands.js";
 import { extractOperatorCriteria } from "./operator-criteria.js";
 import { buildDeveloperPrompt } from "./prompts.js";
@@ -28,7 +29,7 @@ import { recordIssueBaseSha } from "../repository/issues.js";
 import { ensureIssueRepoCheckout, roleWorktreePathForResolution, resolveCheckoutBaseBranch, } from "../adapters/managed-repo.js";
 import { baseRefCandidates, inspectBranchProgress } from "./branch-progress.js";
 import { prepareWorkerDeckConnection, releaseWorkerDeckConnection, verifyWorkerDeckConnection } from "../adapters/agent-deck-bind.js";
-import { realGithubAdapter, pollPrChecksDetailed } from "../adapters/github.js";
+import { realGithubAdapter, pollPrChecksDetailed, } from "../adapters/github.js";
 import { checksWaitCeilingExceeded, checksWaitCeilingMs } from "./checks-wait-config.js";
 import { museCapabilitySafetyNetAfterSession } from "../adapters/muse-capability.js";
 import { getOrAssignSessionCorrelationId, getWorkerSession, mergeSessionMetadata, patchRunningSession, recordSessionProcess, setSessionInputSha } from "../repository/worker-sessions.js";
@@ -328,6 +329,11 @@ function checksWaitStartedAtFromPayload(payloadJson) {
  * A missing/unknown workflow answer (no adapter method, unreadable base ref) waits
  * fail-closed: sending an unverified PR to review is the outcome this exists to
  * prevent, and the wait ceiling still bounds it.
+ *
+ * NOT-354: "no checks" on a CONFLICTING PR is not a queued wait — GitHub creates no
+ * merge ref, so the workflow never starts. That case returns `conflicting` (and the
+ * `conflicting` milestone reason) so the caller runs the base sync instead of
+ * deferring. UNKNOWN mergeability is "not computed yet" and keeps today's wait.
  */
 async function resolveChecksWait(opts) {
     const waitStartedAt = checksWaitStartedAtFromPayload(opts.payloadJson) ?? opts.pollStartedAt;
@@ -350,6 +356,16 @@ async function resolveChecksWait(opts) {
         if (hasWorkflow === false) {
             return { pending: null, milestoneReason: "none_no_workflow" };
         }
+        let mergeable = "UNKNOWN";
+        try {
+            mergeable = (await opts.github.prMergeableState?.({ cwd: opts.cwd, number: opts.prNumber })) ?? "UNKNOWN";
+        }
+        catch {
+            mergeable = "UNKNOWN";
+        }
+        if (mergeable === "CONFLICTING") {
+            return { pending: null, milestoneReason: "conflicting", conflicting: { waitStartedAt } };
+        }
         return {
             pending: { ...base, reason: "Waiting for CI (queued) - no attempt spent" },
             milestoneReason: "none_with_workflow",
@@ -364,6 +380,60 @@ async function resolveChecksWait(opts) {
     }
     return { pending: null };
 }
+/**
+ * NOT-354: a conflicting PR's CI wait runs the NOT-310 base sync (`checks_wait`
+ * entry: plain push, never force/rebase, one sync + one repair round per episode)
+ * from the effect, which still holds the lease. applyCompletion acts on the
+ * result. A refusal (`skipped`) becomes the single escalation, never a wait.
+ */
+async function checksConflictOutcome(ctx, deps, opts) {
+    const sync = deps.conflictSync ?? runMergeConflictSync;
+    const conflictReason = `PR #${opts.prNumber} conflicts with ${opts.baseBranch} (mergeable: CONFLICTING), ` +
+        `so its CI cannot start.`;
+    const base = {
+        kind: "checks_conflicting",
+        branch: opts.branch,
+        baseBranch: opts.baseBranch,
+        prNumber: opts.prNumber,
+        headSha: opts.headSha,
+        waitStartedAt: opts.waitStartedAt,
+    };
+    let result;
+    try {
+        result = await sync({
+            issueId: ctx.issue.id,
+            instanceId: ctx.instance.id,
+            repo: ctx.issue.repo,
+            branch: opts.branch,
+            baseBranch: opts.baseBranch,
+            prNumber: opts.prNumber,
+            mergeReason: conflictReason,
+            entry: "checks_wait",
+        });
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        result = { outcome: "skipped", reason: `base sync errored: ${detail}` };
+    }
+    switch (result.outcome) {
+        case "synced":
+            return { ...base, sync: { result: "synced", headSha: result.headSha } };
+        case "repair_needed":
+            return { ...base, sync: { result: "repair", files: result.files } };
+        case "escalate":
+            return { ...base, sync: { result: "escalate", reason: result.reason, evidence: result.evidence } };
+        default:
+            // skipped (or a merge-only outcome that cannot occur on this entry).
+            return {
+                ...base,
+                sync: {
+                    result: "escalate",
+                    reason: `${conflictReason} Dealer could not sync ${opts.baseBranch}: ${result.outcome === "skipped" ? result.reason : result.outcome}`,
+                    evidence: { checksConflict: true },
+                },
+            };
+    }
+}
 /**
  * Infra retry that skips the agent: publish whatever the branch already carries. Uses the
  * issue repo as `gh` cwd and `origin/<branch>` as the verified head (any worktree was
@@ -667,6 +737,16 @@ async function runPublishOnlyHandoff(ctx, deps, branchName) {
             author: "system",
             content: { snapshot: checks, prNumber: prView.number, headSha: prView.headRefOid },
         });
+        // NOT-354: a conflicting PR never gets checks — sync the base instead of waiting.
+        if (wait.conflicting) {
+            return checksConflictOutcome(ctx, deps, {
+                branch: branchName,
+                baseBranch: prView.baseRefName,
+                prNumber: prView.number,
+                headSha: prView.headRefOid,
+                waitStartedAt: wait.conflicting.waitStartedAt,
+            });
+        }
         // NOT-311: still-waiting CI defers with backoff (no attempt spent) instead of
         // timing out the session. An aborted wait keeps today's `timed_out`.
         if (wait.pending)
@@ -1811,6 +1891,18 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
             author: "system",
             content: { snapshot: checks, prNumber: prView.number, headSha: prView.headRefOid },
         });
+        // NOT-354: a conflicting PR never gets checks — sync the base instead of waiting.
+        // The worktree goes first: the sync refuses a branch still checked out elsewhere.
+        if (wait.conflicting) {
+            await bestEffortRemove(repoPath, worktreePath);
+            return checksConflictOutcome(ctx, deps, {
+                branch: branchName,
+                baseBranch: prView.baseRefName,
+                prNumber: prView.number,
+                headSha: prView.headRefOid,
+                waitStartedAt: wait.conflicting.waitStartedAt,
+            });
+        }
         // NOT-311: still-waiting CI defers with backoff (no attempt spent) instead of
         // timing out the session. An aborted wait keeps today's `timed_out`.
         if (wait.pending) {

package/bundle/server/dist/coordinator/developer-effect.test.js

@@ -162,6 +162,14 @@ function fakeGithub(opts = {}) {
             throw new Error("publishReview is unused by the developer effect");
         }
     };
+    if (opts.mergeable !== undefined) {
+        const mergeable = opts.mergeable;
+        adapter.prMergeableState = async ({ number }) => {
+            if (number == null)
+                throw new Error("fakeGithub.prMergeableState requires an explicit PR number");
+            return typeof mergeable === "function" ? mergeable() : mergeable;
+        };
+    }
     return adapter;
 }
 test("clean handoff: real worktree, real push, fake GitHub — issue moves to reviewing with a reviewer work item queued", async () => {
@@ -667,6 +675,170 @@ test("NOT-311: none with an unknown workflow answer waits fail-closed", async ()
     const completed = listWorkflowEventsForIssue(issueId).find((e) => e.type === "checks.completed");
     assert.equal(JSON.parse(completed.payloadJson ?? "{}").reason, "none_with_workflow");
 });
+/** NOT-354: records every base-sync invocation and answers from `respond`. */
+function recordingConflictSync(respond) {
+    const calls = [];
+    return {
+        calls,
+        sync: async (call) => {
+            calls.push(call);
+            return respond(call, calls.length);
+        },
+    };
+}
+async function withShortDeferralBackoff(fn) {
+    const prevBase = process.env.DECK_OUTAGE_BACKOFF_BASE_MS;
+    const prevMax = process.env.DECK_OUTAGE_BACKOFF_MAX_MS;
+    process.env.DECK_OUTAGE_BACKOFF_BASE_MS = "10";
+    process.env.DECK_OUTAGE_BACKOFF_MAX_MS = "10";
+    try {
+        await fn();
+    }
+    finally {
+        if (prevBase === undefined)
+            delete process.env.DECK_OUTAGE_BACKOFF_BASE_MS;
+        else
+            process.env.DECK_OUTAGE_BACKOFF_BASE_MS = prevBase;
+        if (prevMax === undefined)
+            delete process.env.DECK_OUTAGE_BACKOFF_MAX_MS;
+        else
+            process.env.DECK_OUTAGE_BACKOFF_MAX_MS = prevMax;
+    }
+}
+for (const state of ["UNKNOWN", "MERGEABLE"]) {
+    test(`NOT-354: none + pull_request workflow + ${state} PR keeps the queued CI wait, no base sync`, async () => {
+        const issueId = await makeIssue();
+        const recorder = recordingConflictSync(async () => {
+            throw new Error("a non-conflicting PR must never run the base sync");
+        });
+        registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, {
+            deckCallTool: okDeckCallTool,
+            spawn: commitingSpawn,
+            github: fakeGithub({ checks: "none", pullRequestWorkflow: true, mergeable: state }),
+            conflictSync: recorder.sync,
+        }));
+        startWorkflow(issueId);
+        await pump(1);
+        assert.equal(recorder.calls.length, 0);
+        const issue = getIssue(issueId);
+        assert.equal(issue.status, "developing");
+        assert.match(issue.currentIntent ?? "", /Waiting for CI \(queued\) - no attempt spent/);
+        const deferred = listWorkflowEventsForIssue(issueId).filter((e) => e.type === "worker.deferred");
+        assert.equal(deferred.length, 1);
+        assert.equal(JSON.parse(deferred[0].payloadJson ?? "{}").outcome, "checks_pending");
+        const completed = listWorkflowEventsForIssue(issueId).find((e) => e.type === "checks.completed");
+        assert.equal(JSON.parse(completed.payloadJson ?? "{}").reason, "none_with_workflow");
+    });
+}
+test("NOT-354: none + pull_request workflow + CONFLICTING runs the base sync instead of a queued wait; a clean sync re-polls and hands off", async () => {
+    await withShortDeferralBackoff(async () => {
+        let mergeable = "CONFLICTING";
+        let ci = "none";
+        let spawns = 0;
+        const countingSpawn = async (input) => {
+            spawns++;
+            return commitingSpawn(input);
+        };
+        const issueId = await makeIssue();
+        const branch = issueBranchName(issueId);
+        const recorder = recordingConflictSync(async () => ({ outcome: "synced", headSha: git(remote, "rev-parse", branch) }));
+        registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, {
+            deckCallTool: okDeckCallTool,
+            spawn: countingSpawn,
+            github: fakeGithub({ checks: () => ci, pullRequestWorkflow: true, mergeable: () => mergeable }),
+            conflictSync: recorder.sync,
+        }));
+        startWorkflow(issueId);
+        await pump(1);
+        // The coordinator invoked the NOT-310 sync through its checks-wait entry.
+        assert.equal(recorder.calls.length, 1);
+        const call = recorder.calls[0];
+        assert.equal(call.entry, "checks_wait");
+        assert.equal(call.branch, branch);
+        assert.equal(call.baseBranch, "main");
+        assert.equal(call.repo, repo);
+        assert.equal(call.mergePr, undefined, "the checks-wait entry never merges");
+        assert.match(call.mergeReason, /conflicts with main/);
+        const events = listWorkflowEventsForIssue(issueId);
+        const completed = events.find((e) => e.type === "checks.completed");
+        assert.equal(JSON.parse(completed.payloadJson ?? "{}").reason, "conflicting");
+        const deferred = events.filter((e) => e.type === "worker.deferred");
+        assert.equal(deferred.length, 1, "the synced head waits on a normal CI re-poll");
+        const deferredReason = JSON.parse(deferred[0].payloadJson ?? "{}").reason;
+        assert.doesNotMatch(deferredReason, /Waiting for CI \(queued\)/);
+        assert.match(deferredReason, /Synced main into PR #\d+/);
+        const item = listWorkItemsForIssue(issueId)[0];
+        const payload = JSON.parse(item.payloadJson ?? "{}");
+        assert.equal(payload.publishOnly, true, "the re-poll takes the no-agent publish path");
+        assert.ok(payload.checksWaitStartedAt, "the wait keeps its original ceiling anchor");
+        // GitHub recomputes mergeability on the pushed head and CI runs.
+        await new Promise((resolve) => setTimeout(resolve, 60));
+        mergeable = "MERGEABLE";
+        ci = "success";
+        await pump(1);
+        const issue = getIssue(issueId);
+        assert.equal(issue.status, "reviewing", "the synced head continues to review with no human action");
+        assert.equal(spawns, 1, "the re-poll spawns no agent");
+        assert.equal(recorder.calls.length, 1, "no second sync");
+        assert.equal(listHumanActionsForIssue(issueId).filter((a) => a.status === "open").length, 0);
+        assert.equal(issue.infraAttempts, 0);
+    });
+});
+test("NOT-354: CONFLICTING with an unresolvable conflict queues exactly one conflict-repair round; still conflicting after it escalates once with the files", async () => {
+    const issueId = await makeIssue();
+    const prompts = [];
+    let n = 0;
+    const appendingSpawn = async (input) => {
+        prompts.push(input.prompt);
+        n++;
+        fs.appendFileSync(path.join(input.cwd, "feature.txt"), `round ${n}\n`);
+        git(input.cwd, "add", ".");
+        git(input.cwd, "-c", "user.email=agent@test", "-c", "user.name=Agent", "commit", "-q", "-m", `round ${n}`);
+        return { exitCode: 0, transcript: "Implementation conclusion: done.", logPath: "/dev/null", timedOut: false };
+    };
+    const { runMergeConflictSync } = await import("./merge-conflict-sync.js");
+    // First episode call: the sync hit a textual conflict. Second call: the real
+    // sync, whose episode bound must escalate before touching git.
+    const recorder = recordingConflictSync(async (call, i) => i === 1 ? { outcome: "repair_needed", files: ["shared.txt"] } : runMergeConflictSync(call));
+    registerEffectHandler("developer", (ctx) => runDeveloperEffect(ctx, {
+        deckCallTool: okDeckCallTool,
+        spawn: appendingSpawn,
+        github: fakeGithub({ checks: "none", pullRequestWorkflow: true, mergeable: "CONFLICTING" }),
+        conflictSync: recorder.sync,
+    }));
+    startWorkflow(issueId);
+    await pump(1);
+    let issue = getIssue(issueId);
+    assert.equal(issue.status, "developing");
+    assert.equal(listHumanActionsForIssue(issueId).filter((a) => a.status === "open").length, 0);
+    const pending = listWorkItemsForIssue(issueId).filter((i) => i.status === "pending");
+    assert.equal(pending.length, 1, "exactly one conflict-repair round");
+    assert.equal(pending[0].kind, "developer");
+    assert.equal(pending[0].round, 2);
+    const payload = JSON.parse(pending[0].payloadJson ?? "{}");
+    assert.deepEqual(payload.conflictRepair, { baseBranch: "main", branch: issueBranchName(issueId), files: ["shared.txt"] });
+    assert.equal(payload.publishOnly, undefined, "the repair round is an agent session, not a re-poll");
+    assert.equal(listWorkflowEventsForIssue(issueId).filter((e) => e.type === "worker.deferred").length, 0, "a conflicting PR never defers as a CI wait");
+    await pump(1);
+    assert.equal(prompts.length, 2);
+    assert.ok(prompts[1].includes("main"), "repair prompt names the base");
+    assert.ok(prompts[1].includes("shared.txt"), "repair prompt names the conflicting files");
+    issue = getIssue(issueId);
+    assert.equal(issue.status, "needs_human");
+    assert.equal(recorder.calls.length, 2);
+    assert.equal(listWorkItemsForIssue(issueId).filter((i) => i.status === "pending").length, 0);
+    const open = listHumanActionsForIssue(issueId).filter((a) => a.status === "open");
+    assert.equal(open.length, 1, "escalates exactly once");
+    assert.equal(open[0].actionType, "policy_escalation");
+    assert.match(open[0].reason, /shared\.txt/);
+    assert.match(open[0].reason, /conflicts with main/);
+    assert.doesNotMatch(open[0].reason, /Auto-merge failed/);
+    const evidence = JSON.parse(open[0].evidenceJson);
+    assert.deepEqual(evidence.conflictingFiles, ["shared.txt"]);
+    assert.equal(evidence.mergeFailure, undefined, "a pre-review conflict offers no retry_merge");
+    await pump(1);
+    assert.equal(listHumanActionsForIssue(issueId).filter((a) => a.status === "open").length, 1, "no repeat escalation");
+});
 test("NOT-311: past CHECKS_WAIT_CEILING_MS the wait escalates naming the PR and head SHA", async () => {
     // A zero ceiling makes the very first wait already past it — no clock to inject,
     // no sleeping: the deferral reports escalated and a policy_escalation lands.