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.
207 lines
7.6 KiB
Go
207 lines
7.6 KiB
Go
// Package taskactions owns operator task mutations shared by chat and dashboard.
|
|
package taskactions
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"github.com/samcharles93/archie-core/internal/events"
|
|
"github.com/samcharles93/archie-core/internal/taskstate"
|
|
)
|
|
|
|
var (
|
|
ErrNotFound = errors.New("task not found")
|
|
ErrConflict = errors.New("task action conflict")
|
|
ErrUnavailable = errors.New("runtime task control is unavailable")
|
|
)
|
|
|
|
// Task is the state needed to authorize and apply an operator action.
|
|
type Task struct {
|
|
ID int64
|
|
Owner, Repo, Identity, Status, Stage, ParkReason string
|
|
IssueNumber, RetryCount int
|
|
ForgeBacked bool
|
|
// Attempt is the run the operator acted on. It is stamped onto the event
|
|
// this action records so an intervention is attributable to the run it
|
|
// changed course -- without it a retry or a stop is indistinguishable
|
|
// between attempts on the timeline.
|
|
Attempt int
|
|
}
|
|
|
|
type Store interface {
|
|
TaskByID(context.Context, int64) (*Task, error)
|
|
Transition(context.Context, int64, string, string, string) error
|
|
Requeue(context.Context, int64, string, string) error
|
|
RetryTask(context.Context, int64, string, string) error
|
|
ArchiveTask(context.Context, int64, string, events.Event) (int64, error)
|
|
InsertEvent(context.Context, events.Event) (int64, error)
|
|
}
|
|
|
|
// Service runs in the daemon, which owns execution cancellation and events.
|
|
type Service struct {
|
|
Store Store
|
|
MaxRetries func(*Task) int
|
|
CancelTask func(int64) bool
|
|
CloseIssue func(context.Context, string, string, int, string) error
|
|
RemoveLogs func(int64) error
|
|
Publish func(events.Event)
|
|
Warn func(string, ...any)
|
|
}
|
|
|
|
// Apply scopes chat requests to an identity. A nil identity denotes an
|
|
// authenticated dashboard operator, who may act across identities.
|
|
func (s Service) Apply(ctx context.Context, identity *string, id int64, action taskstate.Action) error {
|
|
task, err := s.Store.TaskByID(ctx, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if task == nil {
|
|
return fmt.Errorf("task %d: %w", id, ErrNotFound)
|
|
}
|
|
if identity != nil && task.Identity != *identity {
|
|
return fmt.Errorf("task %d belongs to %q, not %q", id, task.Identity, *identity)
|
|
}
|
|
if err := taskstate.CheckAction(task.Status, action); err != nil {
|
|
return fmt.Errorf("%w: %w", ErrConflict, err)
|
|
}
|
|
mutation, err := s.apply(ctx, task, identity, action)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if mutation.verb != "" && task.ForgeBacked {
|
|
s.closeRejectedIssue(ctx, task, identity, mutation.verb)
|
|
}
|
|
s.emit(ctx, mutation.event)
|
|
return nil
|
|
}
|
|
|
|
type outcome struct {
|
|
event events.Event
|
|
verb string
|
|
}
|
|
|
|
// apply performs the store mutation for one action and returns the event to
|
|
// record alongside it. Errors from the store are returned unwrapped: the
|
|
// caller maps them to a response, and the rules-level errors (ErrConflict)
|
|
// were already checked above.
|
|
func (s Service) apply(ctx context.Context, task *Task, identity *string, action taskstate.Action) (outcome, error) {
|
|
source := "the dashboard"
|
|
if identity != nil {
|
|
source = "chat"
|
|
}
|
|
o := outcome{event: events.Event{TaskID: task.ID, Repo: task.Owner + "/" + task.Repo, Issue: task.IssueNumber, Attempt: task.Attempt}}
|
|
switch action {
|
|
case taskstate.ActionApprove:
|
|
err := s.Store.Requeue(ctx, task.ID, "waiting_human", "implement")
|
|
o.event.Kind, o.event.Detail = events.KindHumanApproved, "approved via "+source
|
|
return o, err
|
|
case taskstate.ActionRetry:
|
|
return s.applyRetry(ctx, task, source, o)
|
|
case taskstate.ActionStop:
|
|
return s.applyStop(ctx, task, source, o)
|
|
case taskstate.ActionReject:
|
|
o.event.Kind, o.event.Detail, o.verb = events.KindHumanRejected, "rejected via "+source, "rejected"
|
|
if task.Status == "running" && s.CancelTask != nil {
|
|
s.CancelTask(task.ID)
|
|
}
|
|
return o, s.Store.Transition(ctx, task.ID, task.Status, "closed_wont_do", "declined from "+source)
|
|
case taskstate.ActionCancel, taskstate.ActionAbandon:
|
|
return s.applyCancelOrAbandon(ctx, task, action, source, o)
|
|
case taskstate.ActionArchive:
|
|
return s.applyArchive(ctx, task, source, o)
|
|
default:
|
|
return o, fmt.Errorf("unsupported task action %q", action)
|
|
}
|
|
}
|
|
|
|
func (s Service) applyRetry(ctx context.Context, task *Task, source string, o outcome) (outcome, error) {
|
|
limit := 0
|
|
if s.MaxRetries != nil {
|
|
limit = s.MaxRetries(task)
|
|
}
|
|
if limit > 0 && task.RetryCount >= limit {
|
|
reason := fmt.Sprintf("max retries reached (%d/%d)", task.RetryCount, limit)
|
|
if err := s.Store.Transition(ctx, task.ID, "parked", "dead", reason); err != nil {
|
|
s.warn("transition to dead failed", "task", task.ID, "err", err)
|
|
} else {
|
|
o.event.Kind, o.event.Detail = events.KindTaskDead, reason
|
|
s.emit(ctx, o.event)
|
|
}
|
|
return o, fmt.Errorf("%w: %s", ErrConflict, reason)
|
|
}
|
|
err := s.Store.RetryTask(ctx, task.ID, "parked", "")
|
|
o.event.Kind, o.event.Detail = events.KindTaskRetried, "retried via "+source
|
|
o.event.Data = map[string]any{"retry_count": task.RetryCount + 1, "previous_stage": task.Stage, "previous_reason": task.ParkReason}
|
|
return o, err
|
|
}
|
|
|
|
func (s Service) applyStop(ctx context.Context, task *Task, source string, o outcome) (outcome, error) {
|
|
if s.CancelTask == nil {
|
|
return o, ErrUnavailable
|
|
}
|
|
o.event.Kind, o.event.Detail = events.KindTaskStopped, "stopped via "+source+"; recoverable work remains parked"
|
|
if !s.CancelTask(task.ID) {
|
|
o.event.Detail = "no active execution was found; recoverable work was parked via " + source
|
|
}
|
|
return o, s.Store.Transition(ctx, task.ID, "running", "parked", o.event.Detail)
|
|
}
|
|
|
|
func (s Service) applyCancelOrAbandon(ctx context.Context, task *Task, action taskstate.Action, source string, o outcome) (outcome, error) {
|
|
from, kind, verb := "queued", events.KindTaskCancelled, "cancelled"
|
|
if action == taskstate.ActionAbandon {
|
|
from, kind, verb = "parked", events.KindTaskAbandoned, "abandoned"
|
|
}
|
|
o.event.Kind, o.event.Detail, o.verb = kind, verb+" via "+source, verb
|
|
return o, s.Store.Transition(ctx, task.ID, from, "closed_wont_do", o.event.Detail)
|
|
}
|
|
|
|
func (s Service) applyArchive(ctx context.Context, task *Task, source string, o outcome) (outcome, error) {
|
|
o.event.Kind, o.event.Detail = events.KindTaskArchiveRequested, "archive requested via "+source
|
|
id, err := s.Store.ArchiveTask(ctx, task.ID, task.Status, o.event)
|
|
if err != nil {
|
|
return o, err
|
|
}
|
|
o.event.ID = id
|
|
if s.RemoveLogs != nil {
|
|
if cleanupErr := s.RemoveLogs(task.ID); cleanupErr != nil {
|
|
s.warn("task log cleanup failed", "task", task.ID, "err", cleanupErr)
|
|
}
|
|
}
|
|
return o, nil
|
|
}
|
|
|
|
func (s Service) closeRejectedIssue(ctx context.Context, task *Task, identity *string, verb string) {
|
|
if s.CloseIssue == nil {
|
|
s.warn("task rejected but no forge is wired; the issue stays open and will be re-polled", "task", task.ID)
|
|
return
|
|
}
|
|
comment := fmt.Sprintf("Closing: this task was %s from the archie %s. Reopen the issue to have archie pick it up again.", verb, "dashboard")
|
|
if identity != nil {
|
|
comment = fmt.Sprintf("Closing: this task was %s from archie chat. Reopen the issue to have archie pick it up again.", verb)
|
|
}
|
|
if err := s.CloseIssue(ctx, task.Owner, task.Repo, task.IssueNumber, comment); err != nil {
|
|
s.warn("closing rejected issue failed; it stays open and will be re-polled", "task", task.ID, "err", err)
|
|
}
|
|
}
|
|
|
|
func (s Service) emit(ctx context.Context, e events.Event) {
|
|
if e.ID == 0 {
|
|
id, err := s.Store.InsertEvent(ctx, e)
|
|
if err != nil {
|
|
s.warn("operator activity persistence failed", "kind", e.Kind, "task", e.TaskID, "err", err)
|
|
} else {
|
|
e.ID = id
|
|
}
|
|
}
|
|
if s.Publish != nil {
|
|
s.Publish(e)
|
|
}
|
|
}
|
|
|
|
func (s Service) warn(msg string, args ...any) {
|
|
if s.Warn != nil {
|
|
s.Warn(msg, args...)
|
|
}
|
|
}
|