Files
archie/internal/workflow/agent.go
T
sam f8df051b19 feat: bounded concurrent task dispatch in daemon (archie-core-u64)
Daemon previously processed one task at a time. Add bounded concurrent
dispatch for SQLite and NATS agent modes, reusing [containers].max_concurrency
(0 = unlimited). Same-repository tasks stay FIFO-serialized to avoid worktree
conflicts; different repositories now run concurrently.

Unblocks archie-core-l1q (NATS transport) and archie-core-g1l
(per-repo allow_concurrent override).
2026-07-24 07:42:13 +10:00

221 lines
7.3 KiB
Go

package workflow
import (
"context"
"fmt"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/skill"
)
// AgentStage is the reusable bridge from a workflow stage to an
// agentloop run. Every LLM-driven stage in any workflow (implement's
// planner/builder, tdd's test-writer/fixer, feasibility's analyst)
// is an AgentStage with a different mission, gate, and result handler —
// never a new engine.
type AgentStage struct {
Name string
// Role selects the model via cfg.Models[Role]; falls back to
// cfg.Models["builder"].
Role string
ReadOnly bool
// Mission produces the task statement from the current context.
Mission func(*TaskContext) string
// Gate returns the stage's quality gate; nil means ungated (e.g.
// read-only analysis stages).
Gate func(*TaskContext) agentexec.Gate
// ExtraRules is appended to the system prompt.
ExtraRules string
// MaxSteps overrides the configured step budget when > 0 (planner
// stages are cheaper than builder stages).
MaxSteps int
// ProtectGlobs blocks write/edit on matching paths for this stage —
// an environmental constraint, not a prompt rule (TDD's fix stage
// protects the committed repro tests; every builder stage protects
// the repo's generated files). The returned globs are combined
// with the repo's configured protected suffixes.
ProtectGlobs func(*TaskContext) []string
// CaptureTools adds structured-output tools whose calls are returned
// as data rather than receiving callbacks into daemon state.
CaptureTools func(*TaskContext) []agentexec.CaptureTool
// OnResult consumes a successful (passed) result. Parked and idle
// results park the workflow before OnResult is called.
OnResult func(*TaskContext, agentexec.Result) error
// ReviewResult gates agent output before OnResult forwards it to
// human channels. The daemon calls this hook to review stage output
// (issue comments, PR bodies) before human delivery. Return an
// error to block the stage. Nil means pass-through — no review.
// PRD §1: daemon reviews agent responses before forwarding.
ReviewResult func(*TaskContext, agentexec.Result) error
}
// Stage adapts the AgentStage to the engine.
func (a AgentStage) Stage() Stage {
return Stage{Name: a.Name, Run: func(ctx context.Context, tc *TaskContext) error {
// Lazy-load the skill body from the worktree (dir is set by the
// prepare stage, which runs before any agent stage). If the body
// was already loaded by the daemon, this is a no-op.
if tc.SkillBody == "" && tc.Dir != "" {
tc.SkillBody = loadSkillBody(tc)
}
if tc.Agent == nil {
return fmt.Errorf("no LLM runtime configured (missing [providers] in config?)")
}
modelRef := tc.Cfg.Models[a.Role]
if modelRef == "" {
modelRef = tc.Cfg.Models["builder"]
}
if modelRef == "" {
return fmt.Errorf("no model configured for role %q (set [models] in config)", a.Role)
}
budget := agentexec.Budget{
MaxSteps: tc.Cfg.Budgets.MaxSteps,
MaxTokens: tc.Cfg.Budgets.MaxTokens,
WallClock: tc.Cfg.Budgets.WallClock.Std(),
}
if a.MaxSteps > 0 {
budget.MaxSteps = a.MaxSteps
}
var gate agentexec.Gate
if a.Gate != nil {
gate = a.Gate(tc)
}
var captureTools []agentexec.CaptureTool
if a.CaptureTools != nil {
captureTools = a.CaptureTools(tc)
}
protection := agentexec.Protection{Suffixes: append([]string(nil), tc.Repo.Protect...)}
if a.ProtectGlobs != nil {
protection.Globs = a.ProtectGlobs(tc)
}
if a.ReadOnly {
protection = agentexec.Protection{}
}
var preflight []agentexec.Command
for _, argv := range tc.Repo.ResolvedPreflight() {
if len(argv) == 0 {
continue
}
preflight = append(preflight, agentexec.Command{Name: argv[0], Argv: argv})
}
req := agentexec.Request{
Version: agentexec.ProtocolVersion,
TaskID: tc.Task.ID,
Attempt: tc.Task.Attempt,
Stage: a.Name,
Workflow: tc.Task.Workflow,
Model: modelRef,
Mission: missionWithSkill(tc, a.Mission(tc)),
ExtraRules: a.ExtraRules,
ReadOnly: a.ReadOnly,
Budget: budget,
Gate: gate,
Preflight: preflight,
Protection: protection,
Notes: tc.Task.Notes,
CaptureTools: captureTools,
Plugins: pluginSpecs(tc.SkillPlugins),
}
res, err := tc.Agent.Run(ctx, tc.Dir, req)
if err != nil && res.Version == 0 {
return fmt.Errorf("agent run: %w", err)
}
if validateErr := res.ValidateFor(req); validateErr != nil {
return fmt.Errorf("validate agent result: %w", validateErr)
}
if len(res.AppendedNotes) > 0 {
for _, note := range res.AppendedNotes {
tc.Task.Notes += "- " + note + "\n"
}
if saveErr := tc.Store.Update(ctx, tc.Task); saveErr != nil {
return fmt.Errorf("persist agent notes: %w", saveErr)
}
}
if err != nil {
return fmt.Errorf("agent run: %w", err)
}
tc.Task.TokensUsed += res.TokensUsed
tc.Task.Iterations += res.Iterations
tc.Emit("agent_finish", a.Name, res.Summary, map[string]any{
"status": string(res.Status), "stop_reason": res.StopReason,
"tokens": res.TokensUsed, "iterations": res.Iterations, "model": modelRef,
})
if res.Status != agentexec.StatusPassed {
detail := res.Detail
if detail == "" {
detail = res.Summary
}
return fmt.Errorf("agent %s (%s): %s", res.Status, res.StopReason, clip(detail, 2000))
}
// Gatekeeping: the daemon reviews agent output before human delivery.
if a.ReviewResult != nil {
if err := a.ReviewResult(tc, res); err != nil {
return fmt.Errorf("review: %w", err)
}
}
if a.OnResult != nil {
return a.OnResult(tc, res)
}
return nil
}}
}
// GateFromRepo converts the repo's configured command lists into an
// agent execution gate.
func GateFromRepo(repo config.Repo, budgets config.Budgets) agentexec.Gate {
cmds := make([]agentexec.Command, 0, len(repo.Gate))
for _, argv := range repo.Gate {
if len(argv) == 0 {
continue
}
cmds = append(cmds, agentexec.Command{Name: argv[0], Argv: argv})
}
return agentexec.Gate{Commands: cmds, MaxConsecutiveFailures: budgets.GateMaxFailures}
}
// pluginSpecs converts skill.Plugin to agentexec.PluginSpec for transport.
func pluginSpecs(plugins []skill.Plugin) []agentexec.PluginSpec {
if len(plugins) == 0 {
return nil
}
out := make([]agentexec.PluginSpec, len(plugins))
for i, p := range plugins {
out[i] = agentexec.PluginSpec{Name: p.Name, Src: p.Src}
}
return out
}
// missionWithSkill prepends the skill body (loaded from SKILL.md) to the
// stage's mission. When no skill is loaded, the mission is returned unchanged.
func missionWithSkill(tc *TaskContext, mission string) string {
if tc.SkillBody == "" {
return mission
}
return "Follow these project-specific guidelines:\n\n" + tc.SkillBody + "\n\n---\n\n" + mission
}
// loadSkillBody loads the SKILL.md body and plugins for the current
// workflow from the worktree's .agents/skills/ directory. Skills declare
// their workflow in metadata.archie.workflow — no hardcoded mapping.
func loadSkillBody(tc *TaskContext) string {
catalog, _ := skill.Catalog(tc.Dir)
entry := skill.SkillForWorkflow(catalog, tc.Task.Workflow)
if entry == nil {
return ""
}
body := skill.LoadBody(tc.Dir, entry.Dir)
if body != "" && tc.SkillPlugins == nil {
plugins, _ := skill.DiscoverPlugins(tc.Dir, entry.Dir)
tc.SkillPlugins = plugins
}
return body
}