agent-dealer 1.2.9 → 1.2.11

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

@@ -17,18 +17,19 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { parsePhaseBudget, parseProfileSnapshot, roleCeiling } from "@agent-dealer/shared";
+import { CONFLICTING_FILES_MAX, runMergeConflictSync } from "./merge-conflict-sync.js";
 import { getTaskSnapshot } from "./commands.js";
 import { extractOperatorCriteria } from "./operator-criteria.js";
 import { buildDeveloperPrompt } from "./prompts.js";
 import { guidanceForNextSession } from "./guidance.js";
 import { realDeveloperSpawn, developerSessionLogPath } from "./spawn.js";
 import { ensureWorktreeDeps, worktreeDepsTimeoutMs, } from "../adapters/worktree-deps.js";
-import { DEFAULT_BASE_FETCH_TIMEOUT_MS, fastForwardLocalBranchToSha, resolveDeveloperWorktree, safeRemoveWorktree, isWorktreeClean, commitsAhead, pushBranch, mergeBase, branchExists, pushBranchRef, revParseHead, revParseRef, fetchRef, salvageDirtyWorktree, dirtyWorktreeRecoveryCommands, withRepoLock, leftoverFingerprint, } from "../adapters/git-worktree.js";
+import { DEFAULT_BASE_FETCH_TIMEOUT_MS, fastForwardLocalBranchToSha, resolveDeveloperWorktree, safeRemoveWorktree, isWorktreeClean, commitsAhead, pushBranch, mergeBase, branchExists, pushBranchRef, revParseHead, revParseRef, fetchRef, salvageDirtyWorktree, dirtyWorktreeRecoveryCommands, withRepoLock, leftoverFingerprint, fetchFreshBase, probeBaseConflict, refExists, } from "../adapters/git-worktree.js";
 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,143 @@ 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 },
+                },
+            };
+    }
+}
+/**
+ * NOT-355: before a developer branch's first push, fetch the base fresh and ask
+ * `git merge-tree --write-tree` whether merging it into the branch would conflict.
+ * Local git, so it never waits on GitHub's lazily computed mergeability. Returns null
+ * to publish exactly as before — on `clean`, or on a git without `--write-tree` (the
+ * only fail-open case) — and otherwise the outcome that blocks the push:
+ * - conflict → `base_conflict` (applyCompletion queues the one repair round);
+ * - base fetch failed → `base_fetch_failed` (NOT-197's network deferral), re-queued
+ *   publish-only so the next run re-probes instead of re-running the agent;
+ * - any other probe failure → `unpushed_commit`, a human decision with the commits kept.
+ * `worktreePath` null probes the local branch ref from the repo (the publish-only
+ * path). Every probe records one `base.probe` event. Never merges, rebases, or
+ * force-pushes.
+ */
+async function prePublishBaseProbe(opts) {
+    const { repoPath, worktreePath, branchName, baseBranch } = opts;
+    const headSha = await (worktreePath ? revParseHead(worktreePath) : revParseRef(repoPath, `refs/heads/${branchName}`)).catch(() => null);
+    const common = { baseBranch, branch: branchName, headSha };
+    const notPublished = (reason) => ({
+        kind: "unpushed_commit",
+        reason: `${reason}; branch ${branchName} was not published.`,
+        branch: branchName,
+        ...(worktreePath ? { worktreePath } : {}),
+    });
+    // A session's commits must survive on the local issue branch before its checkout
+    // goes (strictly a fast-forward — the worker may have committed on a side branch).
+    const keepCommits = async () => {
+        if (!worktreePath)
+            return true;
+        if (!headSha)
+            return false;
+        const kept = await fastForwardLocalBranchToSha({ repo: repoPath, branch: branchName, sha: headSha }).catch(() => false);
+        if (kept)
+            await bestEffortRemove(repoPath, worktreePath);
+        return kept;
+    };
+    const fresh = await fetchFreshBase(repoPath, baseBranch, developerEffectConfig.baseFetchTimeoutMs);
+    if (!fresh.ok) {
+        opts.emit(`Developer · base probe deferred: could not fetch ${baseBranch}`, {
+            result: "deferred",
+            reason: fresh.reason,
+            ...common,
+        });
+        if (!(await keepCommits())) {
+            return notPublished(`Could not fetch ${baseBranch} to probe for conflicts (${fresh.reason})`);
+        }
+        return { kind: "base_fetch_failed", reason: fresh.reason, publishBranch: branchName };
+    }
+    if (!headSha) {
+        opts.emit(`Developer · base probe failed`, { result: "failed", reason: "branch head does not resolve", ...common });
+        return notPublished(`Base conflict probe against ${baseBranch} failed (branch head does not resolve)`);
+    }
+    const probe = await probeBaseConflict({
+        worktreePath: worktreePath ?? repoPath,
+        baseRef: fresh.sha,
+        headRef: worktreePath ? "HEAD" : `refs/heads/${branchName}`,
+        exec: opts.exec,
+    });
+    if (probe.state === "skipped") {
+        console.warn(`[dealer] base probe skipped for ${branchName}: ${probe.reason}`);
+        opts.emit(`Developer · base probe skipped`, { result: "skipped", reason: probe.reason, baseSha: fresh.sha, ...common });
+        return null;
+    }
+    if (probe.state === "error") {
+        opts.emit(`Developer · base probe failed`, { result: "failed", reason: probe.reason, baseSha: fresh.sha, ...common });
+        return notPublished(`Base conflict probe against ${baseBranch} failed (${probe.reason})`);
+    }
+    if (probe.state === "clean") {
+        opts.emit(`Developer · base probe clean`, { result: "clean", baseSha: fresh.sha, ...common });
+        return null;
+    }
+    const files = probe.files.slice(0, CONFLICTING_FILES_MAX);
+    opts.emit(`Developer · branch conflicts with ${baseBranch}; not publishing`, {
+        result: "conflict",
+        files: probe.files,
+        baseSha: fresh.sha,
+        ...common,
+    });
+    // The repair round continues from the local issue branch; keepCommits leaves the
+    // checkout in place when it cannot fast-forward, for crash-recovery inspection.
+    await keepCommits();
+    return { kind: "base_conflict", branch: branchName, baseBranch, headSha, files };
+}
 /**
  * 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
@@ -455,6 +608,20 @@ async function runPublishOnlyHandoff(ctx, deps, branchName) {
                 fetch: true,
             });
             if (progress.state === "unpushed") {
+                // NOT-355: commits origin has never seen (a reclaim, or a probe deferred on a
+                // base fetch) get the same pre-publish probe as a live attempt's first push.
+                if (!(await refExists(cwd, `refs/remotes/origin/${branchName}`))) {
+                    const blocked = await prePublishBaseProbe({
+                        repoPath: cwd,
+                        worktreePath: null,
+                        branchName,
+                        baseBranch,
+                        exec: deps.probeGitExec,
+                        emit: (intent, payload) => milestone("base.probe", intent, payload),
+                    });
+                    if (blocked)
+                        return { kind: "early", outcome: blocked };
+                }
                 setLiveIntent(issue.id, `Developer · pushing ${progress.unpushed} recovered commit${progress.unpushed === 1 ? "" : "s"} (round ${round})`);
                 const recovered = await pushBranchRef({
                     repo: cwd,
@@ -667,6 +834,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)
@@ -1607,6 +1784,21 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
             await bestEffortRemove(repoPath, worktreePath);
             return { kind: "no_pr" };
         }
+        // NOT-355: a branch never pushed before (no PR can exist yet) is probed against
+        // the fresh base first — a conflicting branch gets a repair round, not a
+        // conflicting draft PR CI never runs on. Published branches are NOT-354/310's.
+        if (!(await refExists(worktreePath, `refs/remotes/origin/${branchName}`))) {
+            const blocked = await prePublishBaseProbe({
+                repoPath,
+                worktreePath,
+                branchName,
+                baseBranch,
+                exec: deps.probeGitExec,
+                emit: (intent, payload) => milestone("base.probe", intent, payload),
+            });
+            if (blocked)
+                return blocked;
+        }
         setLiveIntent(issue.id, `Developer · pushing branch (round ${round})`);
         // NOT-220: pushBranch retries once with a lease pin when the divergence is
         // proven safe (remote tip is issue.headSha, remote-only commits
@@ -1811,6 +2003,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) {