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/channel.go | 49 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 49 insertions(+) (limited to 'internal/executor/channel.go') diff --git a/internal/executor/channel.go b/internal/executor/channel.go index ef64ede..5afe22e 100644 --- a/internal/executor/channel.go +++ b/internal/executor/channel.go @@ -10,6 +10,8 @@ import ( "github.com/thepeterstone/claudomator/internal/agentchannel" "github.com/thepeterstone/claudomator/internal/event" + "github.com/thepeterstone/claudomator/internal/role" + "github.com/thepeterstone/claudomator/internal/storage" "github.com/thepeterstone/claudomator/internal/story" "github.com/thepeterstone/claudomator/internal/task" "github.com/google/uuid" @@ -50,6 +52,12 @@ type channelStore interface { GetEpicByName(name string) (*story.Epic, error) GetStory(id string) (*story.Story, error) UpdateStory(st *story.Story) error + // CreateRoleConfig backs storeChannel.ProposeRoleConfig (Phase 8): it + // inserts a new "draft"-status role_configs row for a role, auto- + // assigning the next version number, exactly the way + // api.handleCreateRoleVersion (the human-facing + // POST /api/roles/{role}/versions endpoint) already uses it. + CreateRoleConfig(roleName, configJSON, proposedBy string) (*storage.RoleConfigRow, error) } // pendingAsker is implemented by channels that buffer an ask_user call so the @@ -223,4 +231,45 @@ func (c *storeChannel) ProposeEpic(_ context.Context, spec agentchannel.EpicProp return epic.ID, err } return epic.ID, nil +} + +// ProposeRoleConfig creates a new draft role_configs row for config.Role, +// proposed_by "retro" (the only role this phase wires the tool up for, +// though nothing else about the mechanism is retro-specific). It never reads +// or touches whatever version is currently active for that role — draft +// creation and activation are deliberately separate paths (see +// storage.CreateRoleConfig / storage.ActivateRoleConfigVersion), the latter +// staying a human action via POST /api/roles/{role}/activate. +// +// Records event.KindRoleConfigProposed on the *calling task's own ID* +// (c.taskID, not a role or story ID — roles have no first-class row/ID of +// their own the way epics/stories do), payload {role, version}. This mirrors +// ProposeEpic's "one event per proposal call" convention but attaches to the +// task rather than the proposed entity: internal/scheduler.StoryOrchestrator +// reads a retro task's own event stream for these once the task completes, +// to assemble the aggregate KindRetroCaptured payload it attaches to the +// story's ID (see that package's finalizeRetro). +func (c *storeChannel) ProposeRoleConfig(_ context.Context, config role.RoleConfig) (int, error) { + configJSON, err := json.Marshal(config) + if err != nil { + return 0, err + } + row, err := c.store.CreateRoleConfig(config.Role, string(configJSON), "retro") + if err != nil { + return 0, err + } + + payload, _ := json.Marshal(struct { + Role string `json:"role"` + Version int `json:"version"` + }{Role: row.Role, Version: row.Version}) + if err := c.store.CreateEvent(&event.Event{ + TaskID: c.taskID, + Kind: event.KindRoleConfigProposed, + Actor: event.ActorAgent, + Payload: payload, + }); err != nil { + return row.Version, err + } + return row.Version, nil } \ No newline at end of file -- cgit v1.2.3