From c2b992542b4da72b7557f6e8ac72cbdace4c1831 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Wed, 11 Nov 2026 00:39:36 +0000 Subject: [PATCH] Tell the next stage what failed when an error edge leads onward A failed visit was recorded on its step only, so a landing gate that sent the run back to implement gave the implementer nothing about which checks failed. The diagnostic (bounded) is now the next stage's previous output and a memory entry. --- internal/server/runner.go | 4 +++ internal/server/turn_failure_test.go | 41 ++++++++++++++++++++++++++++ internal/server/turns.go | 25 +++++++++++++++++ 3 files changed, 70 insertions(+) create mode 100644 internal/server/turn_failure_test.go diff --git a/internal/server/runner.go b/internal/server/runner.go index 40fbe747..59ae74be 100644 --- a/internal/server/runner.go +++ b/internal/server/runner.go @@ -2193,6 +2193,10 @@ func (r *runner) runLoop(ctx context.Context, id int64, graph protocol.Graph, na if artifactsDir != "" { state.artifactDirs = append(state.artifactDirs, strconv.Itoa(sequence)) } + } else if step.Status == "failed" && step.Target != "" && + step.Target != protocol.FailureEnd && step.Target != protocol.SuccessEnd { + // The error edge leads to another stage: tell it what failed. + state.recordFailure(step) } // Step finished: report its outcome, routing target, diagnostic and the // artifacts recorded for the visit, plus the run's running step count. diff --git a/internal/server/turn_failure_test.go b/internal/server/turn_failure_test.go new file mode 100644 index 00000000..69d52b4e --- /dev/null +++ b/internal/server/turn_failure_test.go @@ -0,0 +1,41 @@ +package server + +import ( + "strings" + "testing" + + "git.a-wan.net/alan/pipelines/internal/protocol" +) + +// A failed stage whose error edge leads to another stage (a landing gate that +// sends the run back to implement) must tell that stage what failed. +func TestRecordFailureCarriesTheDiagnosticToTheNextStage(t *testing.T) { + state := &runState{prompt: "Do the task", visits: map[string]int{"land": 1}} + state.recordFailure(protocol.RunStep{ + Stage: "land", + Outcome: "error", + Status: "failed", + Diagnostic: "delivery check \"tool/test\" failed: exit status 1: FAILED test/a_test.dart: reads the row", + }) + if len(state.turns) != 1 || state.turns[0].Stage != "land" || state.turns[0].Outcome != "error" || state.turns[0].Visit != 1 { + t.Fatalf("turns = %+v", state.turns) + } + input := state.turnInput() + for _, want := range []string{"Do the task", "The land stage failed", "FAILED test/a_test.dart: reads the row"} { + if !strings.Contains(input, want) { + t.Errorf("next input lacks %q:\n%s", want, input) + } + } +} + +func TestRecordFailureBoundsTheDiagnostic(t *testing.T) { + state := &runState{visits: map[string]int{}} + state.recordFailure(protocol.RunStep{Stage: "land", Outcome: "error", Diagnostic: "first failure\n" + strings.Repeat("x", 3*maxFailureDetail)}) + output := state.turns[0].Output + if len(output) > maxFailureDetail+400 { + t.Fatalf("output is %d bytes", len(output)) + } + if !strings.Contains(output, "first failure") || !strings.Contains(output, "[truncated]") { + t.Fatalf("output = %.200s", output) + } +} diff --git a/internal/server/turns.go b/internal/server/turns.go index 913ce8de..63e8f236 100644 --- a/internal/server/turns.go +++ b/internal/server/turns.go @@ -146,6 +146,31 @@ func (s *runState) recordTurn(step protocol.RunStep, publicFiles []string) { s.lastOutput = output } +// maxFailureDetail bounds the failure text carried to the next stage. A +// delivery check's quiet output lists its failures first, so the head is kept. +const maxFailureDetail = 6000 + +// recordFailure makes a failed visit that routes onward (an error edge to +// another stage) visible to that stage. Without it the diagnostic exists only +// on the stored step: a landing gate that fails its checks would send the run +// back to the implementer with nothing saying which checks failed. +func (s *runState) recordFailure(step protocol.RunStep) { + detail := strings.TrimSpace(step.Diagnostic) + if len(detail) > maxFailureDetail { + detail = strings.ToValidUTF8(detail[:maxFailureDetail], "") + "\n[truncated]" + } + output := "# outcome\n\nerror\n\n# handoff\n\nThe " + step.Stage + + " stage failed and sent the run back. Fix the cause below; keep the work already done.\n\n~~~\n" + + detail + "\n~~~\n" + s.turns = append(s.turns, turn.MemoryEntry{ + Stage: step.Stage, + Visit: s.visits[step.Stage], + Outcome: step.Outcome, + Output: output, + }) + s.lastOutput = output +} + // publicFileSet lists regular files below the run's public directory as paths // relative to the run directory, retaining the "public/" prefix. func publicFileSet(runRoot string) map[string]bool {