From 64da3952aa089c36f42eebe25d67523f43116441 Mon Sep 17 00:00:00 2001 From: Sam Catlow Date: Tue, 25 Aug 2026 01:19:21 +1000 Subject: [PATCH] feat(gateway): add task_action chat tool for operator task management Adds the task_action tool to internal/gateway/task_tools.go and wires it via chatTaskActorAdapter in cmd/archied. This enables operators in chat to execute lifecycle actions (abandon, archive, retry, stop, cancel, approve, reject) on tasks using the same action path and state machine as the dashboard. Enforces identity scoping so an instance cannot mutate another identity's tasks, verifies status permissions via internal/taskstate, and classifies the tool as mutating with required human approval. --- cmd/archied/bootstrap.go | 10 + cmd/archied/main.go | 71 +++++ cmd/archied/task_action_adapter_test.go | 340 ++++++++++++++++++++++ cmd/archied/telegram_setup.go | 2 + internal/gateway/task_action_tool_test.go | 265 +++++++++++++++++ internal/gateway/task_tools.go | 83 +++++- internal/gateway/task_tools_test.go | 36 +-- internal/gateway/turn.go | 3 +- 8 files changed, 779 insertions(+), 31 deletions(-) create mode 100644 cmd/archied/task_action_adapter_test.go create mode 100644 internal/gateway/task_action_tool_test.go diff --git a/cmd/archied/bootstrap.go b/cmd/archied/bootstrap.go index e7a517b29..fbac4379d 100644 --- a/cmd/archied/bootstrap.go +++ b/cmd/archied/bootstrap.go @@ -484,6 +484,11 @@ func (b *boot) setupLLMAndChat(ctx context.Context) { tasks: b.st.TaskByID, taskLogs: b.taskLogs, }, + ChatTaskActor: chatTaskActorAdapter{ + tasks: b.st.TaskByID, + handler: b.web.Handler(), + token: func() string { return b.web.Token }, + }, DefaultChatIdentity: b.defaultChatIdentity, SessionStore: b.chatSessionStore, Bus: b.bus, Log: log, } @@ -516,6 +521,11 @@ func (b *boot) setupGateways(ctx context.Context, cfgPath, overlayPath string) b tasks: b.st.TaskByID, taskLogs: b.taskLogs, }, + ChatTaskActor: chatTaskActorAdapter{ + tasks: b.st.TaskByID, + handler: b.web.Handler(), + token: func() string { return b.web.Token }, + }, DefaultChatIdentity: b.defaultChatIdentity, SessionStore: b.chatSessionStore, Updates: b.updateService, Bus: b.bus, RegisterRestart: func(request func() error) { b.restartTelegram = request }, Log: log, diff --git a/cmd/archied/main.go b/cmd/archied/main.go index f4aa1b584..d069afd7e 100644 --- a/cmd/archied/main.go +++ b/cmd/archied/main.go @@ -5,6 +5,7 @@ package main import ( + "bytes" "context" "crypto/sha256" "encoding/json" @@ -13,6 +14,8 @@ import ( "log/slog" "maps" "net" + "net/http" + "net/http/httptest" "os" "os/signal" "path/filepath" @@ -43,6 +46,7 @@ import ( "github.com/samcharles93/archie-core/internal/storage" "github.com/samcharles93/archie-core/internal/store" "github.com/samcharles93/archie-core/internal/storerpc" + "github.com/samcharles93/archie-core/internal/taskstate" "github.com/samcharles93/archie-core/internal/tools" "github.com/samcharles93/archie-core/internal/tools/mcp" toolprovider "github.com/samcharles93/archie-core/internal/tools/provider" @@ -597,6 +601,73 @@ func (a chatTaskLogReaderAdapter) ReadChatTaskLogs( }, nil } +// chatTaskActorAdapter executes operator actions on a task via the same +// action path the dashboard uses, ensuring chat and webui cannot diverge. +// It enforces identity scoping so an identity cannot mutate another +// identity's tasks. +type chatTaskActorAdapter struct { + tasks func(context.Context, int64) (*store.Task, error) + handler http.Handler + token func() string +} + +func (a chatTaskActorAdapter) ApplyChatTaskAction( + ctx context.Context, identity string, taskID int64, action taskstate.Action, +) (gateway.TaskActionResult, error) { + if a.tasks == nil || a.handler == nil { + return gateway.TaskActionResult{}, fmt.Errorf("task actions are not configured") + } + task, err := a.tasks(ctx, taskID) + if err != nil { + return gateway.TaskActionResult{}, err + } + if task == nil { + return gateway.TaskActionResult{}, fmt.Errorf("task %d not found", taskID) + } + // Match the filter chatTaskListerAdapter and chatTaskLogReaderAdapter apply: + // a model bound to one identity must not mutate another identity's tasks, + // and tasks with no identity (forge-sourced) are not actionable through a + // chat tool at all — they belong to the daemon, not a particular identity. + if task.Identity != identity { + return gateway.TaskActionResult{}, fmt.Errorf("task %d belongs to %q, not %q", taskID, task.Identity, identity) + } + if err := taskstate.CheckAction(task.Status, action); err != nil { + return gateway.TaskActionResult{}, err + } + + body, err := json.Marshal(map[string]any{"action": string(action)}) + if err != nil { + return gateway.TaskActionResult{}, fmt.Errorf("marshal action request: %w", err) + } + req := httptest.NewRequestWithContext(ctx, http.MethodPost, + fmt.Sprintf("/api/tasks/%d/action", taskID), + bytes.NewReader(body), + ) + req.Header.Set("Content-Type", "application/json") + req.Header.Set("X-Archie-CSRF", "1") + if a.token != nil { + if tok := a.token(); tok != "" { + req.Header.Set("Authorization", "Bearer "+tok) + } + } + rec := httptest.NewRecorder() + a.handler.ServeHTTP(rec, req) + + if rec.Code != http.StatusOK { + errMsg := strings.TrimSpace(rec.Body.String()) + if errMsg == "" { + errMsg = fmt.Sprintf("HTTP %d", rec.Code) + } + return gateway.TaskActionResult{}, fmt.Errorf("action %s on task %d failed: %s", action, taskID, errMsg) + } + + return gateway.TaskActionResult{ + TaskID: taskID, + Action: string(action), + Message: fmt.Sprintf("Applied %s to task %d.", action, taskID), + }, nil +} + func chatTaskProfiles(cfg config.Config) ([]gateway.TaskProfile, string) { if len(cfg.Identities) > 0 { profiles := make([]gateway.TaskProfile, 0, len(cfg.Identities)) diff --git a/cmd/archied/task_action_adapter_test.go b/cmd/archied/task_action_adapter_test.go new file mode 100644 index 000000000..5ad1e8488 --- /dev/null +++ b/cmd/archied/task_action_adapter_test.go @@ -0,0 +1,340 @@ +package main + +import ( + "context" + "path/filepath" + "strings" + "testing" + + "github.com/samcharles93/archie-core/internal/config" + "github.com/samcharles93/archie-core/internal/store" + "github.com/samcharles93/archie-core/internal/taskstate" + "github.com/samcharles93/archie-core/internal/webui" +) + +func TestChatTaskActorAdapterCrossIdentityRefused(t *testing.T) { + ctx := context.Background() + st, err := store.Open(ctx, filepath.Join(t.TempDir(), "tasks.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + + task, err := st.EnqueueChatTask(ctx, "acme", "widget", "parked job", "", "", "identity-owner") + if err != nil { + t.Fatal(err) + } + if err := st.Transition(ctx, task.ID, store.StatusQueued, store.StatusParked, "needs help"); err != nil { + t.Fatal(err) + } + + srv := &webui.Server{Store: st, Cfg: config.NewHolder(config.Config{})} + adapter := chatTaskActorAdapter{ + tasks: st.TaskByID, + handler: srv.Handler(), + token: func() string { return srv.Token }, + } + + tests := []struct { + name string + actorIdentity string + action taskstate.Action + }{ + { + name: "different identity cannot abandon", + actorIdentity: "identity-attacker", + action: taskstate.ActionAbandon, + }, + { + name: "different identity cannot retry", + actorIdentity: "identity-attacker", + action: taskstate.ActionRetry, + }, + { + name: "different identity cannot archive", + actorIdentity: "identity-attacker", + action: taskstate.ActionArchive, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + _, err := adapter.ApplyChatTaskAction(ctx, tc.actorIdentity, task.ID, tc.action) + if err == nil { + t.Fatalf("ApplyChatTaskAction() allowed cross-identity action %s by %q on task owned by %q", + tc.action, tc.actorIdentity, task.Identity) + } + if !strings.Contains(err.Error(), "identity-owner") || !strings.Contains(err.Error(), tc.actorIdentity) { + t.Errorf("error = %q, want mention of both identities", err.Error()) + } + + // Confirm store state was NOT mutated. + current, err := st.TaskByID(ctx, task.ID) + if err != nil || current == nil { + t.Fatalf("TaskByID = (%+v, %v)", current, err) + } + if current.Status != store.StatusParked { + t.Errorf("task status mutated to %q despite cross-identity refusal", current.Status) + } + }) + } +} + +func TestChatTaskActorAdapterRefusesDisallowedStateAction(t *testing.T) { + ctx := context.Background() + st, err := store.Open(ctx, filepath.Join(t.TempDir(), "tasks.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + + srv := &webui.Server{Store: st, Cfg: config.NewHolder(config.Config{})} + adapter := chatTaskActorAdapter{ + tasks: st.TaskByID, + handler: srv.Handler(), + token: func() string { return srv.Token }, + } + + tests := []struct { + name string + initialStatus string + attemptAction taskstate.Action + }{ + { + name: "cannot abandon running task", + initialStatus: store.StatusRunning, + attemptAction: taskstate.ActionAbandon, + }, + { + name: "cannot archive parked task", + initialStatus: store.StatusParked, + attemptAction: taskstate.ActionArchive, + }, + { + name: "cannot retry queued task", + initialStatus: store.StatusQueued, + attemptAction: taskstate.ActionRetry, + }, + { + name: "cannot approve running task", + initialStatus: store.StatusRunning, + attemptAction: taskstate.ActionApprove, + }, + { + name: "cannot reject queued task", + initialStatus: store.StatusQueued, + attemptAction: taskstate.ActionReject, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + task, err := st.EnqueueChatTask(ctx, "acme", "widget", "test task", "", "", "archie") + if err != nil { + t.Fatal(err) + } + if tc.initialStatus != store.StatusQueued { + if err := st.Transition(ctx, task.ID, store.StatusQueued, tc.initialStatus, "setup"); err != nil { + t.Fatal(err) + } + } + + _, err = adapter.ApplyChatTaskAction(ctx, "archie", task.ID, tc.attemptAction) + if err == nil { + t.Fatalf("expected error attempting %s on %s task, got nil", tc.attemptAction, tc.initialStatus) + } + + // Assert error matches taskstate rules. + wantErr := taskstate.CheckAction(tc.initialStatus, tc.attemptAction) + if wantErr != nil && !strings.Contains(err.Error(), wantErr.Error()) { + t.Errorf("error = %q, want substring %q", err.Error(), wantErr.Error()) + } + + // Ensure task status did not change. + current, err := st.TaskByID(ctx, task.ID) + if err != nil || current == nil { + t.Fatalf("TaskByID = (%+v, %v)", current, err) + } + if current.Status != tc.initialStatus { + t.Errorf("task status changed to %q, want %q", current.Status, tc.initialStatus) + } + }) + } +} + +func TestChatTaskActorAdapterTaskNotFound(t *testing.T) { + ctx := context.Background() + st, err := store.Open(ctx, filepath.Join(t.TempDir(), "tasks.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + + srv := &webui.Server{Store: st, Cfg: config.NewHolder(config.Config{})} + adapter := chatTaskActorAdapter{ + tasks: st.TaskByID, + handler: srv.Handler(), + token: func() string { return srv.Token }, + } + + _, err = adapter.ApplyChatTaskAction(ctx, "archie", 999999, taskstate.ActionAbandon) + if err == nil { + t.Fatal("expected error for non-existent task, got nil") + } + if !strings.Contains(err.Error(), "not found") { + t.Errorf("error = %q, want 'not found'", err.Error()) + } +} + +func TestChatTaskActorAdapterAppliesActionsToStore(t *testing.T) { + tests := []struct { + name string + initialStatus string + action taskstate.Action + wantStatus string + wantArchived bool + }{ + { + name: "abandon parked task closes it won't do", + initialStatus: store.StatusParked, + action: taskstate.ActionAbandon, + wantStatus: store.StatusClosedWontDo, + }, + { + name: "retry parked task requeues it", + initialStatus: store.StatusParked, + action: taskstate.ActionRetry, + wantStatus: store.StatusQueued, + }, + { + name: "cancel queued task closes it", + initialStatus: store.StatusQueued, + action: taskstate.ActionCancel, + wantStatus: store.StatusClosedWontDo, + }, + { + name: "approve waiting_human task queues it", + initialStatus: store.StatusWaitingHuman, + action: taskstate.ActionApprove, + wantStatus: store.StatusQueued, + }, + { + name: "reject waiting_human task closes it", + initialStatus: store.StatusWaitingHuman, + action: taskstate.ActionReject, + wantStatus: store.StatusClosedWontDo, + }, + { + name: "archive dead task removes it from store", + initialStatus: store.StatusDead, + action: taskstate.ActionArchive, + wantArchived: true, + }, + { + name: "archive closed_wont_do task removes it from store", + initialStatus: store.StatusClosedWontDo, + action: taskstate.ActionArchive, + wantArchived: true, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + ctx := context.Background() + st, err := store.Open(ctx, filepath.Join(t.TempDir(), "tasks.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + + srv := &webui.Server{Store: st, Cfg: config.NewHolder(config.Config{MaxRetries: 3})} + adapter := chatTaskActorAdapter{ + tasks: st.TaskByID, + handler: srv.Handler(), + token: func() string { return srv.Token }, + } + + task, err := st.EnqueueChatTask(ctx, "acme", "widget", "actionable task", "", "", "archie") + if err != nil { + t.Fatal(err) + } + if tc.initialStatus != store.StatusQueued { + if err := st.Transition(ctx, task.ID, store.StatusQueued, tc.initialStatus, "setup"); err != nil { + t.Fatal(err) + } + } + + result, err := adapter.ApplyChatTaskAction(ctx, "archie", task.ID, tc.action) + if err != nil { + t.Fatalf("ApplyChatTaskAction(%s) error = %v", tc.action, err) + } + if result.TaskID != task.ID { + t.Errorf("result.TaskID = %d, want %d", result.TaskID, task.ID) + } + if result.Action != string(tc.action) { + t.Errorf("result.Action = %q, want %q", result.Action, tc.action) + } + + current, err := st.TaskByID(ctx, task.ID) + if err != nil { + t.Fatal(err) + } + if tc.wantArchived { + if current != nil { + t.Errorf("task %d still exists in store after archive: %+v", task.ID, current) + } + } else { + if current == nil { + t.Fatalf("task %d not found in store", task.ID) + } + if current.Status != tc.wantStatus { + t.Errorf("task status = %q, want %q", current.Status, tc.wantStatus) + } + } + }) + } +} + +func TestChatTaskActorAdapterWithTokenAuth(t *testing.T) { + ctx := context.Background() + st, err := store.Open(ctx, filepath.Join(t.TempDir(), "tasks.db")) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = st.Close() }) + + srv := &webui.Server{ + Store: st, + Cfg: config.NewHolder(config.Config{MaxRetries: 3}), + Token: "secret-token-12345", + } + adapter := chatTaskActorAdapter{ + tasks: st.TaskByID, + handler: srv.Handler(), + token: func() string { return srv.Token }, + } + + task, err := st.EnqueueChatTask(ctx, "acme", "widget", "auth task", "", "", "archie") + if err != nil { + t.Fatal(err) + } + if err := st.Transition(ctx, task.ID, store.StatusQueued, store.StatusParked, "park"); err != nil { + t.Fatal(err) + } + + result, err := adapter.ApplyChatTaskAction(ctx, "archie", task.ID, taskstate.ActionAbandon) + if err != nil { + t.Fatalf("ApplyChatTaskAction with token auth failed: %v", err) + } + if result.TaskID != task.ID { + t.Errorf("result.TaskID = %d, want %d", result.TaskID, task.ID) + } + + current, err := st.TaskByID(ctx, task.ID) + if err != nil || current == nil { + t.Fatalf("TaskByID = (%+v, %v)", current, err) + } + if current.Status != store.StatusClosedWontDo { + t.Errorf("status = %q, want %q", current.Status, store.StatusClosedWontDo) + } +} diff --git a/cmd/archied/telegram_setup.go b/cmd/archied/telegram_setup.go index 24c3fba5e..057acd4e1 100644 --- a/cmd/archied/telegram_setup.go +++ b/cmd/archied/telegram_setup.go @@ -46,6 +46,7 @@ type telegramSetup struct { ChatController gateway.TaskController ChatTaskLister gateway.ChatTaskLister ChatTaskLogs gateway.ChatTaskLogReader + ChatTaskActor gateway.ChatTaskActor DefaultChatIdentity string SessionStore gateway.SessionStore Updates telegram.UpdateService @@ -301,6 +302,7 @@ func newChatTurnRunner( TaskLister: s.ChatTaskLister, Tasks: s.ChatTasks, TaskLogs: s.ChatTaskLogs, + TaskActor: s.ChatTaskActor, TaskIdentity: s.DefaultChatIdentity, Bus: s.Bus, BotUser: cfg.BotUser, diff --git a/internal/gateway/task_action_tool_test.go b/internal/gateway/task_action_tool_test.go new file mode 100644 index 000000000..416986ddf --- /dev/null +++ b/internal/gateway/task_action_tool_test.go @@ -0,0 +1,265 @@ +package gateway + +import ( + "context" + "errors" + "fmt" + "strings" + "testing" + + "github.com/samcharles93/archie-core/internal/taskstate" + "github.com/samcharles93/archie-core/internal/tools" +) + +type fakeActor struct { + result TaskActionResult + err error + + gotIdentity string + gotTaskID int64 + gotAction taskstate.Action +} + +func (f *fakeActor) ApplyChatTaskAction(_ context.Context, identity string, taskID int64, action taskstate.Action) (TaskActionResult, error) { + f.gotIdentity = identity + f.gotTaskID = taskID + f.gotAction = action + return f.result, f.err +} + +func TestTaskActionToolProperties(t *testing.T) { + actor := &fakeActor{} + entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action") + + if err := entry.Validate(); err != nil { + t.Fatalf("entry.Validate() = %v", err) + } + if entry.Name != "task_action" { + t.Errorf("Name = %q, want task_action", entry.Name) + } + if entry.Toolset != "tasks" { + t.Errorf("Toolset = %q, want tasks", entry.Toolset) + } + wantClass := tools.ClassMutating | tools.RequiresApproval + if entry.Classification != wantClass { + t.Errorf("Classification = %v, want %v", entry.Classification, wantClass) + } + if entry.BuildApprovalDescription == nil { + t.Fatal("BuildApprovalDescription is nil, want a description builder for confirmation") + } +} + +func TestTaskActionOmittedWhenActorIsNil(t *testing.T) { + entries := TaskTools(&fakeLister{}, &fakeCreator{}, &fakeLogReader{}, nil, "archie") + for _, e := range entries { + if e.Name == "task_action" { + t.Fatal("task_action is present when actor is nil -- a tool that cannot run must not be advertised") + } + } +} + +func TestTaskActionAppearsWhenActorIsNonNil(t *testing.T) { + entries := TaskTools(nil, nil, nil, &fakeActor{}, "archie") + toolNamed(t, entries, "task_action") // fails if absent +} + +func TestTaskActionUsesBoundIdentity(t *testing.T) { + actor := &fakeActor{result: TaskActionResult{TaskID: 42, Action: "abandon", Message: "abandoned"}} + entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action") + + _, err := entry.Handler(context.Background(), map[string]any{ + "task_id": float64(42), + "action": "abandon", + "identity": "other-identity", + }) + if err != nil { + t.Fatal(err) + } + if actor.gotIdentity != "archie" { + t.Errorf("identity = %q, want bound %q", actor.gotIdentity, "archie") + } +} + +func TestTaskActionInputValidation(t *testing.T) { + tests := []struct { + name string + input map[string]any + actor *fakeActor + wantErr bool + wantTaskID int64 + wantAction taskstate.Action + }{ + { + name: "valid float64 task_id", + input: map[string]any{"task_id": float64(10), "action": "abandon"}, + actor: &fakeActor{result: TaskActionResult{TaskID: 10, Action: "abandon"}}, + wantTaskID: 10, + wantAction: taskstate.ActionAbandon, + }, + { + name: "valid int task_id", + input: map[string]any{"task_id": 11, "action": "archive"}, + actor: &fakeActor{result: TaskActionResult{TaskID: 11, Action: "archive"}}, + wantTaskID: 11, + wantAction: taskstate.ActionArchive, + }, + { + name: "valid int64 task_id", + input: map[string]any{"task_id": int64(12), "action": "retry"}, + actor: &fakeActor{result: TaskActionResult{TaskID: 12, Action: "retry"}}, + wantTaskID: 12, + wantAction: taskstate.ActionRetry, + }, + { + name: "normalizes action casing and whitespace", + input: map[string]any{"task_id": float64(13), "action": " ABANDON "}, + actor: &fakeActor{result: TaskActionResult{TaskID: 13, Action: "abandon"}}, + wantTaskID: 13, + wantAction: taskstate.ActionAbandon, + }, + { + name: "missing task_id", + input: map[string]any{"action": "abandon"}, + actor: &fakeActor{}, + wantErr: true, + }, + { + name: "invalid task_id type", + input: map[string]any{"task_id": "not-a-number", "action": "abandon"}, + actor: &fakeActor{}, + wantErr: true, + }, + { + name: "missing action", + input: map[string]any{"task_id": float64(10)}, + actor: &fakeActor{}, + wantErr: true, + }, + { + name: "blank action", + input: map[string]any{"task_id": float64(10), "action": " "}, + actor: &fakeActor{}, + wantErr: true, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + entry := toolNamed(t, TaskTools(nil, nil, nil, tc.actor, "archie"), "task_action") + out, err := entry.Handler(context.Background(), tc.input) + if tc.wantErr { + if err == nil { + t.Fatalf("Handler(%v) = nil error, want error", tc.input) + } + return + } + if err != nil { + t.Fatalf("Handler(%v) = %v, want nil error", tc.input, err) + } + if tc.actor.gotTaskID != tc.wantTaskID { + t.Errorf("task_id = %d, want %d", tc.actor.gotTaskID, tc.wantTaskID) + } + if tc.actor.gotAction != tc.wantAction { + t.Errorf("action = %q, want %q", tc.actor.gotAction, tc.wantAction) + } + res, ok := out.(TaskActionResult) + if !ok { + t.Fatalf("Handler output = %T, want TaskActionResult", out) + } + if res.TaskID != tc.wantTaskID { + t.Errorf("res.TaskID = %d, want %d", res.TaskID, tc.wantTaskID) + } + }) + } +} + +func TestTaskActionAllActions(t *testing.T) { + actions := []struct { + action taskstate.Action + input string + }{ + {action: taskstate.ActionAbandon, input: "abandon"}, + {action: taskstate.ActionArchive, input: "archive"}, + {action: taskstate.ActionRetry, input: "retry"}, + {action: taskstate.ActionStop, input: "stop"}, + {action: taskstate.ActionCancel, input: "cancel"}, + {action: taskstate.ActionApprove, input: "approve"}, + {action: taskstate.ActionReject, input: "reject"}, + } + + for _, tc := range actions { + t.Run(string(tc.action), func(t *testing.T) { + actor := &fakeActor{result: TaskActionResult{ + TaskID: 99, + Action: string(tc.action), + Message: fmt.Sprintf("Applied %s to task 99.", tc.action), + }} + entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action") + out, err := entry.Handler(context.Background(), map[string]any{ + "task_id": float64(99), + "action": tc.input, + }) + if err != nil { + t.Fatalf("Handler(%s) error = %v", tc.input, err) + } + res, ok := out.(TaskActionResult) + if !ok { + t.Fatalf("Handler output = %T, want TaskActionResult", out) + } + if res.Action != string(tc.action) { + t.Errorf("res.Action = %q, want %q", res.Action, tc.action) + } + }) + } +} + +func TestTaskActionPropagatesActorError(t *testing.T) { + actor := &fakeActor{err: errors.New("action not available while task is running")} + entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action") + + _, err := entry.Handler(context.Background(), map[string]any{ + "task_id": float64(42), + "action": "abandon", + }) + if err == nil { + t.Fatal("expected error, got nil") + } + if !strings.Contains(err.Error(), "action not available while task is running") { + t.Errorf("error = %v, want substring %q", err, "action not available while task is running") + } +} + +func TestTaskActionBuildApprovalDescription(t *testing.T) { + tests := []struct { + name string + input map[string]any + want string + }{ + { + name: "abandon parked task", + input: map[string]any{"task_id": float64(42), "action": "abandon"}, + want: "Apply action \"abandon\" to task 42.", + }, + { + name: "archive dead task", + input: map[string]any{"task_id": int64(101), "action": "archive"}, + want: "Apply action \"archive\" to task 101.", + }, + { + name: "missing fields fallback cleanly", + input: map[string]any{}, + want: "Apply action \"\" to task 0.", + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + actor := &fakeActor{} + entry := toolNamed(t, TaskTools(nil, nil, nil, actor, "archie"), "task_action") + got := entry.BuildApprovalDescription(tc.input) + if got != tc.want { + t.Errorf("BuildApprovalDescription(%v) = %q, want %q", tc.input, got, tc.want) + } + }) + } +} diff --git a/internal/gateway/task_tools.go b/internal/gateway/task_tools.go index 40144588f..8643c0cc6 100644 --- a/internal/gateway/task_tools.go +++ b/internal/gateway/task_tools.go @@ -6,6 +6,7 @@ import ( "strings" "time" + "github.com/samcharles93/archie-core/internal/taskstate" "github.com/samcharles93/archie-core/internal/tools" ) @@ -55,6 +56,22 @@ type TaskSpawnResult struct { Message string `json:"message"` } +// TaskActionResult is what task_action returns. +type TaskActionResult struct { + TaskID int64 `json:"task_id"` + Action string `json:"action"` + Message string `json:"message"` +} + +// ChatTaskActor is the mutation surface task_action needs. It mirrors the +// ChatTaskLister pattern: gateway states what it needs and the daemon +// supplies an adapter over the store and runtime, so this package keeps its +// independence from internal/store. +type ChatTaskActor interface { + // ApplyChatTaskAction executes action on taskID, scoped to identity's own tasks. + ApplyChatTaskAction(ctx context.Context, identity string, taskID int64, action taskstate.Action) (TaskActionResult, error) +} + // ChatTaskLogEntry is one log line as task_logs returns it. It mirrors // internal/logging.Entry's shape without importing that package: gateway // keeps its independence from internal/logging the same way it already does @@ -98,24 +115,17 @@ type ChatTaskLogReader interface { ReadChatTaskLogs(ctx context.Context, identity string, taskID int64, attempt int, q ChatTaskLogQuery) (ChatTaskLogResult, error) } -// TaskTools builds the chat tools that let Archie see and add to its own work +// TaskTools builds the chat tools that let Archie see, add to, and manage its own work // queue. Until these existed, /spawn and the task list were slash commands only // a human could type, so "what are you working on?" had no tool path at all. // -// Both tools are bound to identity at construction. The model never supplies -// it: a model that could name an identity could read or file work belonging to -// another instance on the same host. +// All tools are bound to identity at construction. The model never supplies +// it: a model that could name an identity could read, mutate or file work +// belonging to another instance on the same host. // // A nil backend omits its tool rather than registering one that always fails, // so a daemon without chat task support advertises nothing. -// -// Deliberately absent: task_approve and task_cancel. waiting_human is the one -// point in the task lifecycle where a person must act, and /approve is that -// gate. The text reaching a chat turn is untrusted -- a forge issue body or an -// inbound email can be quoted into it -- so a tool that approves Archie's own -// work would remove the only human checkpoint in the lifecycle. Cancel is -// destructive on the same untrusted path. Both remain slash commands. -func TaskTools(lister ChatTaskLister, creator TaskCreator, logs ChatTaskLogReader, identity string) []tools.ToolEntry { +func TaskTools(lister ChatTaskLister, creator TaskCreator, logs ChatTaskLogReader, actor ChatTaskActor, identity string) []tools.ToolEntry { var entries []tools.ToolEntry if lister != nil { entries = append(entries, taskListTool(lister, identity)) @@ -126,6 +136,9 @@ func TaskTools(lister ChatTaskLister, creator TaskCreator, logs ChatTaskLogReade if logs != nil { entries = append(entries, taskLogsTool(logs, identity)) } + if actor != nil { + entries = append(entries, taskActionTool(actor, identity)) + } return entries } @@ -228,6 +241,52 @@ func taskSpawnTool(creator TaskCreator, identity string) tools.ToolEntry { } } +func taskActionTool(actor ChatTaskActor, identity string) tools.ToolEntry { + return tools.ToolEntry{ + Name: "task_action", + Toolset: "tasks", + Description: "Perform an operator action on a task (e.g. abandon, archive, retry, stop, cancel, approve, reject). " + + "Use it when the user asks to close, abandon, archive, retry, stop or approve a task.", + Classification: tools.ClassMutating | tools.RequiresApproval, + BuildApprovalDescription: func(input map[string]any) string { + action := strings.TrimSpace(asString(input["action"])) + taskID, _ := asInt64(input["task_id"]) + return fmt.Sprintf("Apply action %q to task %d.", action, taskID) + }, + Schema: tools.JSONSchema{ + "type": "object", + "properties": map[string]any{ + "task_id": map[string]any{ + "type": "integer", + "description": "ID of the task to act on.", + }, + "action": map[string]any{ + "type": "string", + "description": "The action to perform: abandon, archive, retry, stop, cancel, approve, reject.", + }, + }, + "required": []any{"task_id", "action"}, + }, + Handler: func(ctx context.Context, input map[string]any) (any, error) { + taskID, ok := asInt64(input["task_id"]) + if !ok { + return nil, fmt.Errorf("task_action: task_id is required") + } + actionStr := strings.TrimSpace(strings.ToLower(asString(input["action"]))) + if actionStr == "" { + return nil, fmt.Errorf("task_action: action is required") + } + + // The bound identity, never input["identity"]. + result, err := actor.ApplyChatTaskAction(ctx, identity, taskID, taskstate.Action(actionStr)) + if err != nil { + return nil, fmt.Errorf("task_action: %w", err) + } + return result, nil + }, + } +} + func taskLogsTool(reader ChatTaskLogReader, identity string) tools.ToolEntry { return tools.ToolEntry{ Name: "task_logs", diff --git a/internal/gateway/task_tools_test.go b/internal/gateway/task_tools_test.go index 227d8cf12..12982759b 100644 --- a/internal/gateway/task_tools_test.go +++ b/internal/gateway/task_tools_test.go @@ -48,7 +48,7 @@ func toolNamed(t *testing.T, entries []tools.ToolEntry, name string) tools.ToolE } func TestTaskToolsValidate(t *testing.T) { - entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, "archie") + entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, nil, "archie") if len(entries) == 0 { t.Fatal("TaskTools() returned nothing") } @@ -76,7 +76,7 @@ func TestTaskToolsOmitNilBackends(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { - entries := TaskTools(tc.lister, tc.creator, nil, "archie") + entries := TaskTools(tc.lister, tc.creator, nil, nil, "archie") var got []string for _, e := range entries { got = append(got, e.Name) @@ -93,7 +93,7 @@ func TestTaskToolsOmitNilBackends(t *testing.T) { // that could name an identity could read another instance's work. func TestTaskListUsesBoundIdentity(t *testing.T) { lister := &fakeLister{tasks: []ChatTaskSummary{{ID: 7, Title: "wire the thing", Status: "running"}}} - entry := toolNamed(t, TaskTools(lister, nil, nil, "archie"), "task_list") + entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list") // The model supplies an identity; it must be ignored. if _, err := entry.Handler(context.Background(), map[string]any{"identity": "someone-else"}); err != nil { @@ -120,7 +120,7 @@ func TestTaskListLimit(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { lister := &fakeLister{} - entry := toolNamed(t, TaskTools(lister, nil, nil, "archie"), "task_list") + entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list") if _, err := entry.Handler(context.Background(), tc.input); err != nil { t.Fatal(err) } @@ -137,7 +137,7 @@ func TestTaskListFiltersByStatus(t *testing.T) { {ID: 2, Status: "queued"}, {ID: 3, Status: "running"}, }} - entry := toolNamed(t, TaskTools(lister, nil, nil, "archie"), "task_list") + entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list") out, err := entry.Handler(context.Background(), map[string]any{"status": "running"}) if err != nil { @@ -160,7 +160,7 @@ func TestTaskListFiltersByStatus(t *testing.T) { // TestTaskListEmptyIsNotAnError guards against the model reading an empty // queue as a broken tool and retrying. func TestTaskListEmptyIsNotAnError(t *testing.T) { - entry := toolNamed(t, TaskTools(&fakeLister{}, nil, nil, "archie"), "task_list") + entry := toolNamed(t, TaskTools(&fakeLister{}, nil, nil, nil, "archie"), "task_list") out, err := entry.Handler(context.Background(), map[string]any{}) if err != nil { @@ -177,7 +177,7 @@ func TestTaskListEmptyIsNotAnError(t *testing.T) { func TestTaskListPropagatesStoreError(t *testing.T) { lister := &fakeLister{err: errors.New("database is gone")} - entry := toolNamed(t, TaskTools(lister, nil, nil, "archie"), "task_list") + entry := toolNamed(t, TaskTools(lister, nil, nil, nil, "archie"), "task_list") if _, err := entry.Handler(context.Background(), map[string]any{}); err == nil { t.Fatal("handler error = nil, want the store failure surfaced") @@ -228,7 +228,7 @@ func TestTaskSpawn(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { - entry := toolNamed(t, TaskTools(nil, tc.creator, nil, "archie"), "task_spawn") + entry := toolNamed(t, TaskTools(nil, tc.creator, nil, nil, "archie"), "task_spawn") out, err := entry.Handler(context.Background(), tc.input) if tc.wantErr { if err == nil { @@ -264,7 +264,7 @@ func TestTaskSpawn(t *testing.T) { // model must not be able to file work under another instance's identity. func TestTaskSpawnIgnoresModelIdentity(t *testing.T) { creator := &fakeCreator{id: 1} - entry := toolNamed(t, TaskTools(nil, creator, nil, "archie"), "task_spawn") + entry := toolNamed(t, TaskTools(nil, creator, nil, nil, "archie"), "task_spawn") if _, err := entry.Handler(context.Background(), map[string]any{ "title": "sneaky", @@ -282,7 +282,7 @@ func TestTaskSpawnIgnoresModelIdentity(t *testing.T) { // an untrusted input path. If these are ever added they must be a considered // decision, not an accident. func TestTaskToolsExcludeApprovalTools(t *testing.T) { - entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, "archie") + entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, nil, "archie") for _, e := range entries { switch e.Name { case "task_approve", "task_cancel": @@ -313,7 +313,7 @@ func (f *fakeLogReader) ReadChatTaskLogs(_ context.Context, identity string, tas func TestTaskLogsUsesBoundIdentity(t *testing.T) { reader := &fakeLogReader{result: ChatTaskLogResult{Attempt: 1}} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), map[string]any{ "task_id": float64(7), "identity": "someone-else", @@ -327,7 +327,7 @@ func TestTaskLogsUsesBoundIdentity(t *testing.T) { func TestTaskLogsRequiresTaskID(t *testing.T) { reader := &fakeLogReader{} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), map[string]any{}); err == nil { t.Error("expected error for missing task_id, got nil") @@ -336,7 +336,7 @@ func TestTaskLogsRequiresTaskID(t *testing.T) { func TestTaskLogsDefaultsAttemptToZero(t *testing.T) { reader := &fakeLogReader{result: ChatTaskLogResult{Attempt: 0}} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), map[string]any{ "task_id": float64(7), @@ -350,7 +350,7 @@ func TestTaskLogsDefaultsAttemptToZero(t *testing.T) { func TestTaskLogsHonoursExplicitAttempt(t *testing.T) { reader := &fakeLogReader{result: ChatTaskLogResult{Attempt: 2}} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), map[string]any{ "task_id": float64(7), "attempt": float64(2), @@ -377,7 +377,7 @@ func TestTaskLogsLimit(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { reader := &fakeLogReader{result: ChatTaskLogResult{}} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), tc.input); err != nil { t.Fatal(err) } @@ -390,7 +390,7 @@ func TestTaskLogsLimit(t *testing.T) { func TestTaskLogsForwardsComponentAndContains(t *testing.T) { reader := &fakeLogReader{result: ChatTaskLogResult{}} - entry := toolNamed(t, TaskTools(nil, nil, reader, "archie"), "task_logs") + entry := toolNamed(t, TaskTools(nil, nil, reader, nil, "archie"), "task_logs") if _, err := entry.Handler(context.Background(), map[string]any{ "task_id": float64(7), "component": "gate", "q": "build failed", @@ -406,7 +406,7 @@ func TestTaskLogsForwardsComponentAndContains(t *testing.T) { } func TestTaskLogsOmittedWhenReaderIsNil(t *testing.T) { - entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, "archie") + entries := TaskTools(&fakeLister{}, &fakeCreator{}, nil, nil, "archie") for _, e := range entries { if e.Name == "task_logs" { t.Fatal("task_logs is in the tool set when reader is nil -- a tool that always fails must not be advertised") @@ -415,6 +415,6 @@ func TestTaskLogsOmittedWhenReaderIsNil(t *testing.T) { } func TestTaskLogsAppearsWhenReaderIsNonNil(t *testing.T) { - entries := TaskTools(nil, nil, &fakeLogReader{}, "archie") + entries := TaskTools(nil, nil, &fakeLogReader{}, nil, "archie") toolNamed(t, entries, "task_logs") // fails the test if absent } diff --git a/internal/gateway/turn.go b/internal/gateway/turn.go index 52c8593c4..379375ca2 100644 --- a/internal/gateway/turn.go +++ b/internal/gateway/turn.go @@ -75,6 +75,7 @@ type TurnRunnerConfig struct { TaskLister ChatTaskLister Tasks TaskCreator TaskLogs ChatTaskLogReader + TaskActor ChatTaskActor TaskIdentity string Bus TurnEventPublisher BotUser string @@ -247,7 +248,7 @@ func (r *TurnRunner) Run(ctx context.Context, msg Message, stream TurnStream) (s compressed := compressTurnHistory(history, r.BotUser) extraTools := append( - TaskTools(r.TaskLister, r.Tasks, r.TaskLogs, r.TaskIdentity), + TaskTools(r.TaskLister, r.Tasks, r.TaskLogs, r.TaskActor, r.TaskIdentity), SessionTools(r.Sessions, r.Router.SessionTracker(), r.Channel, msg)..., ) modelName := r.Models.ActiveModel()