Files
archie/internal/app/agentworker/task_execution.go
T
sam 2ef962912a feat(tasks): attribute events, changes and config to the attempt that produced them
The events table had no attempt column, so two attempts of the same task were
indistinguishable: a retried task's stage events interleaved into one timeline and
nothing could say which run produced a given result.

- events gains an `attempt` column through the existing presence-gated
  migrateTasks loop rather than a version bump, so user_version stays 3 and an
  existing archie.db is migrated in place. A legacy-database test builds the
  pre-change schema and proves both that existing rows survive unattributed
  (attempt = 0) and that a new value round-trips.
- Event.attempt = 11 and ReadTaskLogRequest.stage = 9 are field additions to
  existing messages: no new RPC, no new table, and no change to any canonical error
  message that crosses the state-store wire.
- Every task event the workflow engine emits now carries the attempt. Producers
  that have no attempt yet (task_queued, binding_dispatch_failure) stay
  unattributed rather than guessing one.
- Changed files are captured as a durable changes_captured event at commit and push
  time, reusing the existing three-dot diff primitive: paths from FilePatches(),
  counts from Stats(), base_sha recorded as the merge base actually diffed rather
  than the base tip, a 200-file cap with totals kept complete. Consumption goes
  through an unexported optional interface so workflow.Trees -- the yaegi capability
  surface for interpreted stage plugins -- is not widened. A capture is also taken
  once the pull request exists, so the capture can link it.
- The per-attempt configuration is captured as a durable config_captured event
  carrying the non-secret config.TaskConfig, instead of a new table plus two new
  state-store RPCs: events are already this system's per-attempt provenance stream,
  so a table would have given one feature two provenance mechanisms. Redaction is
  proven against canary secrets. Measured payload: 539 bytes typical, 2333 bytes at
  20 models.
- Captures carry a schema marker and are refused unless their key set matches the
  declared payload shape, so drift surfaces as "recorded but could not be read"
  rather than as a capture of zeroes.
- Three read endpoints serve the attempt rail, the changed-file captures and a raw
  debug view, mapping to UI-owned response types rather than dumping store types.
- The task-log read gains a stage filter, bound to the stage logger for that
  stage's own lines; agent and tool output records no stage.

A task-scoped grant may already insert events on its own task, so this provenance
is exactly as trustworthy as the rest of that task's event stream. That limit is
documented rather than papered over.
2026-09-18 18:32:59 +10:00

304 lines
11 KiB
Go

package agentworker
import (
"context"
"errors"
"fmt"
"io/fs"
"log/slog"
"os"
"path/filepath"
"strconv"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/domain/workflow/skillbuild"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/domain/workflow/wfeval"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/installtype"
"github.com/samcharles93/archie-core/internal/storage"
"github.com/samcharles93/archie-core/internal/taskrun"
"github.com/samcharles93/archie-core/internal/worktree"
)
// hybridTrees implements workflow.Trees by splitting operations: Prepare
// and Push (network ops needing the daemon's forge credential) proxy over
// worktreerpc; CommitAll/Diff/ChangedFiles/ChangedLines are local git
// operations run directly against the container's bind-mounted worktree.
//
// Prepare returns the bind-mounted worktree that archied prepared before the
// container started. The sandbox has no remote prepare capability.
type remoteTrees interface {
Push(ctx context.Context) error
}
type hybridTrees struct {
push remoteTrees
local *worktree.Manager
localDir string
branch string
// worktreeUID and worktreeGID are the daemon's own host UID/GID
// (WORKTREE_UID/WORKTREE_GID, set by containerEnv), or -1 when unset.
// The agent runs as root inside the container, so a commit it writes
// to the bind-mounted worktree lands owned by UID 0 on the host; Push
// reconciles ownership back to the daemon's UID before handing off,
// since the daemon -- running as its own non-root host user -- is the
// one that reads those objects to actually push (archie-core#520).
worktreeUID, worktreeGID int
}
func (h *hybridTrees) Prepare(ctx context.Context, owner, repo, base string, issue int, title, body, labels string) (dir, branch string, err error) {
return h.localDir, h.branch, nil
}
func (h *hybridTrees) CommitAll(ctx context.Context, dir, message string) (bool, error) {
changed, commitErr := h.local.CommitAll(ctx, dir, message)
if ownershipErr := h.reconcileOwnership(dir); ownershipErr != nil {
ownershipErr = fmt.Errorf("reconcile worktree ownership after commit: %w", ownershipErr)
return changed, errors.Join(commitErr, ownershipErr)
}
return changed, commitErr
}
func (h *hybridTrees) Push(ctx context.Context, dir, branch string) error {
if err := h.reconcileOwnership(dir); err != nil {
return fmt.Errorf("reconcile worktree ownership before push: %w", err)
}
return h.push.Push(ctx)
}
func (h *hybridTrees) reconcileOwnership(dir string) error {
if h.worktreeUID < 0 || h.worktreeGID < 0 {
return nil
}
return chownTree(dir, h.worktreeUID, h.worktreeGID)
}
// restoreWorktreeOwnership returns the deferred half of the ownership
// contract: the agent runs as root inside the container, so a run that ends
// without ever reaching CommitAll or Push (a gate failure that parks the task,
// a stage error, an early return) has to hand the bind-mounted worktree back to
// the daemon's own UID on its way out. The daemon is the process that later
// cleans and resets that directory as a non-root host user, and it cannot even
// unlink inside a root-owned directory -- so a parked attempt otherwise left a
// worktree the next attempt could not start from, no matter what the refresh
// did.
//
// Returns the func rather than deferring internally so the caller's own defer
// runs it at the caller's return, not at this function's.
func restoreWorktreeOwnership(trees *hybridTrees, dir string, log *slog.Logger) func() {
return func() {
if err := trees.reconcileOwnership(dir); err != nil {
log.Warn("worktree ownership restore failed", "dir", dir, "err", err)
}
}
}
func (h *hybridTrees) Diff(ctx context.Context, dir, base string) (string, error) {
return h.local.Diff(ctx, dir, base)
}
func (h *hybridTrees) ChangedFiles(ctx context.Context, dir, base string) ([]string, error) {
return h.local.ChangedFiles(ctx, dir, base)
}
func (h *hybridTrees) Snapshot(ctx context.Context, dir, destDir string) error {
return h.local.Snapshot(ctx, dir, destDir)
}
func (h *hybridTrees) ChangedLines(ctx context.Context, dir, base string) (int, error) {
return h.local.ChangedLines(ctx, dir, base)
}
// ChangedFileStats is the capability the workflow captures a change through.
// It is not part of workflow.Trees: it is asserted for as the unexported
// optional interface package workflow declares, so a Trees implementation
// without it degrades to no capture. Without this forwarder the in-container
// path -- which is every production run, archie-agent executing the whole
// workflow -- would be exactly that silent no-op.
func (h *hybridTrees) ChangedFileStats(ctx context.Context, dir, base string) (task.ChangeStats, error) {
return h.local.ChangedFileStats(ctx, dir, base)
}
var _ workflow.Trees = (*hybridTrees)(nil)
// chownTree recursively chowns dir to uid:gid so the daemon -- running as
// its own host user -- can read loose objects the agent committed as root
// inside the container.
//
// Lchown, not Chown: a repo can legitimately track a symlink whose target
// doesn't exist inside the container (a relative link outside the
// checkout, or to a tool the image doesn't ship). Chown follows the link
// and fails on a dangling target, which would abort a push that would
// otherwise have succeeded -- worse than the permission error this is
// fixing. Lchown changes the link itself and never touches the target.
func chownTree(dir string, uid, gid int) error {
return filepath.WalkDir(dir, func(path string, _ fs.DirEntry, err error) error {
if err != nil {
return err
}
return os.Lchown(path, uid, gid)
})
}
// worktreeOwnerID parses a WORKTREE_UID/WORKTREE_GID environment value,
// returning -1 (unset/unconfigured) when it is empty or not a valid
// non-negative integer.
func worktreeOwnerID(env string) int {
if env == "" {
return -1
}
id, err := strconv.Atoi(env)
if err != nil || id < 0 {
return -1
}
return id
}
type taskDependencies struct {
forge workflow.Forger
store workflow.Store
trees remoteTrees
events agentexec.EventPublisher
}
type runnerFactory func(map[string]agentexec.Provider, *slog.Logger) agentexec.Runner
func newTaskRunner(providers map[string]agentexec.Provider, log *slog.Logger) agentexec.Runner {
return agentexec.NewLoopRunner(agentexec.NewRuntime(providers), log)
}
// applyToolLimits wires the task's carried tool policy into a *LoopRunner's
// result cap/spill, so a worker-executed stage enforces the same limits the
// daemon's own chat path applies (config.Config.Tools.Policy, carried
// non-secret via TaskConfig.ToolPolicy). A runner that isn't a *LoopRunner
// (e.g. a test fake) is left untouched.
func applyToolLimits(agent agentexec.Runner, policy config.ToolPolicy) {
runner, ok := agent.(*agentexec.LoopRunner)
if !ok {
return
}
runner.Limits = agentexec.ToolLimits{
MaxResultChars: policy.MaxResultChars,
SpillDir: policy.SpillDir,
}
}
// routeTask applies the request-carried routing bindings and selects the
// workflow for a task. The daemon's package-level SetKindWorkflows state
// never crosses the process boundary, so runTask installs the resolved
// bindings here -- this worker process is where workflow.Route actually runs.
func routeTask(req taskrun.Request, registry workflow.Registry) workflow.Workflow {
workflow.SetKindWorkflows(req.KindWorkflows)
workflow.SetLabelWorkflows(req.LabelWorkflows)
return workflow.Route(req.Task, registry)
}
// runTask builds a workflow.Registry from the container's mounted worktree,
// routes and runs the entire workflow, and reports its terminal outcome.
// Store remains archied's authority; Response.Task is a logging snapshot.
func runTask(ctx context.Context, req taskrun.Request, dependencies taskDependencies, newRunner runnerFactory, workDir string, log *slog.Logger) (*taskrun.Response, error) {
registry, err := skillbuild.BuildRegistry(workDir)
if err != nil {
return nil, fmt.Errorf("build registry: %w", err)
}
wf := routeTask(req, registry)
trees := &hybridTrees{
push: dependencies.trees,
local: &worktree.Manager{
WorkDir: workDir,
BotUser: req.Cfg.BotUser,
BotEmail: req.Cfg.BotEmail,
},
localDir: workDir,
branch: req.Task.Branch,
worktreeUID: worktreeOwnerID(os.Getenv("WORKTREE_UID")),
worktreeGID: worktreeOwnerID(os.Getenv("WORKTREE_GID")),
}
// The agent process runs as root inside the container, so everything this
// run writes into the bind-mounted worktree is owned by UID 0 on the host;
// CommitAll and Push hand it back on the success path (archie-core#520).
// Doing the same here covers every OTHER way a run can end -- a gate
// failure that parks the task, a stage error, an early return -- because
// the daemon is the one that later cleans and resets this directory, as its
// own non-root host user, and it cannot even unlink a root-owned directory.
// Without this, a parked attempt left a worktree the next attempt could not
// start from.
defer restoreWorktreeOwnership(trees, workDir, log)()
// Start MCP providers and build a local tool registry.
mcpSet, mcpErr := startMCPProviders(ctx, req.MCPServers, log)
if mcpSet != nil {
defer mcpSet.cleanup(ctx, log)
}
if mcpErr != nil {
log.Warn("mcp providers had errors, continuing with available tools", "err", mcpErr)
}
// Build a runner with MCP-discovered tools when available.
var agent agentexec.Runner
if mcpSet != nil && mcpSet.registry != nil {
agent = agentexec.NewLoopRunner(agentexec.NewRuntime(req.Providers), log, mcpSet.registry)
} else {
agent = newRunner(req.Providers, log)
}
if agent == nil {
return nil, fmt.Errorf("no agent runner configured for task %d", req.Task.ID)
}
applyToolLimits(agent, req.Cfg.ToolPolicy)
agent = persistentRunner{Runner: agent, enabled: req.Repo.PersistentStorage}
// A workflow run in this process publishes to an in-process *events.Bus
// the daemon cannot see -- archied and archie-agent are separate
// processes connected only by NATS. Without this bridge, tc.Emit is a
// silent no-op for every stage/outcome/park event this run produces,
// which is why the dashboard timeline showed nothing for any task
// executed through the container/NATS path (archie-core-518). Nil
// dependencies.events (a caller with no NATS connection, e.g. tests
// that construct taskDependencies directly) leaves bus nil, and
// TaskContext.Emit is already nil-safe.
var bus *events.Bus
if dependencies.events != nil {
bus = events.NewBus()
sub := bus.Subscribe(64)
defer sub.Close()
go agentexec.ForwardTaskEvents(sub, dependencies.events, req.Task.ID, log)
}
tc := &workflow.TaskContext{
Task: req.Task,
Repo: req.Repo,
Cfg: req.Cfg.ToConfig(),
Forge: dependencies.forge,
Store: dependencies.store,
Trees: trees,
Agent: agent,
Reviewer: newReviewerFor(req),
Bus: bus,
Log: log,
CustomStages: wfeval.Discover,
}
if req.Repo.PersistentStorage {
memory, readErr := readProjectMemory(storage.MemoryPath)
if readErr != nil {
return nil, fmt.Errorf("read project memory: %w", readErr)
}
if memory != "" {
tc.SystemPrompt = func() string { return memory }
}
}
workflow.Run(ctx, wf, tc)
return &taskrun.Response{
Task: tc.Task,
Status: tc.Outcome.Status,
AgentVersion: Version(),
AgentInstallType: installtype.Type(),
}, nil
}