agent-dealer 1.2.8 → 1.2.10

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

@@ -17,16 +17,20 @@ 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";
 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 { 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, pollPrChecks } 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";
 import { museIdleMinutes, museStallMetadata } from "./muse-spawn.js";
@@ -117,10 +121,18 @@ export const developerEffectConfig = {
     get checksPollIntervalMs() {
         return num("CHECKS_POLL_INTERVAL_MS", 15_000);
     },
+    /** NOT-311: overall CI-wait ceiling measured from the first poll, across deferrals. */
+    get checksWaitCeilingMs() {
+        return checksWaitCeilingMs();
+    },
     /** NOT-197: bound for the pre-branch `git fetch origin <base>` on a fresh issue branch. */
     get baseFetchTimeoutMs() {
         return num("BASE_FETCH_TIMEOUT_MS", DEFAULT_BASE_FETCH_TIMEOUT_MS);
     },
+    /** NOT-315: bound for `npm ci` in the fresh worktree (coordinator side, with network). */
+    get worktreeDepsTimeoutMs() {
+        return worktreeDepsTimeoutMs();
+    },
     /** NOT-110: bounded window to let a lagging `gh pr view` catch up to a just-pushed HEAD. */
     get headReconcileTimeoutMs() {
         return num("HEAD_RECONCILE_TIMEOUT_MS", 30_000);
@@ -290,6 +302,138 @@ async function checksFailedOutcome(opts) {
     });
     return details ? { kind: "checks_failed", details } : { kind: "checks_failed" };
 }
+/**
+ * NOT-311: the `checksWaitStartedAt` persisted by a prior `checks_pending` deferral,
+ * anchoring the overall wait ceiling across re-polls. Null on a first wait (or an
+ * unparseable payload) — the caller then anchors at its own poll start.
+ */
+function checksWaitStartedAtFromPayload(payloadJson) {
+    if (!payloadJson)
+        return null;
+    try {
+        const v = JSON.parse(payloadJson).checksWaitStartedAt;
+        return typeof v === "string" && v ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * NOT-311: decide what a finished checks poll means. Returns a `checks_pending`
+ * outcome when CI is still queued/running at the timeout (or reports no checks while
+ * the base branch has a `pull_request` workflow — "not yet registered", never "no
+ * CI"), and null when the caller stays on today's path (success, failure, an aborted
+ * wait, or `none` with no workflow configured). Also yields the `checks.completed`
+ * milestone reason for the wait cases.
+ *
+ * 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;
+    const base = {
+        kind: "checks_pending",
+        branch: opts.branch,
+        prNumber: opts.prNumber,
+        headSha: opts.headSha,
+        waitStartedAt,
+    };
+    const noChecks = opts.poll.result === "none" || (opts.poll.result === "timeout" && opts.poll.lastSnapshot === "none");
+    if (noChecks) {
+        let hasWorkflow = null;
+        try {
+            hasWorkflow = (await opts.github.hasPullRequestWorkflow?.({ cwd: opts.cwd, baseRef: opts.baseRef })) ?? null;
+        }
+        catch {
+            hasWorkflow = null;
+        }
+        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",
+        };
+    }
+    if (opts.poll.result === "timeout" && opts.poll.lastSnapshot === "pending" && !opts.poll.aborted && !opts.signal?.aborted) {
+        const milestoneReason = checksWaitCeilingExceeded(waitStartedAt) ? "pending_ceiling" : undefined;
+        return {
+            pending: { ...base, reason: "Waiting for CI (running) - no attempt spent" },
+            ...(milestoneReason ? { milestoneReason } : {}),
+        };
+    }
+    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
@@ -528,17 +672,35 @@ async function runPublishOnlyHandoff(ctx, deps, branchName) {
             prNumber: prView.number,
             headSha: prView.headRefOid,
         });
-        const checks = await pollPrChecks(deps.github, {
+        const pollStartedAt = new Date().toISOString();
+        const poll = await pollPrChecksDetailed(deps.github, {
             cwd,
             timeoutMs: developerEffectConfig.checksPollTimeoutMs,
             intervalMs: developerEffectConfig.checksPollIntervalMs,
             signal: ctx.signal,
             number: prView.number,
         });
+        // NOT-311: pending/queued CI at the timeout (or no checks yet with a
+        // `pull_request` workflow on the base) waits with backoff instead of spending
+        // an infra attempt — resolved here so the milestone carries the wait reason.
+        const wait = await resolveChecksWait({
+            github: deps.github,
+            cwd,
+            prNumber: prView.number,
+            baseRef: prView.baseRefName,
+            headSha: prView.headRefOid,
+            branch: branchName,
+            poll,
+            signal: ctx.signal,
+            payloadJson: workItem.payloadJson,
+            pollStartedAt,
+        });
+        const checks = poll.result;
         milestone("checks.completed", `Developer · checks ${checks}`, {
             snapshot: checks,
             prNumber: prView.number,
             headSha: prView.headRefOid,
+            ...(wait.milestoneReason ? { reason: wait.milestoneReason } : {}),
         });
         const postPollView = await deps.github.viewPr({ cwd, branch: branchName });
         if (!postPollView) {
@@ -575,6 +737,20 @@ 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)
+            return wait.pending;
         if (checks === "timeout")
             return { kind: "timed_out" };
         await fetchRef(cwd, prView.baseRefName);
@@ -773,6 +949,18 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
             recordIssueBaseSha(issue.id, resolved.baseSha);
             issue.baseSha = resolved.baseSha;
         }
+        // NOT-315: provision dependencies here, outside the sandbox, with network — the
+        // builder sandbox has none, so an in-session install can never work. A throw
+        // lands in the worktree-setup adapter_failure below: visible and
+        // infra-retryable, never a silent hour-long stall. The session is not spawned.
+        const depsResult = await ensureWorktreeDeps(worktreePath, {
+            runner: deps.depsRunner,
+            timeoutMs: developerEffectConfig.worktreeDepsTimeoutMs,
+        });
+        milestone("worktree.deps_ready", `Developer · dependencies ready (round ${round})`, {
+            ...(depsResult.ran ? { ran: true } : { ran: false, reason: depsResult.reason }),
+            durationMs: depsResult.durationMs,
+        });
     }
     catch (err) {
         return { kind: "adapter_failure", reason: `worktree setup failed: ${String(err)}` };
@@ -886,6 +1074,14 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
         const scopeDecisionNote = typeof payload.scopeDecisionNote === "string" && payload.scopeDecisionNote.trim()
             ? payload.scopeDecisionNote.trim()
             : undefined;
+        // NOT-314: same one-shot ride for an operator_verification repair note.
+        const operatorRepairNote = typeof payload.operatorRepairNote === "string" && payload.operatorRepairNote.trim()
+            ? payload.operatorRepairNote.trim()
+            : undefined;
+        // NOT-314: the frozen snapshot's operator criteria, parsed here so the
+        // worker never re-derives them — the section renders only when non-empty.
+        const operatorCriteria = extractOperatorCriteria(taskSnapshot.acceptanceCriteria);
+        const hasOperatorCriteria = operatorCriteria.length > 0 ? operatorCriteria : undefined;
         // NOT-310: the conflict directive rides only the work item queued by the merge
         // path — exactly this round reads it; nothing is re-read from the DB. Shaped
         // defensively: a malformed directive renders nothing rather than breaking the
@@ -938,6 +1134,8 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
             guidance: guidance.length ? guidance : undefined,
             scopeDecisionNote,
             conflictRepair,
+            operatorCriteria: hasOperatorCriteria,
+            operatorRepairNote,
         });
         // NOT-83 review finding: the session is marked `running` (worker-loop.ts) before this
         // handler ever runs, so an abort landing during worktree setup/deck-bind above already
@@ -1614,7 +1812,8 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
             prNumber: prView.number,
             headSha: prView.headRefOid,
         });
-        const checks = await pollPrChecks(deps.github, {
+        const pollStartedAt = new Date().toISOString();
+        const poll = await pollPrChecksDetailed(deps.github, {
             cwd: worktreePath,
             timeoutMs: developerEffectConfig.checksPollTimeoutMs,
             intervalMs: developerEffectConfig.checksPollIntervalMs,
@@ -1624,10 +1823,27 @@ export async function runDeveloperEffect(ctx, deps = defaultDeps) {
             // back to a bare `gh pr view` either).
             number: prView.number,
         });
+        // NOT-311: pending/queued CI at the timeout (or no checks yet with a
+        // `pull_request` workflow on the base) waits with backoff instead of spending
+        // an infra attempt — resolved here so the milestone carries the wait reason.
+        const wait = await resolveChecksWait({
+            github: deps.github,
+            cwd: worktreePath,
+            prNumber: prView.number,
+            baseRef: prView.baseRefName,
+            headSha: prView.headRefOid,
+            branch: branchName,
+            poll,
+            signal: ctx.signal,
+            payloadJson: workItem.payloadJson,
+            pollStartedAt,
+        });
+        const checks = poll.result;
         milestone("checks.completed", `Developer · checks ${checks}`, {
             snapshot: checks,
             prNumber: prView.number,
             headSha: prView.headRefOid,
+            ...(wait.milestoneReason ? { reason: wait.milestoneReason } : {}),
         });
         // The poll can run for up to checksPollTimeoutMs (default 10 minutes) — re-fetch and
         // re-validate identity against the SAME localHead before trusting either the checks
@@ -1675,6 +1891,24 @@ 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) {
+            await bestEffortRemove(repoPath, worktreePath);
+            return wait.pending;
+        }
         if (checks === "timeout") {
             await bestEffortRemove(repoPath, worktreePath);
             return { kind: "timed_out" };