From 8cb291ad7cdb317ff80947278ee055b1a4925b41 Mon Sep 17 00:00:00 2001 From: Claude Sonnet 5 Date: Sat, 4 Jul 2026 05:05:36 +0000 Subject: feat(story,role): add retro ceremony -- closes the self-improvement loop (Phase 8) The final mechanism the versioned role-config model (Phase 5) was built for: when a story reaches DONE, StoryOrchestrator spawns a retro-role task that reflects on the story's full history and proposes draft role_configs versions for a human to review and activate via the existing (unchanged) POST /api/roles/{role}/activate. - AgentChannel gains a 6th method, ProposeRoleConfig(ctx, role.RoleConfig) (version, err), following ProposeEpic's precedent (Phase 7c): a structured tool call, not summary-parsing. storeChannel.ProposeRoleConfig calls the same Store.CreateRoleConfig the human-facing POST /api/roles/{role}/versions endpoint already uses (proposed_by: "retro"), landing a new draft row without touching whatever's currently active. Wired through both transports exactly like ProposeEpic: internal/agentloop/tools.go (native loop) and internal/executor/agentmcp.go (MCP). - StoryOrchestrator.Tick now routes a story at status DONE to a new processRetro stage instead of processStory -- a sibling stage, not a continuation, since the Builder->Evaluators->Arbitration chain is long settled by then. processRetro only *reads* that settled pipeline (read-only findEvaluators/findArbitration counterparts to ensureEvaluators/ensureArbitration -- it never spawns/mutates Builder-pipeline tasks) to locate the Arbitration task the retro task depends on, then spawns (idempotently -- checks for an existing retro-role dependent first) one retro-role task with instructions assembled from the story's spec/acceptance-criteria, full task tree, per- task cost/escalation history, active role_configs per role encountered, and the story's own event stream (evaluator verdicts, arbitration decision). - event.KindRetroCaptured (attached to the story's ID, matching KindEvalVerdict/KindArbitrationDecided's convention) fires once the retro task completes (auto-accepted like every other pipeline task), aggregating every event.KindRoleConfigProposed the retro task recorded (one per propose_role_config call) into {task_id, proposals: [{role, version}], summary} -- the summary is the "capturing lessons" half of this ceremony, the proposals are the versioned-config half. - Human activation is completely untouched: drafts land through the identical CreateRoleConfig/config_json path Phase 5's endpoints already handle, confirmed via existing role-endpoint tests passing unmodified. go build/vet/test -race -count=1 all pass, full suite (20 packages) -- one run hit a known, pre-existing, intermittent flake under full-suite load (unrelated to this phase's files) that did not reproduce on two immediate reruns, both in isolation and full-suite. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01V1moSNCJRcP6kykA4tyUSs --- internal/executor/nativerunner_test.go | 59 ++++++++++++++++++++++++++++++++++ 1 file changed, 59 insertions(+) (limited to 'internal/executor/nativerunner_test.go') diff --git a/internal/executor/nativerunner_test.go b/internal/executor/nativerunner_test.go index afdb49d..89a7ab5 100644 --- a/internal/executor/nativerunner_test.go +++ b/internal/executor/nativerunner_test.go @@ -282,6 +282,65 @@ func TestNativeRunner_Run_ToolLoop_ProposeEpic(t *testing.T) { } } +// TestNativeRunner_Run_ToolLoop_ProposeRoleConfig is an end-to-end-ish test +// (fake LLM server, real agentloop.Loop/tools.go dispatch, real +// storeChannel) proving a propose_role_config tool call reaches +// AgentChannel.ProposeRoleConfig correctly through +// internal/agentloop/tools.go's dispatchTool, and from there through +// storeChannel.ProposeRoleConfig into a new draft role_configs row — +// mirroring the propose_epic coverage above (Phase 7c) for this phase's +// (Phase 8) new tool. +func TestNativeRunner_Run_ToolLoop_ProposeRoleConfig(t *testing.T) { + srv := fakeChatServer(t, []fakeTurn{ + {toolCalls: []llm.ToolCall{toolCall("c1", "propose_role_config", `{"role":"builder","system_prompt":"Be more careful.","escalation_ladder":[{"candidates":[{"provider":"anthropic","model":"claude-sonnet-4-6"}],"max_retries":1}]}`)}}, + {content: "finished"}, + }) + defer srv.Close() + + r := newLocalRunner(t, srv) + tt := localTask() + store := &fakeChannelStore{} + ch := newStoreChannel(store, tt.ID) + exec := &storage.Execution{ID: uuid.New().String(), TaskID: tt.ID} + + if err := r.Run(context.Background(), tt, exec, ch); err != nil { + t.Fatalf("Run: %v", err) + } + + rows := store.roleConfigs["builder"] + if len(rows) != 1 { + t.Fatalf("expected 1 created role_configs row, got %d", len(rows)) + } + row := rows[0] + if row.Status != "draft" { + t.Errorf("expected status draft, got %q", row.Status) + } + var decoded struct { + Role string `json:"role"` + SystemPrompt string `json:"system_prompt"` + EscalationLadder []struct { + Candidates []struct { + Provider string `json:"provider"` + Model string `json:"model"` + } `json:"candidates"` + MaxRetries int `json:"max_retries"` + } `json:"escalation_ladder"` + } + if err := json.Unmarshal([]byte(row.ConfigJSON), &decoded); err != nil { + t.Fatalf("unmarshal config_json: %v", err) + } + if decoded.Role != "builder" || decoded.SystemPrompt != "Be more careful." { + t.Errorf("config fields not propagated: %+v", decoded) + } + if len(decoded.EscalationLadder) != 1 || len(decoded.EscalationLadder[0].Candidates) != 1 || + decoded.EscalationLadder[0].Candidates[0].Provider != "anthropic" { + t.Errorf("escalation_ladder not propagated: %+v", decoded.EscalationLadder) + } + if len(store.createdEvents) != 1 || store.createdEvents[0].TaskID != tt.ID { + t.Errorf("expected 1 role_config_proposed event attached to the calling task, got %+v", store.createdEvents) + } +} + func TestNativeRunner_Run_RecordProgress(t *testing.T) { srv := fakeChatServer(t, []fakeTurn{ {toolCalls: []llm.ToolCall{toolCall("c1", "record_progress", `{"message":"halfway there"}`)}}, -- cgit v1.2.3