merge: the own-PR flow no longer parks on the operator-approval gate (7nst)

This commit is contained in:
sam committed 2026-09-30 07:41:24 +10:00
commit 06334ca3f9
5 files changed
+123 -11

No files matched your search

@@ -363,6 +363,10 @@ func (f *fakeForge) VerifyPush(ctx context.Context, owner, repo string) error {
// TestStageCommitPushClosesIssueWhenBuildNoChanges verifies that
// StageCommitPush closes the issue with a comment when BuildNoChanges
// is true, instead of trying to commit and failing.
//
// This is also the terminal half of the hazard archie-core-7nst describes: a
// run re-entered against a worktree that already carries the change reaches
// this path, and it must close the issue without ever opening a pull request.
func TestStageCommitPushClosesIssueWhenBuildNoChanges(t *testing.T) {
f := &fakeForge{}
@@ -389,6 +393,9 @@ func TestStageCommitPushClosesIssueWhenBuildNoChanges(t *testing.T) {
} else {
t.Log("CloseIssue called (no changes needed)")
}
if len(f.calls) != 0 {
t.Errorf("forge calls = %v, want none: a no-changes run closes the issue and opens no pull request", f.calls)
}
if tc.Outcome.Status != StatusCompleted {
t.Errorf("expected Outcome=Completed, got %s", tc.Outcome.Status)
} else {
@@ -16,6 +16,8 @@ type PRReviewDecision struct {
SkippedPhases []string
}
// ReviewPullRequest refuses operator approval outright, so the gate is left
// out of the stage list rather than reached and skipped.
func ReviewPullRequest(ctx context.Context, tc *TaskContext) (PRReviewDecision, error) {
if tc.Cfg.Review.ApproveBeforePost {
return PRReviewDecision{}, fmt.Errorf("headless review cannot wait for operator approval")
@@ -27,7 +29,7 @@ func ReviewPullRequest(ctx context.Context, tc *TaskContext) (PRReviewDecision,
_ = os.RemoveAll(tc.prReview.snapshotDir)
}
}()
for _, stage := range prReviewDecisionStages() {
for _, stage := range prReviewDecisionStages(false) {
if err := ctx.Err(); err != nil {
return PRReviewDecision{}, err
}
+9 -5
View File
@@ -104,6 +104,12 @@ func renderBlockingFindingsDetail(findings []prreview.ScoredFinding) string {
// the outcome the PR's existence already earned -- the same best-effort
// convention the deleted StagePostReviewComments followed.
//
// The operator-approval gate is deliberately not spliced in here: it belongs
// to the standalone pr-review workflow, where an operator's response
// re-reviews a pull request that already exists to post to. This trigger
// reviews a change with no PR and no place to post yet, so a wait here would
// end the implement run before its PR was opened (archie-core-7nst).
//
// This must run every decision stage from inside one Stage.Run body rather
// than as separate Stage entries in the workflow's list: the engine ends a
// run the instant any stage sets tc.Outcome (workflow.go's Run loop), so a
@@ -111,7 +117,7 @@ func renderBlockingFindingsDetail(findings []prreview.ScoredFinding) string {
// spliced in as their own preceding stages -- OpenPR's own doc comment names
// this exact pattern ("call this and then do so in the same stage").
func StagePRReviewAndOpenPR(body func(*TaskContext) string) Stage {
return stagePRReviewAndOpenPR(prReviewDecisionStages(), body)
return stagePRReviewAndOpenPR(prReviewDecisionStages(false), body)
}
// stagePRReviewAndOpenPR is StagePRReviewAndOpenPR's implementation, taking
@@ -127,10 +133,8 @@ func stagePRReviewAndOpenPR(decisionStages []Stage, body func(*TaskContext) stri
return fmt.Errorf("pr-review (%s): %w", stage.Name, err)
}
if tc.Outcome.Status != "" {
// A decision stage ended the run itself (operator-approval's
// waiting_human, or a decision stage's own park). Honor it
// rather than proceed to open a PR the operator has not
// cleared yet.
// A decision stage ended the run itself. Honor it rather than
// proceed to open a PR the run has already decided against.
return nil
}
}
@@ -4,8 +4,10 @@ import (
"context"
"errors"
"log/slog"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/workflow/prreview"
)
@@ -168,6 +170,92 @@ func TestLocalPRSourceReadsFromTheTasksOwnWorktree(t *testing.T) {
}
}
// scriptedPRReviewPipeline answers every agent call the full decision
// pipeline makes with the minimum its decoder accepts, ending with one
// advisory (non-blocking) finding: enough for the pipeline to reach the point
// of opening a PR, and nothing that parks on its own.
func scriptedPRReviewPipeline() *concurrentAgentRunner {
return &concurrentAgentRunner{byStage: func(stage string) (agentexec.Result, error) {
switch {
case stage == "intake-ai-score":
return captureResult("score_ai_generated", map[string]any{"confidence": 0.1}), nil
case strings.HasPrefix(stage, "lens-"):
return captureResult("propose_dimensions", map[string]any{"dimensions": []map[string]any{{
"name": "defect", "prompt": "review main.go", "target_files": []string{"main.go"}, "priority": 1.0,
}}}), nil
case strings.HasPrefix(stage, "reviewer-"):
return captureResult("report_findings", map[string]any{"findings": []map[string]any{{
"file": "main.go", "line_start": 1, "severity": "important", "title": "defect",
"body": "broken", "evidence": "package main", "confidence": 0.9,
}}}), nil
case stage == "evidence-verifier":
return captureResult("verify_findings", map[string]any{"verdicts": []map[string]any{{"index": 0, "supported": true}}}), nil
case stage == "adversary":
return captureResult("adversary_verdicts", map[string]any{"verdicts": []map[string]any{{"index": 0, "verdict": "confirmed"}}}), nil
case stage == "consistency":
return captureResult("report_findings", map[string]any{"findings": []any{}}), nil
case stage == "merge-gate":
return captureResult("classify_blocking", map[string]any{"blocking": false}), nil
case stage == "polish":
return captureResult("polish", map[string]any{"body": "tightened"}), nil
default:
return passedResult("phase complete"), nil
}
}}
}
// TestStagePRReviewAndOpenPRDoesNotParkOnOperatorApproval is the regression
// test for archie-core-7nst. The own-PR trigger splices the pr-review
// decision stages into the implement workflow before it opens its PR, and
// with review.approve_before_post set the operator-approval gate used to end
// that run in waiting_human with no PR in existence. Approving such a park
// re-runs the whole implement workflow against a worktree that already
// carries the change; a builder that then finds nothing to do makes
// StageCommitPush close the issue, so the run completes and the PR is never
// opened. The gate belongs to the standalone pipeline only.
func TestStagePRReviewAndOpenPRDoesNotParkOnOperatorApproval(t *testing.T) {
tc, forge := ownPRTaskContext(t)
tc.Task.Workflow = "implement"
tc.Cfg.Review.ApproveBeforePost = true
tc.Cfg.Models = map[string]string{"review": "provider/review", "classification": "provider/classification"}
tc.Agent = scriptedPRReviewPipeline()
if err := StagePRReviewAndOpenPR(implementPRBody).Run(context.Background(), tc); err != nil {
t.Fatalf("stage: %v", err)
}
if tc.Outcome.Status == StatusWaitingHuman {
t.Fatalf("outcome = %q: the own-PR splice must not park on the operator-approval gate, there is no PR to post to yet", tc.Outcome.Status)
}
if tc.Outcome.Status != StatusPROpen {
t.Fatalf("outcome = %q, want %q", tc.Outcome.Status, StatusPROpen)
}
if forge.prNumber == 0 {
t.Fatal("no PR was opened")
}
}
// TestPRReviewWorkflowStillParksOnOperatorApproval is the other half of the
// archie-core-7nst fix: the gate is dropped from the own-PR splice, not from
// the pipeline. The standalone pr-review workflow still waits for the
// operator before it posts and before its merge gate runs.
func TestPRReviewWorkflowStillParksOnOperatorApproval(t *testing.T) {
tc := baseTaskContext(t)
tc.Cfg.Review.ApproveBeforePost = true
tc.PRSource = &fakePRSource{diff: smallDiff, files: map[string]string{"main.go": "package main\n"}}
tc.Agent = scriptedPRReviewPipeline()
forge := &fakeForge{}
tc.Forge = forge
Run(context.Background(), PRReview(), tc)
if tc.Outcome.Status != StatusWaitingHuman {
t.Fatalf("outcome = %q, want %q: the standalone pipeline must still wait for the operator", tc.Outcome.Status, StatusWaitingHuman)
}
if len(forge.calls) != 0 || forge.reviewCalls != 0 {
t.Errorf("forge calls = %v (reviews %d), want none: nothing posts before the operator responds", forge.calls, forge.reviewCalls)
}
}
// configRepoWithBase builds a minimal config.Repo whose BaseBranch()
// resolves without a live git call.
func configRepoWithBase(t *testing.T) config.Repo {
+16 -5
View File
@@ -163,7 +163,7 @@ func PRReview() Workflow {
"depth": {Type: "string"},
},
},
Stages: append(prReviewDecisionStages(), stagePROutput()),
Stages: append(prReviewDecisionStages(true), stagePROutput()),
}
}
@@ -174,8 +174,17 @@ func PRReview() Workflow {
// trigger): the decision of whether an unchallenged blocking finding parks
// the task must happen before a PR exists to post to, while phase 9's
// posting must happen after, once a PR number exists to anchor comments to.
func prReviewDecisionStages() []Stage {
return []Stage{
//
// withOperatorApproval splices the operator-approval gate in between
// synthesis and the merge gate. Only the standalone pr-review workflow passes
// true: there the operator's response re-reviews the pull request, and the
// run is re-entered from the start anyway, which is safe because that
// pipeline has no write-then-close stage. Archie's own PRs has no PR to give
// the operator a posting decision about yet, and a park there would end the
// implement run before it opened one (archie-core-7nst), so the splice drops
// the gate instead.
func prReviewDecisionStages(withOperatorApproval bool) []Stage {
stages := []Stage{
stagePRIntake(),
stagePRAnatomy(),
stagePRLenses(),
@@ -184,9 +193,11 @@ func prReviewDecisionStages() []Stage {
stagePRVerification(),
stagePRCoverageConsistency(),
stagePRSynthesis(),
stagePROperatorApproval(),
stagePRMergeGate(),
}
if withOperatorApproval {
stages = append(stages, stagePROperatorApproval())
}
return append(stages, stagePRMergeGate())
}
// stagePRIntake is pipeline phase 1: PR metadata and diff statistics, the