package workflow
import (
"context"
"fmt"
"os/exec"
"strings"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/events"
)
// Bounds on how much of a failing gate command's output rides along at each
// point in this stage. They serve different purposes and are sized
// independently, not derived from one another:
// - baselineWarnLogBytes is the tail shown in daemon/container logs. Test
// runners put the useful failure after their long list of passing packages,
// so keeping the head made the operator log actively misleading.
// - baselineMissionBytes is what the builder agent sees -- generous, since
// it needs enough context to actually diagnose the failure.
// - baselineParkOutputBytes is what a human (or Archie's own chat tools)
// sees in the park reason when the builder couldn't fix it. It used to
// be zero: the returned error carried only a status string, so a park
// reason like "go build ./... fails ... (status: failed)" gave no way to
// see the actual compiler error. It stays comfortably under the store's
// own park-reason cap (see this package's Task.ParkReason clip).
const (
baselineWarnLogBytes = 2048
baselineMissionBytes = 3000
baselineParkOutputBytes = 2048
)
// StageBaselineGate verifies the repo's gate is green at the base commit.
// If the gate is red due to pre-existing failures, the builder attempts to
// fix them via TDD before proceeding. Only parks if the builder cannot fix
// the failures.
func StageBaselineGate() Stage {
return Stage{Name: "baseline", Run: func(ctx context.Context, tc *TaskContext) error {
for _, argv := range tc.Repo.Gate {
if len(argv) == 0 {
continue
}
cmd := exec.CommandContext(ctx, argv[0], argv[1:]...)
cmd.Dir = tc.Dir
out, err := cmd.CombinedOutput()
if err == nil {
continue
}
tc.Log.Warn("baseline red -- auto-fixing pre-existing gate failure",
"cmd", strings.Join(argv, " "),
"err", clipTail(string(out), baselineWarnLogBytes))
// Run builder to fix the failure via TDD.
mission := fmt.Sprintf(
"The baseline gate check `%s` failed on the repository %s at the base commit "+
"(before any feature work). This is a pre-existing issue -- not caused by your work. "+
"Fix it using TDD:\n\n"+
"1. Write a test that proves the failure exists\n"+
"2. Run the test -- it should FAIL (confirming the bug)\n"+
"3. Fix the root cause\n"+
"4. Run the test -- it should PASS\n"+
"5. Repeat until the gate `%s` passes for all packages\n\n"+
"Gate output:\n%s\n\n"+
"When the gate passes, call finish with status \"passed\".",
strings.Join(argv, " "), tc.Repo.FullName(), strings.Join(argv, " "),
clip(extractFailingGateOutput(string(out)), baselineMissionBytes),
)
modelRef := tc.Cfg.Models["builder"]
req := agentexec.Request{
Version: agentexec.ProtocolVersion,
TaskID: tc.Task.ID,
Attempt: tc.Task.Attempt,
Stage: "baseline-fix",
Workflow: tc.Task.Workflow,
Model: modelRef,
ContextWindow: modelContextBudget(tc.Cfg, modelRef),
Mission: mission,
Budget: agentexec.Budget{
MaxSteps: tc.Cfg.Budgets.MaxSteps,
WallClock: tc.Cfg.Budgets.WallClock.Std(),
},
Gate: GateFromRepo(tc.Repo, tc.Cfg.Budgets),
Protection: agentexec.Protection{Suffixes: append([]string(nil), tc.Repo.Protect...)},
}
res, agentErr := tc.Agent.Run(ctx, tc.Dir, req, tc.toolCallReporter("baseline-fix"))
if agentErr != nil && res.Version == 0 {
return fmt.Errorf("baseline-fix agent run: %w", agentErr)
}
tc.Task.TokensUsed += res.TokensUsed
tc.Task.Iterations += res.Iterations
accumulateUsage(&tc.RunUsage, res.Usage)
if emitErr := tc.EmitDurable(ctx, events.KindAgentFinish, "baseline-fix", res.Summary, agentFinishData(res, modelRef)); emitErr != nil {
return fmt.Errorf("persist baseline-fix agent finish: %w", emitErr)
}
if agentErr != nil {
return fmt.Errorf("baseline-fix agent run: %w", agentErr)
}
if res.Status != agentexec.StatusPassed {
return fmt.Errorf("baseline red -- %s fails and builder could not auto-fix (status: %s)\n\ngate output:\n%s",
strings.Join(argv, " "), res.Status, clipTail(string(out), baselineParkOutputBytes))
}
// Commit the baseline fix.
changed, commitErr := tc.Trees.CommitAll(ctx, tc.Dir,
fmt.Sprintf("fix: baseline gate repair (%s)", strings.Join(argv, " ")))
if commitErr != nil {
tc.Log.Warn("baseline fix commit failed", "err", commitErr)
}
if changed {
tc.BuildSummary = res.Summary
tc.BaselineFixed = true
}
}
return nil
}}
}
// Implement is the default workflow: plan read-only, post the plan to
// the issue for visibility, build behind the repo's gate, open the PR
// with the builder's own summary.
func Implement() Workflow {
return Workflow{
Name: "implement",
Stages: []Stage{
StagePrepareWorktree(),
StageRepoStages(),
StageBaselineGate(),
AgentStage{
Name: "plan",
Role: "planner",
ReadOnly: true,
Mission: func(tc *TaskContext) string {
prd := ""
if tc.Task.Plan != "" {
// An approved feasibility PRD precedes this run;
// the plan refines it rather than starting cold.
prd = "\n\n" + tc.Task.Plan + "\n\n"
}
return fmt.Sprintf(
"Produce a concrete implementation plan for this %s on the repository %s.\n"+prd+"\n"+
"%s\n\n"+
"Explore the codebase with your read-only tools, then call finish with status "+
"\"passed\" and the plan as the summary: files to touch, the approach, acceptance "+
"criteria, and what tests should prove it. Keep the plan tightly scoped to the task -- "+
"call finish with status \"blocked\" if the task is too vague or too large for one PR.",
taskKind(tc.Task), tc.Repo.FullName(), taskPromptBlock(tc.Task),
)
},
OnResult: func(tc *TaskContext, res agentexec.Result) error {
tc.Task.Plan = res.Summary
return nil
},
}.Stage(),
AgentStage{
Name: "build",
Role: "builder",
Gate: func(tc *TaskContext) agentexec.Gate {
return GateFromRepo(tc.Repo, tc.Cfg.Budgets)
},
ExtraRules: "Files matching the repository's protected suffixes (e.g. generated code) are " +
"write-blocked -- edit their sources instead; the gate regenerates them.",
Mission: func(tc *TaskContext) string {
return fmt.Sprintf(
"Implement this %s on the repository %s, following the plan below.\n\n"+
"%s\n\n\n%s\n\n\n"+
"Make the smallest change that satisfies the task and the plan's acceptance criteria. "+
"Do not run git -- the orchestrator commits and pushes for you. When done, call finish "+
"with status \"passed\" and a summary written for the human who will review the pull "+
"request: what changed, why, and how it was verified.",
taskKind(tc.Task), tc.Repo.FullName(), taskPromptBlock(tc.Task), tc.Task.Plan,
)
},
OnResult: func(tc *TaskContext, res agentexec.Result) error {
tc.BuildSummary = res.Summary
if res.Status == agentexec.StatusPassed && len(res.Changes) == 0 && !tc.BaselineFixed {
tc.BuildNoChanges = true
}
return nil
},
}.Stage(),
StageCommitPush(func(tc *TaskContext) string {
return fmt.Sprintf("%s (archie)", tc.Task.Title) +
commitIssueReference("Implements", tc.Task)
}),
StageYaegiGate(),
StageDiffCap(),
StageReview(),
StageOpenPR(implementPRBody),
},
}
}
// implementPRBody is the PR summary footer for the implement workflow. It
// reports the fresh-vs-cached breakdown of tc.Task.TokensUsed (see
// formatTokenUsage) so the operator isn't misled by the raw prompt-token sum
// -- most of it is typically prefix-cache hits billed at a steep discount,
// not full price. When the adversarial review ran, its findings section is
// appended so the PR states what the reviewer checked and found (h019.6).
func implementPRBody(tc *TaskContext) string {
summary := tc.BuildSummary
if section := renderPRReviewSection(tc.ReviewReport); section != "" {
summary += "\n\n" + section
}
return fmt.Sprintf("%s\n\n---\n*workflow: implement · %d iterations · %s*",
summary, tc.Task.Iterations, formatTokenUsage(tc.Task.TokensUsed, tc.RunUsage))
}