package agentworker import ( "context" "errors" "fmt" "io/fs" "log/slog" "os" "path/filepath" "strconv" "github.com/samcharles93/ai-sdk/runtime" "github.com/samcharles93/archie-core/internal/agentexec" "github.com/samcharles93/archie-core/internal/agentexec/modelloop" "github.com/samcharles93/archie-core/internal/config" "github.com/samcharles93/archie-core/internal/domain/agentrun" "github.com/samcharles93/archie-core/internal/domain/workflow" "github.com/samcharles93/archie-core/internal/domain/workflow/task" "github.com/samcharles93/archie-core/internal/events" "github.com/samcharles93/archie-core/internal/infrastructure/prsource" "github.com/samcharles93/archie-core/internal/infrastructure/taskmcp" "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/tools" "github.com/samcharles93/archie-core/internal/worktree" ) // hybridTrees implements workflow.Trees: Push goes to the daemon over // worktreerpc; local git operations run on the bind-mounted worktree. 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 host UID/GID, or -1. Push // chowns the worktree back to them. worktreeUID, worktreeGID int } // Prepare returns the worktree the daemon already prepared and its branch. func (h *hybridTrees) Prepare(ctx context.Context, owner, repo, base string, issue int, title, body, labels string, target workflow.PrepareTarget) (dir, branch string, err error) { if target != workflow.PrepareFresh { return h.localDir, string(target), nil } 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 a func that chowns the worktree back to // the daemon's UID, for every way a run can end. 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 forwards to the local worktree manager. func (h *hybridTrees) ChangedFileStats(ctx context.Context, dir, base string) (task.ChangeStats, error) { return h.local.ChangedFileStats(ctx, dir, base) } // HasUncommittedChanges forwards to the local worktree manager. func (h *hybridTrees) HasUncommittedChanges(ctx context.Context, dir string) (bool, error) { return h.local.HasUncommittedChanges(ctx, dir) } var _ workflow.Trees = (*hybridTrees)(nil) // chownTree recursively lchowns dir to uid:gid. 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 calls task.Caller trees remoteTrees events agentexec.EventPublisher // steps is the workflow step vocabulary pinned definitions are compiled // against, registered at the composition root and injected: this is the // executing half of the contract whose validating half is the control // plane's. steps *workflow.Manager // guardrails is the guardrail engine agent stages record tool outcomes // against. It is built by this process's composition root (the workflow // runs in archie-agent, so the daemon's engine cannot reach it) and set on // every TaskContext; nil means guardrails are disabled. guardrails *tools.GuardrailEngine } type runnerFactory func(map[string]agentrun.Provider, map[string]config.ModelLimits, *slog.Logger) agentrun.Runner func newTaskRunner(providers map[string]agentrun.Provider, limits map[string]config.ModelLimits, log *slog.Logger) agentrun.Runner { return modelloop.NewLoopRunner(modelloop.NewRuntime(providers, limits), log) } // applyToolLimits sets the task's tool policy and allowlist on a // *LoopRunner. Other runners are untouched. func applyToolLimits(agent agentrun.Runner, policy config.ToolPolicy, allow []string) { runner, ok := agent.(*modelloop.LoopRunner) if !ok { return } runner.Limits = modelloop.ToolLimits{ MaxResultChars: policy.MaxResultChars, SpillDir: policy.SpillDir, } runner.AllowTools = allow } // stageRunners builds the runner every agent stage uses. llm is the task's // shared model runtime (the one its MCP providers answer sampling from); the // registry path reuses it rather than building a second one. func stageRunners(req taskrun.Request, mcpSet *taskmcp.Set, newRunner runnerFactory, llm *runtime.Runtime, log *slog.Logger) (agentrun.Runner, error) { if req.Harness != nil { // The built-in loop has no route to a model from a Kit container. return agentexec.HarnessStages{Runner: agentexec.NewHarnessRunner(nil), Spec: *req.Harness}, nil } var agent agentrun.Runner if mcpSet != nil && mcpSet.Registry != nil { agent = modelloop.NewLoopRunner(llm, log, mcpSet.Registry) } else { agent = newRunner(req.Providers, req.Cfg.ModelLimits, log) } if agent == nil { return nil, fmt.Errorf("no agent runner configured for task %d", req.Task.ID) } applyToolLimits(agent, req.Cfg.ToolPolicy, req.Tools) return agent, nil } // routeTask remains available for routing-only callers. Production execution // compiles the request's pinned YAML directly. func routeTask(req taskrun.Request, registry workflow.Registry) workflow.Workflow { return workflow.Route(req.Task, registry) } // runTask compiles the immutable database definition carried by the request, // runs it, 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) { wf, err := CompilePinnedWorkflow(&req, dependencies.steps) if err != nil { return nil, err } 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")), } defer restoreWorktreeOwnership(trees, workDir, log)() llm, mcpSet := taskMCPProviders(ctx, req, dependencies, log) if mcpSet != nil { defer mcpSet.Close(ctx, log) } agent, err := stageRunners(req, mcpSet, newRunner, llm, log) if err != nil { return nil, err } agent = persistentRunner{Runner: agent, enabled: req.Repo.PersistentStorage} // Forward workflow events to the daemon over NATS. 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, Calls: dependencies.calls, Trees: trees, Agent: agent, Bus: bus, Log: log, Guardrails: dependencies.guardrails, } tc.Instructions = req.Instructions configureTaskContext(tc, workDir) 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 } // configureTaskContext applies what the task's kind changes about its context: // a test run writes nothing to a forge, and pr-review reads the PR data the // daemon prefetched into workDir. func configureTaskContext(tc *workflow.TaskContext, workDir string) { if tc.Task.IsTestRun() { workflow.SuppressForgeWrites(tc) } if tc.Task.Workflow == "pr-review" { tc.PRSource = prsource.NewFromMount(filepath.Join(workDir, prsource.PrefetchDirName)) } } // CompilePinnedWorkflow compiles the definition the request carries. With // none, it pins one from the shipped definitions onto req and req.Task. func CompilePinnedWorkflow(req *taskrun.Request, steps *workflow.Manager) (workflow.Workflow, error) { // steps is this process's required step vocabulary, so a nil one is a wiring // mistake at the composition root (productionWorkerDependencies) rather than // a runtime condition: name it instead of dereferencing it. if steps == nil { return workflow.Workflow{}, errors.New("compile pinned workflow: no step vocabulary: the composition root must register the provider set (infrastructure/workflowsteps.NewManager) before the first compile") } // One resolution for the whole function: both compiles below read the // vocabulary the composition root registered, never the builtin registry. vocabulary := steps.Registry() if req.WorkflowDefinition == "" { shipped := workflow.ShippedDefinitions() routing := make(workflow.Registry, len(shipped.Definitions)) for _, definition := range shipped.Definitions { compiled, compileErr := workflow.ParseAndCompile(definition.YAML, vocabulary) if compileErr != nil { return workflow.Workflow{}, fmt.Errorf("compile shipped workflow definition: %w", compileErr) } routing[definition.ID] = compiled } selected := routeTask(*req, routing) req.Task.Workflow = selected.Name entry, ok := shipped.DefinitionByID(selected.Name) if !ok { return workflow.Workflow{}, fmt.Errorf("task has no pinned workflow definition") } req.WorkflowDefinition = entry.YAML req.Task.WorkflowDefinitionYAML = entry.YAML req.Task.WorkflowDefinitionDigest = workflow.DigestDefinition(entry.YAML) } wf, err := workflow.ParseAndCompile(req.WorkflowDefinition, vocabulary) if err != nil { return workflow.Workflow{}, fmt.Errorf("compile pinned workflow definition: %w", err) } if wf.Name != req.Task.Workflow || workflow.DigestDefinition(req.WorkflowDefinition) != req.Task.WorkflowDefinitionDigest { return workflow.Workflow{}, fmt.Errorf("pinned workflow definition does not match task identity") } return wf, nil } func taskMCPProviders(ctx context.Context, req taskrun.Request, deps taskDependencies, log *slog.Logger) (*runtime.Runtime, *taskmcp.Set) { if req.Harness != nil || len(req.MCPServers) == 0 { return nil, nil } llm := modelloop.NewRuntime(req.Providers, req.Cfg.ModelLimits) set, err := taskmcp.Start(ctx, req.MCPServers, taskmcp.SamplingHandler(llm, req.Cfg, taskmcp.UsageRecorder(deps.store, req.Task, log)), log, storage.MCPNPMCacheMountDir) if err != nil { log.Warn("mcp providers had errors, continuing with available tools", "err", err) } return llm, set }