From 04b6e7eef473cb6eb69e345a4ea08243a8713077 Mon Sep 17 00:00:00 2001 From: Claude Sonnet 5 Date: Sat, 4 Jul 2026 04:39:28 +0000 Subject: feat(story,scheduler): add epic-proposal tool + AskUser-timeout escalation (Phase 7c) Two independent pieces, completing Phase 7. Epic-proposal tool: AgentChannel gains a 5th method, ProposeEpic(ctx, EpicProposal{Name, Description, StoryIDs}) (epicID, err), implemented on storeChannel -- matches an existing epic by exact name or creates one (DiscoverySource: "agent"), sets epic_id on each resolvable story (skips, doesn't fail, on an unresolved ID), emits KindEpicProposed attached to the epic's own ID with payload {epic_id, name, story_ids}. Wired into both transports exactly like Phase 6 wired role into spawn_subtask: a new propose_epic tool in the native tool-use loop (internal/agentloop/tools.go) and the MCP transport (internal/executor/agentmcp.go). This is the mechanism for a discovery/planner-role agent to act on its own judgment that several stories it's been given form one cohesive initiative -- the judgment itself lives in the calling agent's instructions/model, not in this code. AskUser-timeout escalation: extends the existing Scheduler (Phase 5's retry-then-escalate watcher) rather than adding a new component, since "stuck task needs escalation" is exactly what it already does. Finds role-typed BLOCKED tasks whose question has been outstanding longer than SchedulerConfig.AskUserTimeoutSeconds (default 10 minutes) using task.UpdatedAt as the outstanding-since timestamp -- no new column needed, since UpdateTaskQuestion already stamps it the instant a question is recorded and nothing else touches the row while BLOCKED. Resolves the next ladder tier from the latest execution's EscalationRung, records the system-authored fallback answer as an audit-trail task.Interaction, clears the question, sets the new tasks.needs_review flag, emits KindEscalated (now carrying a trigger field: "failure" vs "ask_user_timeout" for the existing failure-retry path vs this one), and resumes via Pool.SubmitResume at the escalated tier -- degrading to same-tier resume with final:true if the ladder's exhausted or no role config exists, since unblocking the task takes priority over having somewhere higher to escalate to. GET /api/tasks?needs_review=true surfaces auto-decided tasks for human review. go build/vet/test -race -count=1 all pass, full suite (20 packages), run twice to rule out flakiness in the new tests. (One pre-existing, unrelated test -- TestHandleRunTask_CascadesRetryToFailedDeps, a tempdir-cleanup race -- appeared once under full-suite load per the implementing agent's report and did not reproduce in this verification's runs either; not a regression from this work.) Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01V1moSNCJRcP6kykA4tyUSs --- internal/executor/agentmcp_test.go | 41 +++++++++++++++++++++++++++++++++----- 1 file changed, 36 insertions(+), 5 deletions(-) (limited to 'internal/executor/agentmcp_test.go') diff --git a/internal/executor/agentmcp_test.go b/internal/executor/agentmcp_test.go index 4aeb7cb..c73d6db 100644 --- a/internal/executor/agentmcp_test.go +++ b/internal/executor/agentmcp_test.go @@ -12,11 +12,13 @@ import ( // recordingChannel is a fake AgentChannel that records tool invocations. type recordingChannel struct { - asked string - summary string - spawned []SubtaskSpec - progress []string - spawnID string + asked string + summary string + spawned []SubtaskSpec + progress []string + spawnID string + proposedEpics []EpicProposal + epicID string } func (c *recordingChannel) AskUser(_ context.Context, q string) (string, error) { @@ -35,6 +37,10 @@ func (c *recordingChannel) RecordProgress(_ context.Context, m string) error { c.progress = append(c.progress, m) return nil } +func (c *recordingChannel) ProposeEpic(_ context.Context, spec EpicProposal) (string, error) { + c.proposedEpics = append(c.proposedEpics, spec) + return c.epicID, nil +} func resultText(t *testing.T, res *mcp.CallToolResult) string { t.Helper() @@ -178,6 +184,31 @@ func TestAgentServer_RecordProgress(t *testing.T) { } } +func TestAgentServer_ProposeEpic(t *testing.T) { + ch := &recordingChannel{epicID: "epic-1"} + cs := connectInMemory(t, newAgentServer(ch)) + res, err := cs.CallTool(context.Background(), &mcp.CallToolParams{ + Name: "propose_epic", + Arguments: map[string]any{"name": "Checkout revamp", "description": "relaunch", "story_ids": []string{"s1", "s2"}}, + }) + if err != nil { + t.Fatalf("CallTool: %v", err) + } + if len(ch.proposedEpics) != 1 { + t.Fatalf("expected 1 proposed epic, got %d", len(ch.proposedEpics)) + } + spec := ch.proposedEpics[0] + if spec.Name != "Checkout revamp" || spec.Description != "relaunch" { + t.Errorf("epic spec not propagated: %+v", spec) + } + if len(spec.StoryIDs) != 2 || spec.StoryIDs[0] != "s1" || spec.StoryIDs[1] != "s2" { + t.Errorf("story_ids not propagated: %+v", spec.StoryIDs) + } + if txt := resultText(t, res); !strings.Contains(txt, "epic-1") { + t.Errorf("expected returned epic ID in result, got %q", txt) + } +} + type bearerRT struct { token string base http.RoundTripper -- cgit v1.2.3