Files
archie/internal/domain/workflow/agent_test.go
T
sam 5e94cef784 refactor(workflow): relocate Task/Status/Source and define workflow.Store (#754)
* refactor(workflow,store): relocate Task/Status/Source and define workflow.Store

Move store.Task, store.Status*/store.Source*, and the 3-method workflow
store interface out of internal/store into internal/domain/workflow as
workflow.Task/workflow.Status/workflow.Source plus a consumer-owned
workflow.Store, superseding store.WorkflowStore. internal/domain/workflow
now imports zero internal/store symbols; internal/store persists the
domain type instead (infrastructure depends on domain), and its Store
satisfies workflow.Store.

Updates every production and test caller of the relocated symbols across
daemon, webui, gateway, agentworker, agenttransport/nats, storerpc,
taskrun, and worktreerpc, and removes TestRecordDispatchViaExplicitTx per
docs/prds/state-store-contract.md (rev. 2c) sections 4 and 12 step 2.

Two workflow-package integration tests that exercise the real *store.Store
move to an external workflow_test package (store_integration_test.go) to
avoid a workflow(test)->store->workflow(prod) import cycle now that store
depends on workflow.

* no-mistakes(document): docs(state-store): mark §4.8 relocation done in state-store-contract
2026-09-07 00:39:26 +10:00

347 lines
12 KiB
Go

package workflow
import (
"context"
"encoding/json"
"errors"
"log/slog"
"reflect"
"strings"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/events"
)
type fakeAgentRunner struct {
workspace string
request agentexec.Request
result agentexec.Result
err error
// report is the reporter the caller passed to Run, captured so a test
// can invoke it directly and assert on the resulting tc.Emit call.
report agentexec.ToolCallReporter
}
type agentRunnerFunc func(context.Context, string, agentexec.Request, agentexec.ToolCallReporter) (agentexec.Result, error)
func (f agentRunnerFunc) Run(
ctx context.Context, workspace string, req agentexec.Request, report agentexec.ToolCallReporter,
) (agentexec.Result, error) {
return f(ctx, workspace, req, report)
}
func (r *fakeAgentRunner) Run(
_ context.Context, workspace string, req agentexec.Request, report agentexec.ToolCallReporter,
) (agentexec.Result, error) {
r.workspace = workspace
r.request = req
r.report = report
if r.result.Version == 0 {
r.result.Version = agentexec.ProtocolVersion
}
r.result.TaskID = req.TaskID
r.result.Attempt = req.Attempt
r.result.Stage = req.Stage
return r.result, r.err
}
func TestAgentStageBuildsExecutionRequestAndAppliesResult(t *testing.T) {
runner := &fakeAgentRunner{result: agentexec.Result{
Version: agentexec.ProtocolVersion, Status: agentexec.StatusPassed,
Summary: "finished", TokensUsed: 23, Iterations: 4,
}}
resultCalled := false
stage := AgentStage{
Name: "plan", Role: "planner", ReadOnly: true, MaxSteps: 7,
Mission: func(*TaskContext) string { return "inspect the repository" },
OnResult: func(_ *TaskContext, result agentexec.Result) error {
resultCalled = result.Summary == "finished"
return nil
},
}.Stage()
task := &Task{ID: 9, Attempt: 2}
tc := &TaskContext{
Task: task, Agent: runner, Dir: "/tmp/workspace", Log: slog.New(slog.DiscardHandler),
Cfg: config.Config{
Models: map[string]string{"builder": "provider/fallback"},
Budgets: config.Budgets{MaxSteps: 50},
},
Repo: config.Repo{Protect: []string{"_templ.go"}, Preflight: [][]string{{"go", "version"}}},
}
if err := stage.Run(context.Background(), tc); err != nil {
t.Fatal(err)
}
if runner.workspace != tc.Dir {
t.Fatalf("workspace = %q, want %q", runner.workspace, tc.Dir)
}
wantPreflight := []agentexec.Command{{Name: "go", Argv: []string{"go", "version"}}}
if runner.request.Version != agentexec.ProtocolVersion || runner.request.TaskID != 9 || runner.request.Attempt != 2 ||
runner.request.Model != "provider/fallback" || runner.request.Budget.MaxSteps != 7 || !runner.request.ReadOnly ||
!reflect.DeepEqual(runner.request.Preflight, wantPreflight) {
t.Fatalf("unexpected request: %#v", runner.request)
}
if len(runner.request.Protection.Suffixes) != 0 {
t.Fatalf("read-only request has protection rules: %#v", runner.request.Protection)
}
if !resultCalled || task.TokensUsed != 23 || task.Iterations != 4 {
t.Fatalf("result not applied: called=%v task=%#v", resultCalled, task)
}
}
// TestAgentStageReportsToolCallsOnTheTaskBus pins archie-core-467's
// task-transcript counterpart: the reporter AgentStage.Stage() passes into
// tc.Agent.Run must, when invoked, publish a tool_call event onto tc.Bus
// carrying the tool name and outcome -- otherwise a workflow task's own
// transcript never shows what its tools actually did, only the chat
// gateway's interactive turns do.
func TestAgentStageReportsToolCallsOnTheTaskBus(t *testing.T) {
runner := &fakeAgentRunner{result: agentexec.Result{
Version: agentexec.ProtocolVersion, Status: agentexec.StatusPassed,
}}
stage := AgentStage{
Name: "build",
Role: "builder",
Mission: func(*TaskContext) string { return "implement the feature" },
}.Stage()
bus := events.NewBus()
sub := bus.Subscribe(8)
t.Cleanup(sub.Close)
task := &Task{ID: 9, Owner: "acme", Repo: "widget", Attempt: 1}
tc := &TaskContext{
Task: task, Agent: runner, Dir: "/tmp/workspace", Bus: bus, Log: slog.New(slog.DiscardHandler),
Cfg: config.Config{Models: map[string]string{"builder": "provider/model"}},
}
if err := stage.Run(context.Background(), tc); err != nil {
t.Fatal(err)
}
if runner.report == nil {
t.Fatal("AgentStage did not pass a ToolCallReporter to Run")
}
runner.report(agentexec.ToolCallReport{Tool: "read_file", Detail: `"package main"`, Failed: false})
runner.report(agentexec.ToolCallReport{Tool: "shell", Detail: "error: exit status 1", Failed: true})
var got []events.Event
for len(got) < 2 {
select {
case e := <-sub.C:
if e.Kind == events.KindToolCall {
got = append(got, e)
}
case <-time.After(time.Second):
t.Fatalf("timed out waiting for tool_call events, got %d", len(got))
}
}
if got[0].Stage != "build" || got[0].Data["tool"] != "read_file" || got[0].Detail != `"package main"` || got[0].Data["failed"] != false {
t.Fatalf("first tool_call event = %#v", got[0])
}
if got[1].Data["tool"] != "shell" || got[1].Detail != "error: exit status 1" || got[1].Data["failed"] != true {
t.Fatalf("second tool_call event = %#v", got[1])
}
}
func TestAgentStageDiscardsUnstampedErrorResult(t *testing.T) {
task := &Task{ID: 1, Attempt: 1, Notes: "existing\n"}
runner := agentRunnerFunc(func(context.Context, string, agentexec.Request, agentexec.ToolCallReporter) (agentexec.Result, error) {
return agentexec.Result{AppendedNotes: []string{"untrusted"}}, errors.New("worker exited")
})
stage := AgentStage{
Name: "build", Role: "builder", Mission: func(*TaskContext) string { return "build" },
}.Stage()
err := stage.Run(context.Background(), &TaskContext{
Task: task, Agent: runner, Log: slog.New(slog.DiscardHandler),
Cfg: config.Config{Models: map[string]string{"builder": "provider/model"}},
})
if err == nil {
t.Fatal("stage accepted an unstamped error result")
}
if task.Notes != "existing\n" {
t.Fatalf("unstamped error result mutated notes: %q", task.Notes)
}
}
func TestFeasibilityDecisionCrossesAsCapturedData(t *testing.T) {
runner := &fakeAgentRunner{result: agentexec.Result{
Version: agentexec.ProtocolVersion, Status: agentexec.StatusPassed,
Captures: map[string][]json.RawMessage{"decide": {json.RawMessage(`{"fit":true,"reasons":"aligned"}`)}},
}}
tc := &TaskContext{
Task: &Task{ID: 1}, Agent: runner, Log: slog.New(slog.DiscardHandler),
Cfg: config.Config{Models: map[string]string{"planner": "provider/model"}},
Repo: config.Repo{Owner: "owner", Name: "repo"},
}
if err := Feasibility().Stages[1].Run(context.Background(), tc); err != nil {
t.Fatal(err)
}
if tc.decision == nil || !tc.decision.Fit || tc.decision.Reasons != "aligned" {
t.Fatalf("decision = %#v", tc.decision)
}
}
func TestImplementPlanTreatsChatSourceAsNativeTask(t *testing.T) {
runner := &fakeAgentRunner{result: agentexec.Result{
Status: agentexec.StatusPassed, Summary: "plan",
}}
forgeClient := &fakeForge{}
tc := &TaskContext{
Task: &Task{
ID: 1, IssueNumber: 999_001, Title: "Fix chat task", Source: SourceChat,
},
Agent: runner,
Forge: forgeClient,
Log: slog.New(slog.DiscardHandler),
Cfg: config.Config{Models: map[string]string{"planner": "provider/model"}},
Repo: config.Repo{Owner: "owner", Name: "repo"},
}
if err := Implement().Stages[3].Run(context.Background(), tc); err != nil {
t.Fatal(err)
}
if strings.Contains(runner.request.Mission, "999001") ||
!strings.Contains(runner.request.Mission, `<task source="chat">`) {
t.Errorf("chat mission uses synthetic issue semantics:\n%s", runner.request.Mission)
}
if len(forgeClient.commented) != 0 {
t.Fatalf("chat planning posted %d issue comments", len(forgeClient.commented))
}
}
func TestFeasibilityChatTaskAvoidsIssueOperations(t *testing.T) {
t.Run("not fit", func(t *testing.T) {
runner := &fakeAgentRunner{result: agentexec.Result{
Status: agentexec.StatusPassed,
Captures: map[string][]json.RawMessage{
"decide": {json.RawMessage(`{"fit":false,"reasons":"out of scope"}`)},
},
}}
forgeClient := &fakeForge{}
tc := &TaskContext{
Task: &Task{
ID: 1, IssueNumber: 999_001, Title: "Feature", Source: SourceChat,
},
Agent: runner,
Forge: forgeClient,
Log: slog.New(slog.DiscardHandler),
Cfg: config.Config{Models: map[string]string{"planner": "provider/model"}},
Repo: config.Repo{Owner: "owner", Name: "repo"},
}
if err := Feasibility().Stages[1].Run(context.Background(), tc); err != nil {
t.Fatal(err)
}
if forgeClient.closed != 0 || tc.Outcome.Status != StatusClosedWontDo {
t.Fatalf("close calls/outcome = %d/%q", forgeClient.closed, tc.Outcome.Status)
}
})
t.Run("await approval", func(t *testing.T) {
forgeClient := &fakeForge{}
tc := &TaskContext{
Task: &Task{
ID: 1, IssueNumber: 999_001, Plan: "PRD", Source: SourceChat,
},
Forge: forgeClient,
Log: slog.New(slog.DiscardHandler),
}
if err := Feasibility().Stages[3].Run(context.Background(), tc); err != nil {
t.Fatal(err)
}
if len(forgeClient.commented) != 0 || tc.Task.WatchCommentID != 0 ||
tc.Outcome.Status != StatusWaitingHuman {
t.Fatalf("comments/watch/outcome = %d/%d/%q",
len(forgeClient.commented), tc.Task.WatchCommentID, tc.Outcome.Status)
}
})
}
func TestFeasibilityRejectsNullFitValue(t *testing.T) {
runner := &fakeAgentRunner{result: agentexec.Result{
Status: agentexec.StatusPassed,
Captures: map[string][]json.RawMessage{"decide": {json.RawMessage(`{"fit":null,"reasons":"not valid"}`)}},
}}
tc := &TaskContext{
Task: &Task{ID: 1}, Agent: runner, Log: slog.New(slog.DiscardHandler),
Cfg: config.Config{Models: map[string]string{"planner": "provider/model"}},
Repo: config.Repo{Owner: "owner", Name: "repo"},
}
if err := Feasibility().Stages[1].Run(context.Background(), tc); err == nil {
t.Fatal("assess accepted a null fit value")
}
if tc.decision != nil {
t.Fatalf("decision mutated from invalid capture: %#v", tc.decision)
}
}
// ── regression: Gap 5 -- daemon review step ──────────────────────────
func TestReviewResultBlocksOnResultWhenRejected(t *testing.T) {
// Gap 5: no daemon review step before human delivery.
// PRD section 1: the daemon reviews agent responses before forwarding
// to human channels. When ReviewResult returns an error, the stage
// must fail and OnResult must NOT be called. When ReviewResult
// returns nil, OnResult IS called. Currently ReviewResult exists
// but no workflow uses it -- the review step is never exercised.
runner := &fakeAgentRunner{result: agentexec.Result{
Version: agentexec.ProtocolVersion, Status: agentexec.StatusPassed,
Summary: "sensitive output", TokensUsed: 1,
}}
// Test 1: ReviewResult rejects → OnResult must not be called.
onResultCalled := false
rejectStage := AgentStage{
Name: "plan",
Role: "planner",
Mission: func(*TaskContext) string { return "test" },
ReviewResult: func(_ *TaskContext, _ agentexec.Result) error {
return agentexec.ErrBlocked
},
OnResult: func(_ *TaskContext, _ agentexec.Result) error {
onResultCalled = true
return nil
},
}.Stage()
tc := &TaskContext{
Task: &Task{ID: 1, Attempt: 1},
Agent: runner, Log: slog.New(slog.DiscardHandler),
Cfg: config.Config{Models: map[string]string{"planner": "provider/model"}},
}
err := rejectStage.Run(context.Background(), tc)
if err == nil {
t.Error("Gap 5: ReviewResult returned an error but the stage did not fail. " +
"ReviewResult must block the stage when it rejects output.")
}
if onResultCalled {
t.Error("Gap 5: ReviewResult rejected the output but OnResult was still called. " +
"ReviewResult must gate OnResult -- rejected output must not reach human channels.")
}
// Test 2: ReviewResult approves → OnResult IS called.
onResultCalled = false
approveStage := AgentStage{
Name: "plan",
Role: "planner",
Mission: func(*TaskContext) string { return "test" },
ReviewResult: func(_ *TaskContext, _ agentexec.Result) error {
return nil // approved
},
OnResult: func(_ *TaskContext, _ agentexec.Result) error {
onResultCalled = true
return nil
},
}.Stage()
if err := approveStage.Run(context.Background(), tc); err != nil {
t.Fatalf("unexpected stage error: %v", err)
}
if !onResultCalled {
t.Error("Gap 5: ReviewResult approved the output but OnResult was not called. " +
"Approved output must flow through to human channels.")
}
}