From 787b7fb1aed92c2b701724a7741576053b93cccb Mon Sep 17 00:00:00 2001 From: Claude Sonnet 5 Date: Fri, 3 Jul 2026 23:01:50 +0000 Subject: feat(role): add versioned role configs + escalation ladder + scheduler (Phase 5) Two parts: Part A (fixes a gap from Phase 1): Groq/OpenRouter/OpenAI were documented in docs/api-keys-setup.md as usable once configured, but nothing actually constructed runners for them. internal/cli/cloudrunners.go consolidates anthropic/google/groq/openrouter/openai NativeRunner construction into one table-driven registerCloudRunners() helper, replacing the two hand-written per-provider blocks in serve.go/run.go. Groq/OpenRouter/OpenAI reuse openaicompat (no new adapter code) at SandboxKind: "docker". Part B: the token-husbanding harness's core routing mechanism. - internal/role: RoleConfig/Tier/Rung -- a role's system prompt and a multi-tier (provider, model) escalation ladder, versioned via config_json. - storage: new role_configs table (draft/active/retired, UNIQUE(role, version)) with transactional activate-retires-prior-active semantics; new executions.escalation_rung column. - task.AgentConfig.Role string -- purely additive; every existing task shape (Agent.Role == "") is unaffected, proven by TestPool_Execute_NonRoleTask_Unaffected plus the full pre-existing suite passing unchanged. - executor.Pool.execute(): role-typed tasks with no Agent.Type yet resolve tier 0 of their active ladder (round-robin across multi-candidate tiers, skipping rate-limited providers, falling back to soonest-clearing) before the existing pickAgent/Classifier path runs; SystemPrompt applies to Agent.SystemPromptAppend. Already-resolved role tasks (scheduler resubmits) get their escalation_rung re-derived read-only via findTierIndex. - internal/scheduler: polls role-typed FAILED tasks, retries at the same rung under MaxRetries or escalates to the next tier's first candidate when budget.Accountant.Allow() permits (emitting event.KindEscalated), else leaves the task FAILED with a final:true KindEscalated event. An in-memory per-execution-ID "handled" set keeps the poll loop convergent. Started by `serve` only, config knob [scheduler].poll_interval_seconds. - internal/api: POST/GET /api/roles/{role}/versions, POST /api/roles/{role}/activate -- unauthenticated, matching the existing projects/tasks REST endpoints' auth posture (only chatbot MCP, agent MCP, and WebSocket are api_token-gated in this codebase today). Documented as stored-but-not-yet-enforced (CLAUDE.md Design Debt, matching how task.Priority/RetryConfig are already documented): RoleConfig.Tools/ SandboxKind don't affect dispatch yet; DefaultBudgetUSD is read narrowly as the scheduler's escalation cost estimate, not enforced at initial dispatch; scheduler escalation always targets Candidates[0] (no round-robin, unlike initial-dispatch tier-0 resolution); the scheduler's dedupe is per-process and resets on restart (idempotent, harmless). go build/vet/test -race -count=1 all pass, 21 packages. Co-Authored-By: Claude Sonnet 5 Claude-Session: https://claude.ai/code/session_01V1moSNCJRcP6kykA4tyUSs --- internal/storage/roleconfig_test.go | 151 ++++++++++++++++++++++++++++++++++++ 1 file changed, 151 insertions(+) create mode 100644 internal/storage/roleconfig_test.go (limited to 'internal/storage/roleconfig_test.go') diff --git a/internal/storage/roleconfig_test.go b/internal/storage/roleconfig_test.go new file mode 100644 index 0000000..b18eaef --- /dev/null +++ b/internal/storage/roleconfig_test.go @@ -0,0 +1,151 @@ +package storage + +import ( + "database/sql" + "errors" + "testing" +) + +func TestCreateRoleConfig_AssignsIncrementingVersions(t *testing.T) { + db := testDB(t) + + v1, err := db.CreateRoleConfig("coder", `{"role":"coder"}`, "human") + if err != nil { + t.Fatalf("CreateRoleConfig v1: %v", err) + } + if v1.Version != 1 { + t.Errorf("expected version 1, got %d", v1.Version) + } + if v1.Status != "draft" { + t.Errorf("expected status draft, got %q", v1.Status) + } + + v2, err := db.CreateRoleConfig("coder", `{"role":"coder","system_prompt":"v2"}`, "human") + if err != nil { + t.Fatalf("CreateRoleConfig v2: %v", err) + } + if v2.Version != 2 { + t.Errorf("expected version 2, got %d", v2.Version) + } + + // A different role starts its own version sequence at 1. + other, err := db.CreateRoleConfig("reviewer", `{"role":"reviewer"}`, "human") + if err != nil { + t.Fatalf("CreateRoleConfig other role: %v", err) + } + if other.Version != 1 { + t.Errorf("expected version 1 for a new role, got %d", other.Version) + } +} + +func TestGetActiveRoleConfig_NoneActive_ReturnsErrNoRows(t *testing.T) { + db := testDB(t) + if _, err := db.CreateRoleConfig("coder", `{"role":"coder"}`, "human"); err != nil { + t.Fatalf("CreateRoleConfig: %v", err) + } + _, err := db.GetActiveRoleConfig("coder") + if !errors.Is(err, sql.ErrNoRows) { + t.Fatalf("expected sql.ErrNoRows, got %v", err) + } +} + +func TestListRoleConfigVersions_OrderedByVersion(t *testing.T) { + db := testDB(t) + for i := 0; i < 3; i++ { + if _, err := db.CreateRoleConfig("coder", `{"role":"coder"}`, "human"); err != nil { + t.Fatalf("CreateRoleConfig: %v", err) + } + } + versions, err := db.ListRoleConfigVersions("coder") + if err != nil { + t.Fatalf("ListRoleConfigVersions: %v", err) + } + if len(versions) != 3 { + t.Fatalf("expected 3 versions, got %d", len(versions)) + } + for i, v := range versions { + if v.Version != i+1 { + t.Errorf("versions[%d].Version = %d, want %d", i, v.Version, i+1) + } + } +} + +// TestActivateRoleConfigVersion_ExactlyOneActive is the invariant test called +// out in the phase spec: activating version 2 while version 1 is active must +// atomically flip version 1 to retired. +func TestActivateRoleConfigVersion_ExactlyOneActive(t *testing.T) { + db := testDB(t) + + v1, err := db.CreateRoleConfig("coder", `{"role":"coder","system_prompt":"v1"}`, "human") + if err != nil { + t.Fatalf("CreateRoleConfig v1: %v", err) + } + v2, err := db.CreateRoleConfig("coder", `{"role":"coder","system_prompt":"v2"}`, "human") + if err != nil { + t.Fatalf("CreateRoleConfig v2: %v", err) + } + + if err := db.ActivateRoleConfigVersion("coder", v1.Version); err != nil { + t.Fatalf("activate v1: %v", err) + } + active, err := db.GetActiveRoleConfig("coder") + if err != nil { + t.Fatalf("GetActiveRoleConfig: %v", err) + } + if active.Version != v1.Version { + t.Fatalf("expected active version %d, got %d", v1.Version, active.Version) + } + if active.ActivatedAt == nil { + t.Errorf("expected ActivatedAt to be set") + } + + // Now activate v2 — v1 must atomically flip to retired, and v2 becomes + // the sole active row. + if err := db.ActivateRoleConfigVersion("coder", v2.Version); err != nil { + t.Fatalf("activate v2: %v", err) + } + + active, err = db.GetActiveRoleConfig("coder") + if err != nil { + t.Fatalf("GetActiveRoleConfig after v2 activation: %v", err) + } + if active.Version != v2.Version { + t.Fatalf("expected active version %d, got %d", v2.Version, active.Version) + } + + all, err := db.ListRoleConfigVersions("coder") + if err != nil { + t.Fatalf("ListRoleConfigVersions: %v", err) + } + activeCount := 0 + for _, row := range all { + if row.Status == "active" { + activeCount++ + } + if row.Version == v1.Version { + if row.Status != "retired" { + t.Errorf("expected v1 to be retired, got %q", row.Status) + } + if row.RetiredAt == nil { + t.Errorf("expected v1 RetiredAt to be set") + } + } + } + if activeCount != 1 { + t.Fatalf("expected exactly 1 active row, got %d", activeCount) + } +} + +func TestActivateRoleConfigVersion_UnknownVersion_Errors(t *testing.T) { + db := testDB(t) + if _, err := db.CreateRoleConfig("coder", `{"role":"coder"}`, "human"); err != nil { + t.Fatalf("CreateRoleConfig: %v", err) + } + if err := db.ActivateRoleConfigVersion("coder", 99); err == nil { + t.Fatalf("expected error activating unknown version") + } + // No row should have been left active. + if _, err := db.GetActiveRoleConfig("coder"); !errors.Is(err, sql.ErrNoRows) { + t.Fatalf("expected sql.ErrNoRows, got %v", err) + } +} -- cgit v1.2.3