@straiffi/archon 1.7.1 → 1.7.3

package/dist/server/lib/ticketAutomationCommit.js

@@ -1,17 +1,26 @@
+import { createHash } from 'crypto';
+import db from '../db.js';
 import config from './config.js';
 import { buildCommitMessagePrompt, normalizeGeneratedCommitMessage, } from './commitMessage.js';
-import { commitGitChanges, getGitStatus, getReviewDiffData, getSelectedGitUnifiedDiff, pushCurrentBranch, resolveWorktreePath, } from './git.js';
+import { commitPreparedAutomationChanges, computeGitTreeDeltaDigest, fetchRemoteBranchState, getAutomationCommitPaths, getAutomationRemoteIdentity, getGitHeadIdentity, getGitIndexTreeSha, getGitStatus, getReviewDiffData, getSelectedGitUnifiedDiff, prepareAutomationCommit, pushAutomationTarget, resolveWorktreePath, } from './git.js';
 import { runLightweightPrompt } from './lightweightPrompt.js';
 import { buildPullRequestContentPrompt, parsePullRequestContent, } from './pullRequestContent.js';
-import { isProjectRootBundle } from './tickets.js';
-import { createOrFindGitHubPullRequest, hasGitHubRemoteBranch } from './integrations/github.js';
+import { getBundle, getTicket, isProjectRootBundle } from './tickets.js';
+import { createGitHubPullRequest, observeGitHubPullRequest, } from './integrations/github.js';
 import { getGitHubConnectionConfig } from './integrations/index.js';
-import { hasOpenBundlePullRequest, syncTrackedBundlePullRequestIfNeeded, upsertBundlePullRequestFromGitHub, } from './bundlePullRequests.js';
-import { recordAutomationPause } from './ticketAutomation.js';
-import { getTicket } from './tickets.js';
-const getErrorMessage = (error) => {
-    return error instanceof Error ? error.message : String(error);
+import { upsertBundlePullRequestFromGitHub, } from './bundlePullRequests.js';
+import { depthAtLeast, getBundleAutomationState, resolveAutomationConfig, } from './ticketAutomation.js';
+import { completeAutomationProgressionInTransaction, completeAutomationProgression, getAutomationProgression, waitAutomationProgressionInTransaction, waitAutomationProgression, } from './automationProgression.js';
+import { AUTOMATION_STAGE_DETAILS_SCHEMA_VERSION, createAutomationStageDetails, ensureAutomationStageResult, } from './automationStageDetails.js';
+import { getProjectById } from './projects.js';
+import { getExecutionRun, withExecutionRunTransaction } from './executionRuns.js';
+const EMPTY_MESSAGE_DIGEST = `sha256:${createHash('sha256').update('').digest('hex')}`;
+const getErrorMessage = (error) => error instanceof Error ? error.message : String(error);
+const digestCommitMessage = (message) => {
+    const normalized = message.replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n+$/, '');
+    return `sha256:${createHash('sha256').update(normalized, 'utf8').digest('hex')}`;
 };
+const asBroadcaster = (io) => io;
 export const evaluateCommitPrecondition = (gitStatus) => {
     if (gitStatus.files.length === 0) {
         return { ok: true };
@@ -21,7 +30,7 @@ export const evaluateCommitPrecondition = (gitStatus) => {
     }
     return { ok: true };
 };
-export const evaluatePrPrecondition = (connectionConfig, bundle, gitStatus, hasRemoteBranch, existingTrackedPr) => {
+export const evaluatePrPrecondition = (connectionConfig, bundle, gitStatus, hasRemoteBranch, _existingTrackedPr) => {
     if (!connectionConfig) {
         return { ok: false, reason: 'GitHub integration not connected' };
     }
@@ -36,29 +45,20 @@ export const evaluatePrPrecondition = (connectionConfig, bundle, gitStatus, hasR
     }
     return { ok: true };
 };
-const buildCommitExecution = (project) => {
-    if (project.helper_model) {
-        return {
-            tool: 'opencode',
-            model: project.helper_model,
-            variant: project.helper_variant,
-        };
-    }
-    return { tool: config.tool ?? 'opencode' };
-};
+const buildCommitExecution = (project) => project.helper_model
+    ? { tool: 'opencode', model: project.helper_model, variant: project.helper_variant }
+    : { tool: config.tool ?? 'opencode' };
 const generateCommitMessage = async (cwd, project, selectedPaths) => {
     const gitStatus = getGitStatus(cwd, null, project);
     const selectedPathSet = new Set(selectedPaths);
-    const selectedFiles = gitStatus.files
-        .filter(file => selectedPathSet.has(file.path))
-        .map(file => `${file.status}: ${file.path}`);
     const prompt = buildCommitMessagePrompt({
         commitMessageRules: project.commit_message_rules,
-        selectedFiles,
+        selectedFiles: gitStatus.files
+            .filter(file => selectedPathSet.has(file.path))
+            .map(file => `${file.status}: ${file.path}`),
         diff: getSelectedGitUnifiedDiff(cwd, selectedPaths),
     });
-    const rawMessage = await runLightweightPrompt(buildCommitExecution(project), prompt, cwd);
-    return normalizeGeneratedCommitMessage(rawMessage);
+    return normalizeGeneratedCommitMessage(await runLightweightPrompt(buildCommitExecution(project), prompt, cwd));
 };
 const generatePullRequestContent = async (cwd, project, ticket, branch) => {
     const diffData = getReviewDiffData({ cwd, branch, project });
@@ -67,21 +67,19 @@ const generatePullRequestContent = async (cwd, project, ticket, branch) => {
     }
     try {
         const githubConfig = getGitHubConnectionConfig(ticket.project_id ?? '');
-        const baseBranch = githubConfig?.default_base_branch ?? 'main';
         const prompt = buildPullRequestContentPrompt({
             ticketTitle: ticket.title,
             ticketDescription: ticket.description,
             diff: diffData.diff,
-            baseBranch,
+            baseBranch: githubConfig?.default_base_branch ?? 'main',
         });
-        const rawOutput = await runLightweightPrompt(buildCommitExecution(project), prompt, cwd);
-        const parsed = parsePullRequestContent(rawOutput);
+        const parsed = parsePullRequestContent(await runLightweightPrompt(buildCommitExecution(project), prompt, cwd));
         if (parsed) {
             return parsed;
         }
     }
     catch {
-        // Fall back to ticket fields on any failure
+        // Ticket content is a bounded fallback when helper generation is unavailable.
     }
     return { title: ticket.title, body: ticket.description ?? '' };
 };
@@ -91,98 +89,475 @@ const emitUpdated = (io, ticketId) => {
         io.emit('ticket:updated', updated);
     }
 };
-export const runAutomationCommitChain = async (ticket, project, bundle, automationConfig, io) => {
+const clearStoppedStagePointer = (projectId, bundleId, runId) => {
+    db.prepare(`
+    UPDATE bundle_automation_state
+    SET automation_paused_stage_run_id = NULL,
+        automation_pause_reason_code = NULL,
+        automation_paused_code = NULL,
+        automation_paused_reason = NULL,
+        automation_paused_at = NULL,
+        updated_at = CURRENT_TIMESTAMP
+    WHERE project_id = ? AND worktree_bundle_id = ?
+      AND automation_progression_run_id IS NULL AND automation_paused_stage_run_id = ?
+  `).run(projectId, bundleId, runId);
+};
+const loadLiveState = (projectId, bundleId) => {
+    const project = getProjectById(projectId);
+    const bundle = getBundle(bundleId, projectId);
+    if (!project || !bundle) {
+        throw new Error('Automation project or bundle no longer exists');
+    }
+    return { project, bundle, automationConfig: resolveAutomationConfig(bundle, project) };
+};
+const assertStageCanMutate = (projectId, bundleId, progressionRunId, requiredDepth) => {
+    const live = loadLiveState(projectId, bundleId);
+    const progression = getAutomationProgression(projectId, bundleId);
+    const state = getBundleAutomationState(projectId, bundleId);
+    if (!progression
+        || progression.id !== progressionRunId
+        || progression.status !== 'running'
+        || state?.automation_progression_run_id !== progressionRunId
+        || state.automation_paused_reason !== null
+        || !depthAtLeast(live.automationConfig.depth, requiredDepth)) {
+        throw new Error(`automation no longer permits ${requiredDepth === 'auto_push' ? 'push' : 'pull-request'} mutation`);
+    }
+    return live;
+};
+const githubConfigMatchesIntent = (githubConfig, intent) => (githubConfig.host.toLowerCase() === intent.repoHost.toLowerCase()
+    && githubConfig.repo_owner.toLowerCase() === intent.repoOwner.toLowerCase()
+    && githubConfig.repo_name.toLowerCase() === intent.repoName.toLowerCase()
+    && githubConfig.default_base_branch === intent.baseBranch);
+const startStage = ({ projectId, bundleId, ticketId, ticketTitle, progressionRunId, allowedActiveChildRunId, stageKind, intent, broadcaster, retryOfRunId, }) => withExecutionRunTransaction(transaction => {
+    const progression = getAutomationProgression(projectId, bundleId);
+    if (!progression || progression.id !== progressionRunId) {
+        throw new Error('Automation stage has no active progression owner');
+    }
+    const activeChild = db.prepare(`
+    SELECT id
+    FROM execution_runs
+    WHERE project_id = ? AND parent_run_id = ? AND id <> ?
+      AND kind IN ('review', 'automation_review_fix', 'automation_commit', 'automation_push', 'automation_pull_request')
+      AND status IN ('queued', 'running', 'waiting')
+    LIMIT 1
+  `).get(projectId, progressionRunId, allowedActiveChildRunId ?? '');
+    if (activeChild) {
+        throw new Error('Automation progression already has an active child');
+    }
+    const progressionTicketLink = db.prepare(`
+    SELECT 1 FROM execution_run_links
+    WHERE execution_run_id = ? AND project_id = ? AND entity_type = 'ticket' AND entity_id = ?
+  `).get(progressionRunId, projectId, ticketId);
+    if (!progressionTicketLink) {
+        transaction.addExecutionRunLink({
+            projectId,
+            runId: progressionRunId,
+            link: { entityType: 'ticket', entityId: ticketId, relationship: 'context', label: ticketTitle },
+        });
+    }
+    const createRun = retryOfRunId
+        ? transaction.createAutomationRetryExecutionRun
+        : transaction.createExecutionRun;
+    const run = createRun({
+        projectId,
+        kind: stageKind,
+        domainStatus: 'starting',
+        sourceReference: { kind: 'bundle', id: bundleId },
+        links: [{ entityType: 'ticket', entityId: ticketId, relationship: 'context', label: ticketTitle }],
+        initiatedBy: 'automation',
+        parentRunId: progressionRunId,
+        retryOfRunId,
+        eventType: `${stageKind}_created`,
+    });
+    createAutomationStageDetails({
+        projectId,
+        bundleId,
+        runId: run.id,
+        stageKind,
+        schemaVersion: AUTOMATION_STAGE_DETAILS_SCHEMA_VERSION,
+        intent: intent,
+    });
+    transaction.transitionExecutionRun({
+        projectId,
+        runId: run.id,
+        status: 'running',
+        domainStatus: 'running',
+        eventType: `${stageKind}_started`,
+    });
+    return run.id;
+}, broadcaster);
+const finishStage = ({ projectId, bundleId, progressionRunId, runId, stageKind, result, outcome, completeProgression, pullRequest, githubConfig, broadcaster, }) => {
+    const existing = getExecutionRun(projectId, runId);
+    if (!existing || !['queued', 'running', 'waiting'].includes(existing.status)) {
+        return;
+    }
+    return withExecutionRunTransaction(transaction => {
+        ensureAutomationStageResult({
+            projectId,
+            bundleId,
+            runId,
+            stageKind,
+            schemaVersion: AUTOMATION_STAGE_DETAILS_SCHEMA_VERSION,
+            result: result,
+        });
+        if (pullRequest && githubConfig) {
+            const record = upsertBundlePullRequestFromGitHub(projectId, bundleId, githubConfig, pullRequest);
+            if (!record) {
+                throw new Error('Pull-request domain result could not be persisted');
+            }
+            transaction.addExecutionRunLink({
+                projectId,
+                runId,
+                link: {
+                    entityType: 'bundle_pull_request',
+                    entityId: record.id,
+                    relationship: 'result',
+                    expectedParent: { entityType: 'bundle', entityId: bundleId },
+                },
+            });
+        }
+        transaction.transitionExecutionRun({
+            projectId,
+            runId,
+            status: 'completed',
+            domainStatus: outcome,
+            eventType: `${stageKind}_completed`,
+        });
+        clearStoppedStagePointer(projectId, bundleId, runId);
+        const progression = getAutomationProgression(projectId, bundleId);
+        if (completeProgression && progression?.id === progressionRunId) {
+            completeAutomationProgressionInTransaction(transaction, { projectId, bundleId, progressionRunId });
+        }
+    }, broadcaster);
+};
+const failStage = ({ projectId, bundleId, progressionRunId, runId, stageKind, pauseCode, reason, ambiguous, broadcaster, }) => withExecutionRunTransaction(transaction => {
+    const existing = getExecutionRun(projectId, runId);
+    if (!existing || !['queued', 'running', 'waiting'].includes(existing.status)) {
+        return;
+    }
+    transaction.transitionExecutionRun({
+        projectId,
+        runId,
+        status: 'failed',
+        domainStatus: ambiguous ? 'ambiguous' : 'failed',
+        failure: { code: ambiguous ? 'side_effect_ambiguous' : 'stage_failed', message: reason },
+        eventType: `${stageKind}_failed`,
+    });
+    if (!ambiguous) {
+        clearStoppedStagePointer(projectId, bundleId, runId);
+    }
+    const progression = getAutomationProgression(projectId, bundleId);
+    if (progression?.id === progressionRunId) {
+        waitAutomationProgressionInTransaction(transaction, {
+            projectId,
+            bundleId,
+            progressionRunId,
+            pauseCode,
+            pauseReason: reason,
+            reasonCode: ambiguous ? 'side_effect_ambiguous' : 'stage_failed',
+            pausedStageRunId: runId,
+        });
+    }
+}, broadcaster);
+const pauseBeforeStage = ({ projectId, bundleId, progressionRunId, pauseCode, reason, ambiguous, broadcaster, }) => waitAutomationProgression({
+    projectId,
+    bundleId,
+    progressionRunId,
+    pauseCode,
+    pauseReason: reason,
+    reasonCode: ambiguous ? 'side_effect_ambiguous' : 'precondition_failed',
+    pausedStageRunId: null,
+    broadcaster,
+});
+const remoteStatesEqual = (left, right) => (left.state === right.state && (left.state === 'absent' || (right.state === 'observed' && left.sha === right.sha)));
+export const runAutomationCommitChain = async (ticket, _project, _bundle, _automationConfig, io, progressionRunId, resumeFrom, triggeringReviewRunId) => {
     if (!ticket.project_id || !ticket.worktree_bundle_id) {
         return;
     }
     const projectId = ticket.project_id;
     const bundleId = ticket.worktree_bundle_id;
-    const branch = bundle?.branch ?? null;
-    if (!branch) {
-        recordAutomationPause(projectId, bundleId, 'commit', 'automation commit chain skipped: bundle has no branch');
-        emitUpdated(io, ticket.id);
+    const progression = progressionRunId
+        ? getAutomationProgression(projectId, bundleId)
+        : null;
+    if (!progression || progression.id !== progressionRunId) {
         return;
     }
-    const cwd = bundle?.kind === 'project_root'
-        ? project.repo_path
-        : resolveWorktreePath(branch, project);
-    const emitPaused = (code, reason) => {
-        recordAutomationPause(projectId, bundleId, code, reason);
+    const broadcaster = asBroadcaster(io);
+    const isRetry = Boolean(resumeFrom?.retryOfRunId);
+    const skipCommit = Boolean(resumeFrom && (resumeFrom.stageKind !== 'automation_commit' || !isRetry));
+    const skipPush = Boolean(resumeFrom && (resumeFrom.stageKind === 'automation_pull_request'
+        || (resumeFrom.stageKind === 'automation_push' && !isRetry)));
+    let expectedHeadSha = resumeFrom?.expectedHeadSha ?? null;
+    let live = loadLiveState(projectId, bundleId);
+    if (!depthAtLeast(live.automationConfig.depth, 'auto_commit')) {
+        completeAutomationProgression({ projectId, bundleId, progressionRunId, broadcaster });
         emitUpdated(io, ticket.id);
-    };
-    // Commit leg (auto_commit and deeper)
-    try {
-        const gitStatus = getGitStatus(cwd, branch, project);
-        const commitCheck = evaluateCommitPrecondition(gitStatus);
-        if (!commitCheck.ok) {
-            emitPaused('commit', commitCheck.reason);
-            return;
+        return;
+    }
+    const branch = live.bundle.branch;
+    const cwd = live.bundle.kind === 'project_root'
+        ? live.project.repo_path
+        : resolveWorktreePath(branch, live.project);
+    let commitRunId = null;
+    if (!skipCommit) {
+        try {
+            const status = getGitStatus(cwd, branch, live.project);
+            const precondition = evaluateCommitPrecondition(status);
+            if (!precondition.ok) {
+                throw new Error(precondition.reason);
+            }
+            if (status.files.length === 0) {
+                const head = getGitHeadIdentity(cwd);
+                const intent = {
+                    branch,
+                    preActionHeadSha: head.headSha,
+                    preActionIndexTreeSha: getGitIndexTreeSha(cwd),
+                    intendedTreeSha: head.treeSha,
+                    commitMessageDigest: EMPTY_MESSAGE_DIGEST,
+                    selectedContentDigest: computeGitTreeDeltaDigest(cwd, head.headSha, head.treeSha),
+                };
+                commitRunId = startStage({ projectId, bundleId, ticketId: ticket.id, ticketTitle: ticket.title, progressionRunId, allowedActiveChildRunId: triggeringReviewRunId, stageKind: 'automation_commit', intent, broadcaster, retryOfRunId: resumeFrom?.stageKind === 'automation_commit' ? resumeFrom.retryOfRunId : undefined });
+                live = loadLiveState(projectId, bundleId);
+                finishStage({
+                    projectId,
+                    bundleId,
+                    progressionRunId,
+                    runId: commitRunId,
+                    stageKind: 'automation_commit',
+                    result: { outcome: 'no_changes', headSha: head.headSha, treeSha: head.treeSha },
+                    outcome: 'no_changes',
+                    completeProgression: !depthAtLeast(live.automationConfig.depth, 'auto_push'),
+                    broadcaster,
+                });
+                expectedHeadSha = head.headSha;
+            }
+            else {
+                const selectedPaths = getAutomationCommitPaths(status.files);
+                const message = await generateCommitMessage(cwd, live.project, selectedPaths);
+                live = loadLiveState(projectId, bundleId);
+                if (!message) {
+                    throw new Error('commit message generation produced an empty result');
+                }
+                if (!depthAtLeast(live.automationConfig.depth, 'auto_commit')) {
+                    completeAutomationProgression({ projectId, bundleId, progressionRunId, broadcaster });
+                    emitUpdated(io, ticket.id);
+                    return;
+                }
+                const prepared = prepareAutomationCommit(cwd, branch, live.project, selectedPaths);
+                const intent = {
+                    branch,
+                    preActionHeadSha: prepared.preActionHeadSha,
+                    preActionIndexTreeSha: prepared.preActionIndexTreeSha,
+                    intendedTreeSha: prepared.intendedTreeSha,
+                    commitMessageDigest: digestCommitMessage(message),
+                    selectedContentDigest: prepared.selectedContentDigest,
+                };
+                commitRunId = startStage({ projectId, bundleId, ticketId: ticket.id, ticketTitle: ticket.title, progressionRunId, allowedActiveChildRunId: triggeringReviewRunId, stageKind: 'automation_commit', intent, broadcaster, retryOfRunId: resumeFrom?.stageKind === 'automation_commit' ? resumeFrom.retryOfRunId : undefined });
+                const result = await commitPreparedAutomationChanges(cwd, branch, live.project, message, prepared);
+                live = loadLiveState(projectId, bundleId);
+                finishStage({
+                    projectId,
+                    bundleId,
+                    progressionRunId,
+                    runId: commitRunId,
+                    stageKind: 'automation_commit',
+                    result,
+                    outcome: 'committed',
+                    completeProgression: !depthAtLeast(live.automationConfig.depth, 'auto_push'),
+                    broadcaster,
+                });
+                expectedHeadSha = result.commitSha;
+            }
         }
-        if (gitStatus.files.length > 0) {
-            const selectedPaths = gitStatus.files.map(file => file.path);
-            const message = await generateCommitMessage(cwd, project, selectedPaths);
-            if (!message) {
-                emitPaused('commit', 'commit message generation produced an empty result');
-                return;
+        catch (error) {
+            const reason = `commit failed: ${getErrorMessage(error)}`;
+            if (commitRunId) {
+                failStage({ projectId, bundleId, progressionRunId, runId: commitRunId, stageKind: 'automation_commit', pauseCode: 'commit', reason, ambiguous: true, broadcaster });
+            }
+            else {
+                pauseBeforeStage({ projectId, bundleId, progressionRunId, pauseCode: 'commit', reason, broadcaster });
             }
-            await commitGitChanges(cwd, branch, project, message, selectedPaths);
+            emitUpdated(io, ticket.id);
+            return;
         }
     }
-    catch (error) {
-        emitPaused('commit', `commit failed: ${getErrorMessage(error)}`);
+    live = loadLiveState(projectId, bundleId);
+    if (getAutomationProgression(projectId, bundleId)?.id !== progressionRunId) {
+        emitUpdated(io, ticket.id);
         return;
     }
-    if (automationConfig.depth === 'auto_commit') {
+    if (!depthAtLeast(live.automationConfig.depth, 'auto_push')) {
+        completeAutomationProgression({ projectId, bundleId, progressionRunId, broadcaster });
         emitUpdated(io, ticket.id);
         return;
     }
-    // Push leg (auto_push and deeper). pushCurrentBranch is idempotent — a no-op
-    // when the branch is already up to date — so no separate precondition is needed.
-    try {
-        await pushCurrentBranch(cwd, branch);
+    let pushRunId = null;
+    if (!skipPush) {
+        try {
+            if (!expectedHeadSha || getGitHeadIdentity(cwd).headSha !== expectedHeadSha) {
+                throw new Error('HEAD no longer matches the exact automation commit result');
+            }
+            const target = expectedHeadSha;
+            const originIdentity = getAutomationRemoteIdentity(cwd);
+            const preActionRemote = await fetchRemoteBranchState(cwd, branch, originIdentity);
+            live = loadLiveState(projectId, bundleId);
+            if (!depthAtLeast(live.automationConfig.depth, 'auto_push')) {
+                completeAutomationProgression({ projectId, bundleId, progressionRunId, broadcaster });
+                emitUpdated(io, ticket.id);
+                return;
+            }
+            if (getGitHeadIdentity(cwd).headSha !== target) {
+                throw new Error('HEAD changed while the push stage was being prepared');
+            }
+            const intent = { branch, originIdentity, targetLocalSha: target, preActionRemote };
+            pushRunId = startStage({ projectId, bundleId, ticketId: ticket.id, ticketTitle: ticket.title, progressionRunId, allowedActiveChildRunId: triggeringReviewRunId, stageKind: 'automation_push', intent, broadcaster, retryOfRunId: resumeFrom?.stageKind === 'automation_push' ? resumeFrom.retryOfRunId : undefined });
+            const current = await fetchRemoteBranchState(cwd, branch, originIdentity);
+            live = loadLiveState(projectId, bundleId);
+            if (current.state === 'observed' && current.sha === target) {
+                finishStage({ projectId, bundleId, progressionRunId, runId: pushRunId, stageKind: 'automation_push', result: { remoteSha: target }, outcome: 'already_current', completeProgression: !depthAtLeast(live.automationConfig.depth, 'auto_pr'), broadcaster });
+                expectedHeadSha = target;
+            }
+            else if (remoteStatesEqual(current, preActionRemote)) {
+                live = assertStageCanMutate(projectId, bundleId, progressionRunId, 'auto_push');
+                await pushAutomationTarget(cwd, branch, target, originIdentity);
+                live = loadLiveState(projectId, bundleId);
+                const observed = await fetchRemoteBranchState(cwd, branch, originIdentity);
+                live = loadLiveState(projectId, bundleId);
+                if (observed.state !== 'observed' || observed.sha !== target) {
+                    throw new Error('remote changed after push and cannot be attributed to this stage');
+                }
+                finishStage({ projectId, bundleId, progressionRunId, runId: pushRunId, stageKind: 'automation_push', result: { remoteSha: target }, outcome: 'pushed', completeProgression: !depthAtLeast(live.automationConfig.depth, 'auto_pr'), broadcaster });
+                expectedHeadSha = target;
+            }
+            else {
+                throw new Error('remote changed after push intent was persisted');
+            }
+        }
+        catch (error) {
+            const reason = `push ambiguous: ${getErrorMessage(error)}`;
+            if (pushRunId) {
+                failStage({ projectId, bundleId, progressionRunId, runId: pushRunId, stageKind: 'automation_push', pauseCode: 'push', reason, ambiguous: true, broadcaster });
+            }
+            else {
+                pauseBeforeStage({ projectId, bundleId, progressionRunId, pauseCode: 'push', reason, ambiguous: true, broadcaster });
+            }
+            emitUpdated(io, ticket.id);
+            return;
+        }
     }
-    catch (error) {
-        emitPaused('push', `push failed: ${getErrorMessage(error)}`);
+    live = loadLiveState(projectId, bundleId);
+    if (getAutomationProgression(projectId, bundleId)?.id !== progressionRunId) {
+        emitUpdated(io, ticket.id);
+        return;
+    }
+    if (!depthAtLeast(live.automationConfig.depth, 'auto_pr')) {
+        completeAutomationProgression({ projectId, bundleId, progressionRunId, broadcaster });
+        emitUpdated(io, ticket.id);
         return;
     }
-    if (automationConfig.depth === 'auto_push') {
+    if (resumeFrom?.stageKind === 'automation_pull_request' && !isRetry) {
+        completeAutomationProgression({ projectId, bundleId, progressionRunId, broadcaster });
         emitUpdated(io, ticket.id);
         return;
     }
-    // PR leg (auto_pr)
+    let pullRequestRunId = null;
     try {
         const githubConfig = getGitHubConnectionConfig(projectId);
-        const prGitStatus = getGitStatus(cwd, branch, project);
-        const hasRemoteBranch = hasGitHubRemoteBranch(cwd, branch);
-        const tracked = bundle
-            ? await syncTrackedBundlePullRequestIfNeeded(project, bundle, { force: true })
-            : null;
-        const prCheck = evaluatePrPrecondition(githubConfig, bundle, prGitStatus, hasRemoteBranch, tracked);
-        if (!prCheck.ok) {
-            emitPaused('pull_request', prCheck.reason);
-            return;
-        }
-        if (hasOpenBundlePullRequest(tracked)) {
-            emitUpdated(io, ticket.id);
-            return;
+        if (!githubConfig?.default_base_branch || isProjectRootBundle(live.bundle)) {
+            throw new Error(!githubConfig ? 'GitHub integration not connected' : 'pull-request configuration is incomplete');
         }
-        if (!githubConfig) {
-            emitPaused('pull_request', 'GitHub integration not connected');
-            return;
+        if (!expectedHeadSha || getGitHeadIdentity(cwd).headSha !== expectedHeadSha) {
+            throw new Error('HEAD no longer matches the exact automation push result');
         }
-        const baseBranch = githubConfig.default_base_branch ?? '';
-        const prContent = await generatePullRequestContent(cwd, project, ticket, branch);
-        const nextPullRequest = await createOrFindGitHubPullRequest(githubConfig, {
-            title: prContent.title,
-            body: prContent.body,
-            baseBranch,
+        const headSha = expectedHeadSha;
+        const intent = {
+            provider: 'github',
+            repoHost: githubConfig.host,
+            repoOwner: githubConfig.repo_owner,
+            repoName: githubConfig.repo_name,
+            baseBranch: githubConfig.default_base_branch,
             headBranch: branch,
+            headSha,
+        };
+        pullRequestRunId = startStage({ projectId, bundleId, ticketId: ticket.id, ticketTitle: ticket.title, progressionRunId, allowedActiveChildRunId: triggeringReviewRunId, stageKind: 'automation_pull_request', intent, broadcaster, retryOfRunId: resumeFrom?.stageKind === 'automation_pull_request' ? resumeFrom.retryOfRunId : undefined });
+        let observation = await observeGitHubPullRequest(githubConfig, intent);
+        live = loadLiveState(projectId, bundleId);
+        let pullRequest;
+        let outcome;
+        if (observation.outcome === 'exact') {
+            pullRequest = observation.pullRequest;
+            outcome = 'already_exists';
+        }
+        else if (observation.outcome === 'absent') {
+            const content = await generatePullRequestContent(cwd, live.project, ticket, branch);
+            live = loadLiveState(projectId, bundleId);
+            const currentConfig = getGitHubConnectionConfig(projectId);
+            if (!currentConfig || !githubConfigMatchesIntent(currentConfig, intent)) {
+                throw new Error('GitHub configuration changed while the pull-request stage was active');
+            }
+            live = assertStageCanMutate(projectId, bundleId, progressionRunId, 'auto_pr');
+            if (getGitHeadIdentity(cwd).headSha !== intent.headSha) {
+                throw new Error('HEAD changed while the pull-request stage was active');
+            }
+            const remote = await fetchRemoteBranchState(cwd, branch);
+            if (remote.state !== 'observed' || remote.sha !== intent.headSha) {
+                throw new Error('remote branch no longer matches the persisted pull-request head');
+            }
+            const mutationConfig = getGitHubConnectionConfig(projectId);
+            if (!mutationConfig || !githubConfigMatchesIntent(mutationConfig, intent)) {
+                throw new Error('GitHub configuration changed while the pull-request stage was active');
+            }
+            live = assertStageCanMutate(projectId, bundleId, progressionRunId, 'auto_pr');
+            if (getGitHeadIdentity(cwd).headSha !== intent.headSha) {
+                throw new Error('HEAD changed before pull-request creation');
+            }
+            pullRequest = await createGitHubPullRequest(mutationConfig, {
+                title: content.title,
+                body: content.body,
+                baseBranch: intent.baseBranch,
+                headBranch: branch,
+            });
+            live = loadLiveState(projectId, bundleId);
+            observation = await observeGitHubPullRequest(mutationConfig, intent);
+            live = loadLiveState(projectId, bundleId);
+            if (observation.outcome !== 'exact' || observation.pullRequest.number !== pullRequest.number) {
+                throw new Error('created pull request could not be observed with its persisted head identity');
+            }
+            pullRequest = observation.pullRequest;
+            outcome = 'created';
+        }
+        else {
+            throw new Error(observation.reason);
+        }
+        const result = {
+            pullRequestNumber: pullRequest.number,
+            providerId: pullRequest.nodeId,
+            url: pullRequest.url,
+            state: pullRequest.state,
+        };
+        finishStage({
+            projectId,
+            bundleId,
+            progressionRunId,
+            runId: pullRequestRunId,
+            stageKind: 'automation_pull_request',
+            result,
+            outcome,
+            completeProgression: true,
+            pullRequest,
+            githubConfig,
+            broadcaster,
         });
-        upsertBundlePullRequestFromGitHub(projectId, bundleId, githubConfig, nextPullRequest);
-        emitUpdated(io, ticket.id);
     }
     catch (error) {
-        emitPaused('pull_request', `pull request failed: ${getErrorMessage(error)}`);
+        const reason = `pull request ambiguous: ${getErrorMessage(error)}`;
+        if (pullRequestRunId) {
+            failStage({ projectId, bundleId, progressionRunId, runId: pullRequestRunId, stageKind: 'automation_pull_request', pauseCode: 'pull_request', reason, ambiguous: true, broadcaster });
+        }
+        else {
+            pauseBeforeStage({ projectId, bundleId, progressionRunId, pauseCode: 'pull_request', reason, ambiguous: true, broadcaster });
+        }
     }
+    emitUpdated(io, ticket.id);
 };
 //# sourceMappingURL=ticketAutomationCommit.js.map