@straiffi/archon 1.10.1 → 1.10.2

package/dist/server/workers/review.js

@@ -23,17 +23,21 @@ import { captureStageBaseline, captureStageSuccess } from '../lib/ticketUndo.js'
 import { beginTicketThinkingRun, bindTicketThinkingMessage } from '../lib/thinkingState.js';
 import { autoParkTicketIfStale, getTicket, resolveTicketBranch, resolveTicketTool, resolveTicketWorkerKey } from '../lib/tickets.js';
 import { createAgentRun, emitAgentRunsUpdated, emitExecutionAgentRunsUpdated, getAgentRun, listAgentRunsForExecutionRun, terminalizeAgentRunsForExecutionRun, } from '../lib/agentRuns.js';
-import { buildAutomationFixInstruction, buildAutomationFixStatusMessage, decideReviewAutomation, depthAtLeast, getBundleAutomationState, resetBundleAutomationLoop, resolveAutomationConfig, upsertBundleAutomationState, } from '../lib/ticketAutomation.js';
+import { buildAutomationFixInstruction, buildAutomationFixStatusMessage, countBlockingFindings, decideReviewAutomation, depthAtLeast, getBundleAutomationState, resetBundleAutomationLoop, resolveAutomationConfig, } from '../lib/ticketAutomation.js';
 import { runAutomationCommitChain } from '../lib/ticketAutomationCommit.js';
 import { submitTicketFollowUp } from '../lib/ticketFollowUpOperations.js';
-import { completeAutomationProgression, createAutomationReviewFix, ensureAutomationProgression, finishAutomationReviewFix, pauseAutomationProgression, resolveProgressionForChild, waitAutomationProgression, } from '../lib/automationProgression.js';
+import { completeAutomationProgressionInTransaction, completeAutomationProgression, completeAutomationReviewFixActionInTransaction, createAutomationReviewFixInTransaction, ensureAutomationProgression, finishAutomationReviewFix, pauseAutomationProgression, resolveProgressionForChild, waitAutomationProgression, } from '../lib/automationProgression.js';
+import { assertAutomationAuthorizationCurrent, assertAutomationBoundaryNotRequired, AutomationCheckGateError, } from '../lib/automationCheckGate.js';
+import { attachReviewRepairActionEnvelopeInTransaction, attachReviewRepairActionInTransaction, appendReviewRepairIterationDecisionInTransaction, attachReviewRepairResultInTransaction, claimReviewRepairIterationInTransaction, getReviewRepairIteration, getReviewRepairIterationByVerification, pauseReviewRepairIteration, pauseReviewRepairIterationInTransaction, terminalizeReviewRepairIterationInTransaction, } from '../lib/reviewRepairIterations.js';
 import { formatBuildOpenQuestionAnswersPrompt, listAnsweredBuildOpenQuestionsForBundle } from '../lib/buildOpenQuestions.js';
 import { validateWorkflowContext } from '../lib/types.js';
-import { isOpencodeModelResolutionError } from '../lib/opencodeErrors.js';
+import { isModelResolutionError } from '../lib/modelResolutionErrors.js';
 import { assertProviderSessionAuthorityMatches, createExecutionProfileSelectionMetadata } from '../lib/executionRunAuthority.js';
 import { classifyTicketExecutionTarget, resolveExecutionTarget } from '../lib/executionTargets.js';
 import { resolveWorkloadExecutionEnvironment } from '../lib/workloadExecutionEnvironment.js';
 import { getModelProvider } from '../lib/models.js';
+import { captureCheckWorkspaceIdentity } from '../lib/checkWorkspaceIdentity.js';
+import { persistReviewCompletionAutomationInTransaction, } from '../lib/reviewRepairCompletion.js';
 const getErrorMessage = (error) => {
     return error instanceof Error ? error.message : String(error);
 };
@@ -368,7 +372,7 @@ Every finding must set \`file_path\` to a path in \`<review_scope>\` and set at
 
 Do not include planning text, implementation steps, or commentary about changing modes.`, ticket.skills);
 };
-const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parsedStatus, findings, io, executionContext, initiation) => {
+const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parsedStatus, findings, io, executionContext, initiation, persistedAutomation) => {
     if (!ticket.worktree_bundle_id || !ticket.project_id) {
         return false;
     }
@@ -376,12 +380,74 @@ const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parse
     const bundleId = ticket.worktree_bundle_id;
     const liveTicket = getTicket(ticket.id) ?? ticket;
     const liveProject = getEffectiveProject(liveTicket) ?? project;
-    const config = resolveAutomationConfig(liveTicket.bundle ?? null, liveProject);
+    const config = persistedAutomation?.config ?? resolveAutomationConfig(liveTicket.bundle ?? null, liveProject);
     const bundleState = getBundleAutomationState(projectId, bundleId);
-    const decision = decideReviewAutomation(config, bundleState, reviewRunId, parsedStatus, findings);
-    const progression = initiation.initiator === 'automation'
-        ? resolveProgressionForChild({ projectId, bundleId, childRunId: executionContext.runId })
-        : null;
+    const decision = persistedAutomation?.decision
+        ?? decideReviewAutomation(config, bundleState, reviewRunId, parsedStatus, findings);
+    const progressionRunId = persistedAutomation?.progressionRunId
+        ?? (initiation.initiator === 'automation'
+            ? resolveProgressionForChild({ projectId, bundleId, childRunId: executionContext.runId }).id
+            : null);
+    const progression = progressionRunId ? { id: progressionRunId } : null;
+    if (progression) {
+        const iteration = getReviewRepairIterationByVerification(projectId, executionContext.runId);
+        if (iteration?.phase === 'verification_active'
+            && iteration.resulting_review_execution_run_id === executionContext.runId) {
+            const resultingBlockingCount = parsedStatus === 'completed'
+                ? countBlockingFindings(findings, config)
+                : null;
+            withExecutionRunTransaction(transaction => {
+                if (parsedStatus === 'completed' && reviewRunId) {
+                    attachReviewRepairResultInTransaction(transaction, {
+                        projectId,
+                        iterationId: iteration.id,
+                        expectedPhase: 'verification_active',
+                        expectedVerificationRunId: executionContext.runId,
+                        resultingReviewRunId: reviewRunId,
+                    });
+                }
+                appendReviewRepairIterationDecisionInTransaction(transaction, {
+                    projectId,
+                    iterationId: iteration.id,
+                    decisionPoint: 'verification_completion',
+                    effectiveAutomationConfig: config,
+                    decisionCode: parsedStatus === 'completed' ? 'verification_completed' : 'verification_failed',
+                    operationRunId: executionContext.runId,
+                });
+                const terminal = decision.kind === 'fix_iteration'
+                    ? { outcome: 'continuing', stopReason: null }
+                    : decision.kind === 'clean'
+                        ? { outcome: 'repaired', stopReason: 'no_blocking_findings' }
+                        : decision.kind === 'exhausted'
+                            ? { outcome: 'exhausted', stopReason: 'max_iterations' }
+                            : decision.kind === 'pause_blocking'
+                                ? { outcome: 'interrupted', stopReason: 'automation_disabled' }
+                                : parsedStatus !== 'completed'
+                                    ? { outcome: 'failed', stopReason: 'verification_failed' }
+                                    : { outcome: 'interrupted', stopReason: 'configuration_changed' };
+                if (parsedStatus !== 'completed') {
+                    pauseReviewRepairIterationInTransaction(transaction, {
+                        projectId,
+                        iterationId: iteration.id,
+                        expectedPhase: 'verification_active',
+                        expectedCurrentRunId: executionContext.runId,
+                        stopReason: 'verification_failed',
+                    });
+                }
+                else {
+                    terminalizeReviewRepairIterationInTransaction(transaction, {
+                        projectId,
+                        iterationId: iteration.id,
+                        expectedPhase: 'verification_active',
+                        expectedCurrentRunId: executionContext.runId,
+                        outcome: terminal.outcome,
+                        stopReason: terminal.stopReason,
+                        resultingBlockingCount,
+                    });
+                }
+            }, asGenericEmitter(io), 'immediate');
+        }
+    }
     switch (decision.kind) {
         case 'manual':
             if (progression) {
@@ -431,41 +497,66 @@ const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parse
             if (!reviewRunId) {
                 throw new Error('Review fix cannot start without persisted review findings');
             }
-            const previousIteration = bundleState?.review_iteration_count ?? 0;
-            const previousFixLoopActive = bundleState?.fix_loop_active ?? 0;
-            upsertBundleAutomationState(projectId, bundleId, {
-                review_iteration_count: decision.iteration,
-                fix_loop_active: 1,
-            });
             const instruction = buildAutomationFixInstruction(config.reviewSeverity);
             const reviewFixWorkflowContext = validateWorkflowContext({
                 ...(initiation.workflowContext ?? {}),
                 review_finding_run_id: reviewRunId,
                 review_severity: config.reviewSeverity,
             });
-            let reviewFix = null;
-            try {
-                reviewFix = progression
-                    ? createAutomationReviewFix({
+            const repairProgressionRunId = progression?.id ?? ensureAutomationProgression({
+                projectId,
+                bundleId,
+                ticketId: ticket.id,
+                ticketTitle: ticket.title,
+                parentRunId: executionContext.runId,
+                workflowContext: initiation.workflowContext,
+                broadcaster: asGenericEmitter(io),
+            }).runId;
+            let reviewFix = persistedAutomation?.repair?.reviewFix ?? null;
+            let iterationId = persistedAutomation?.repair?.iterationId ?? null;
+            if (persistedAutomation && !persistedAutomation.repair) {
+                return true;
+            }
+            if (!reviewFix) {
+                const claimed = withExecutionRunTransaction(transaction => {
+                    const iteration = claimReviewRepairIterationInTransaction(transaction, {
+                        projectId,
+                        worktreeBundleId: bundleId,
+                        ownerTicketId: ticket.id,
+                        automationProgressionRunId: repairProgressionRunId,
+                        triggeringReviewExecutionRunId: executionContext.runId,
+                        triggeringReviewRunId: reviewRunId,
+                        triggeringBlockingCount: countBlockingFindings(findings, config),
+                        effectiveAutomationConfig: config,
+                        decisionCode: 'repair_admitted',
+                    });
+                    if (iteration.phase !== 'observed') {
+                        return { iteration, reviewFix: null };
+                    }
+                    const createdReviewFix = createAutomationReviewFixInTransaction(transaction, {
                         projectId,
                         bundleId,
                         ticketId: ticket.id,
                         ticketTitle: ticket.title,
-                        progressionRunId: progression.id,
+                        progressionRunId: repairProgressionRunId,
                         workflowContext: reviewFixWorkflowContext,
                         triggeringReviewRunId: executionContext.runId,
                         reviewFindingRunId: reviewRunId,
                         reviewSeverity: config.reviewSeverity,
-                        broadcaster: asGenericEmitter(io),
-                    })
-                    : null;
+                    });
+                    attachReviewRepairActionEnvelopeInTransaction(transaction, {
+                        projectId,
+                        iterationId: iteration.id,
+                        expectedPhase: 'observed',
+                        runId: createdReviewFix.runId,
+                    });
+                    return { iteration, reviewFix: createdReviewFix };
+                }, asGenericEmitter(io), 'immediate');
+                iterationId = claimed.iteration.id;
+                reviewFix = claimed.reviewFix;
             }
-            catch (error) {
-                upsertBundleAutomationState(projectId, bundleId, {
-                    review_iteration_count: previousIteration,
-                    fix_loop_active: previousFixLoopActive,
-                });
-                throw error;
+            if (!reviewFix) {
+                return true;
             }
             const started = submitTicketFollowUp({
                 ticketId: ticket.id,
@@ -475,16 +566,30 @@ const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parse
                 persistTriggerMessage: false,
                 initiation: {
                     initiator: 'automation',
-                    causalParentRunId: reviewFix?.runId ?? executionContext.runId,
+                    causalParentRunId: reviewFix.runId,
                     workflowContext: reviewFixWorkflowContext,
                 },
+                onExecutionCreated: (createdContext, transaction) => {
+                    attachReviewRepairActionInTransaction(transaction, {
+                        projectId,
+                        iterationId: iterationId,
+                        expectedPhase: 'action_claimed',
+                        runId: createdContext.runId,
+                    });
+                },
+                onExecutionCompleted: (completedContext, transaction) => {
+                    const currentTicket = getTicket(ticket.id) ?? ticket;
+                    const currentProject = getEffectiveProject(currentTicket) ?? project;
+                    const currentConfig = resolveAutomationConfig(currentTicket.bundle ?? null, currentProject);
+                    completeAutomationReviewFixActionInTransaction(transaction, {
+                        projectId,
+                        actionRunId: completedContext.runId,
+                        effectiveAutomationConfig: currentConfig,
+                    });
+                },
             });
             if (!started.ok) {
-                upsertBundleAutomationState(projectId, bundleId, {
-                    review_iteration_count: previousIteration,
-                    fix_loop_active: previousFixLoopActive,
-                });
-                if (reviewFix && progression) {
+                if (reviewFix) {
                     finishAutomationReviewFix({
                         projectId,
                         reviewFixRunId: reviewFix.runId,
@@ -494,24 +599,27 @@ const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parse
                     waitAutomationProgression({
                         projectId,
                         bundleId,
-                        progressionRunId: progression.id,
+                        progressionRunId: repairProgressionRunId,
                         pauseCode: 'review',
                         pauseReason: `fix follow-up could not start: ${started.error}`,
                         reasonCode: 'stage_failed',
                         pausedStageRunId: reviewFix.runId,
                         broadcaster: asGenericEmitter(io),
                     });
-                }
-                else {
-                    pauseAutomationProgression({
-                        projectId,
-                        bundleId,
-                        pauseCode: 'review',
-                        pauseReason: `fix follow-up could not start: ${started.error}`,
-                        reasonCode: 'stage_failed',
-                        pausedStageRunId: null,
-                        broadcaster: asGenericEmitter(io),
-                    });
+                    const failedIteration = getReviewRepairIteration(projectId, iterationId);
+                    if (failedIteration && !['paused', 'terminal'].includes(failedIteration.phase)) {
+                        pauseReviewRepairIteration({
+                            projectId,
+                            iterationId: failedIteration.id,
+                            expectedPhase: failedIteration.phase,
+                            expectedCurrentRunId: failedIteration.resulting_review_execution_run_id
+                                ?? failedIteration.gate_batch_run_id
+                                ?? failedIteration.action_run_id
+                                ?? failedIteration.action_envelope_run_id,
+                            stopReason: 'action_failed',
+                            broadcaster: asGenericEmitter(io),
+                        });
+                    }
                 }
                 const pausedTicket = getTicket(ticket.id);
                 if (pausedTicket) {
@@ -557,6 +665,36 @@ const runReviewCompletionAutomation = async (ticket, project, reviewRunId, parse
             }
             return true;
         }
+        case 'exhausted': {
+            if (progression) {
+                waitAutomationProgression({
+                    projectId,
+                    bundleId,
+                    progressionRunId: progression.id,
+                    pauseCode: 'review',
+                    pauseReason: 'Blocking Review findings remain after repair verification.',
+                    reasonCode: 'precondition_failed',
+                    pausedStageRunId: executionContext.runId,
+                    broadcaster: asGenericEmitter(io),
+                });
+            }
+            else {
+                pauseAutomationProgression({
+                    projectId,
+                    bundleId,
+                    pauseCode: 'review',
+                    pauseReason: 'Blocking Review findings remain after repair verification.',
+                    reasonCode: 'precondition_failed',
+                    pausedStageRunId: null,
+                    broadcaster: asGenericEmitter(io),
+                });
+            }
+            const pausedTicket = getTicket(ticket.id);
+            if (pausedTicket) {
+                io.emit('ticket:updated', pausedTicket);
+            }
+            return true;
+        }
         case 'clean': {
             resetBundleAutomationLoop(projectId, bundleId);
             if (depthAtLeast(config.depth, 'auto_commit')) {
@@ -617,15 +755,10 @@ export function startReview(ticket, io, options) {
                 compensateAcceptance = acceptance.compensate;
             }
             const acceptedTool = resolveTicketTool(acceptedTicket, config.tool ?? 'opencode');
-            const acceptedReviewer = acceptedTool === 'opencode'
-                ? resolveReviewerConfig(acceptedTicket.bundle, project, {
-                    model: acceptedTicket.model,
-                    variant: acceptedTicket.variant,
-                })
-                : {
-                    model: acceptedTicket.model,
-                    variant: acceptedTicket.model ? acceptedTicket.variant : null,
-                };
+            const acceptedReviewer = resolveReviewerConfig(acceptedTicket.bundle, project, {
+                model: acceptedTicket.model,
+                variant: acceptedTicket.variant,
+            }, acceptedTool);
             acceptedReviewExecution = {
                 tool: acceptedTool,
                 model: acceptedReviewer.model,
@@ -677,12 +810,14 @@ export function startReview(ticket, io, options) {
                 },
                 eventType: initiation.retrySourceRunId ? 'retry_started' : 'review_created',
             });
-            return {
+            const createdContext = {
                 runId: executionRun.id,
                 correlationId: executionRun.correlation_id,
                 projectId: executionRun.project_id,
                 kind: executionRun.kind,
             };
+            options?.onExecutionCreated?.(createdContext, transaction);
+            return createdContext;
         }, asGenericEmitter(io));
     }
     catch (error) {
@@ -716,6 +851,93 @@ export function startReview(ticket, io, options) {
                     throw new Error('The queued Review has no immutable execution configuration');
                 }
                 const cwd = currentTicket.bundle?.kind === 'project_root' ? project.repo_path : resolveWorktreePath(branch, project);
+                const verificationIteration = getReviewRepairIterationByVerification(project.id, executionContext.runId);
+                if (verificationIteration) {
+                    const admittedIdentity = verificationIteration.workspace_evidence?.workspaceIdentity;
+                    const currentIdentity = await captureCheckWorkspaceIdentity(cwd);
+                    const liveConfig = resolveAutomationConfig(currentTicket.bundle ?? null, project);
+                    if (liveConfig.depth === 'manual') {
+                        withExecutionRunTransaction(transaction => {
+                            terminalizeReviewRepairIterationInTransaction(transaction, {
+                                projectId: project.id,
+                                iterationId: verificationIteration.id,
+                                expectedPhase: 'verification_active',
+                                expectedCurrentRunId: executionContext.runId,
+                                outcome: 'interrupted',
+                                stopReason: 'configuration_changed',
+                            });
+                            completeAutomationProgressionInTransaction(transaction, {
+                                projectId: project.id,
+                                bundleId: verificationIteration.worktree_bundle_id,
+                                progressionRunId: verificationIteration.automation_progression_run_id,
+                                domainStatus: 'manual_boundary_reached',
+                            });
+                        }, asGenericEmitter(io), 'immediate');
+                        throw new Error('Automated Review was disabled before verification started');
+                    }
+                    if (admittedIdentity?.state !== 'available'
+                        || currentIdentity.state !== 'available'
+                        || admittedIdentity.fingerprint !== currentIdentity.fingerprint) {
+                        pauseReviewRepairIteration({
+                            projectId: project.id,
+                            iterationId: verificationIteration.id,
+                            expectedPhase: 'verification_active',
+                            expectedCurrentRunId: executionContext.runId,
+                            stopReason: 'stale_evidence',
+                            workspaceEvidence: {
+                                ...verificationIteration.workspace_evidence,
+                                startupWorkspaceIdentity: currentIdentity,
+                            },
+                            broadcaster: asGenericEmitter(io),
+                        });
+                        throw new Error('Automated Review workspace is stale relative to gate admission');
+                    }
+                    if (!currentTicket.bundle) {
+                        throw new Error('Automated Review bundle no longer exists');
+                    }
+                    try {
+                        if (verificationIteration.gate_evaluation_id) {
+                            await assertAutomationAuthorizationCurrent({
+                                project,
+                                bundle: currentTicket.bundle,
+                                progressionRunId: verificationIteration.automation_progression_run_id,
+                                cwd,
+                                evaluationId: verificationIteration.gate_evaluation_id,
+                                boundaryKind: 'automation_review',
+                            });
+                        }
+                        else if (typeof verificationIteration.workspace_evidence?.policyFingerprint === 'string') {
+                            assertAutomationBoundaryNotRequired({
+                                project,
+                                bundle: currentTicket.bundle,
+                                progressionRunId: verificationIteration.automation_progression_run_id,
+                                policyFingerprint: verificationIteration.workspace_evidence.policyFingerprint,
+                                boundaryKind: 'automation_review',
+                            });
+                        }
+                        else {
+                            throw new AutomationCheckGateError('invalid_lineage', 'Automated Review gate evidence is unavailable');
+                        }
+                    }
+                    catch (error) {
+                        if (!(error instanceof AutomationCheckGateError)) {
+                            throw error;
+                        }
+                        pauseReviewRepairIteration({
+                            projectId: project.id,
+                            iterationId: verificationIteration.id,
+                            expectedPhase: 'verification_active',
+                            expectedCurrentRunId: executionContext.runId,
+                            stopReason: 'stale_evidence',
+                            workspaceEvidence: {
+                                ...verificationIteration.workspace_evidence,
+                                startupWorkspaceIdentity: currentIdentity,
+                            },
+                            broadcaster: asGenericEmitter(io),
+                        });
+                        throw new Error(`Automated Review gate authorization is stale: ${error.message}`);
+                    }
+                }
                 const { tool, skills } = acceptedReviewExecution;
                 const reviewerConfig = {
                     model: acceptedReviewExecution.model,
@@ -907,6 +1129,15 @@ export function startReview(ticket, io, options) {
                             expectedParent: { entityType: 'ticket', entityId: currentTicket.id },
                         },
                     });
+                    if (verificationIteration) {
+                        attachReviewRepairResultInTransaction(transaction, {
+                            projectId: executionContext.projectId,
+                            iterationId: verificationIteration.id,
+                            expectedPhase: 'verification_active',
+                            expectedVerificationRunId: executionContext.runId,
+                            resultingReviewRunId: activeReviewRunId,
+                        });
+                    }
                 }, asGenericEmitter(io));
                 beginTicketThinkingRun(ticket.id);
                 const blindRunId = createAgentRun({
@@ -1025,7 +1256,7 @@ export function startReview(ticket, io, options) {
                         });
                     }
                     catch (error) {
-                        if (tool === 'opencode' && reviewerConfig.model && isOpencodeModelResolutionError(error)) {
+                        if (reviewerConfig.model && isModelResolutionError(error, tool)) {
                             throw getReviewerExecutionError(error, reviewerConfig.model, reviewerConfig.variant);
                         }
                         throw error;
@@ -1195,7 +1426,8 @@ export function startReview(ticket, io, options) {
                         ...(parseFailed ? { failure: { code: 'parse_failed', message: 'Review output could not be parsed' } } : {}),
                         eventType: parseFailed ? 'review_parse_failed' : 'review_completed',
                     });
-                    return { messageId, reviewRunId: activeReviewRunId };
+                    const persistedAutomation = persistReviewCompletionAutomationInTransaction(transaction, currentTicket, project, activeReviewRunId, parsedStatus, parsedFindings, executionContext, initiation);
+                    return { messageId, reviewRunId: activeReviewRunId, persistedAutomation };
                 }, asGenericEmitter(io));
                 persistedMessageId = persisted.messageId;
                 reviewRunId = persisted.reviewRunId;
@@ -1232,7 +1464,7 @@ export function startReview(ticket, io, options) {
                     captureStageSuccess(ticket.id, 'review');
                     let handled = false;
                     try {
-                        handled = await runReviewCompletionAutomation(updated, project, reviewRunId, parsedStatus, parsedFindings, io, executionContext, initiation);
+                        handled = await runReviewCompletionAutomation(updated, project, reviewRunId, parsedStatus, parsedFindings, io, executionContext, initiation, persisted.persistedAutomation);
                     }
                     catch (automationError) {
                         if (ticket.project_id && ticket.worktree_bundle_id) {