feat(executor): add DAG auto-cascade-fail + role-typed subtask spawning (Phase 6)

Two prerequisites for safe parallel evaluator fan-out (later phase):

1. Auto-cascade-fail: previously, a failed task's dependents just sat
   PENDING/QUEUED forever (or until something eventually tried to dispatch
   them and discovered the dependency was dead). Pool.cascadeFail now fires
   right after a task lands in a terminal failure state (FAILED/TIMED_OUT/
   CANCELLED/BUDGET_EXCEEDED, from handleRunResult, the budget-gate reject
   path, and the checkDepsReady dependency-failure path), recursively
   cancelling every not-yet-run dependent (PENDING/QUEUED only -- RUNNING and
   terminal states are left alone) with a message referencing the upstream
   failure. A visited-set guards recursion, which turned out to be
   load-bearing rather than defense-in-depth: task creation does not prevent
   dependency cycles anywhere in this codebase.

   Correction to an earlier assumption: internal/executor's
   waitForDependencies is dead code, never called. The live mechanism is
   checkDepsReady, invoked synchronously in execute() with a self-requeue via
   time.AfterFunc. Added a freshness re-check (GetTask, bail if no longer
   QUEUED) at the top of that block so a task cascade-cancelled while sitting
   in the requeue loop stops silently instead of hitting an invalid
   CANCELLED->CANCELLED transition or, worse, still getting dispatched.

2. storeChannel.SpawnSubtask hardcoded Agent.Type: "claude" on every spawned
   child regardless of what role it should play -- a hard blocker for a
   Planner/Builder task spawning role-typed evaluator subtasks. SubtaskSpec
   (internal/agentchannel) gains a Role field; when set, the child task gets
   Agent.Role instead of a hardcoded Type, so Phase 5's role-resolution picks
   provider/model from that role's escalation ladder. spec.Role == "" (every
   existing caller) preserves today's exact behavior byte-for-byte -- proven
   by an explicit regression test, not just new-feature coverage. Threaded
   the new `role` parameter through both spawn_subtask transports: the native
   tool-use loop (internal/agentloop/tools.go) and the MCP tool exposed to
   ContainerRunner-driven claude/gemini agents (internal/executor/agentmcp.go).

go build/vet/test -race -count=1 all pass, full suite (20 packages).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01V1moSNCJRcP6kykA4tyUSs

1 files changed, 20 insertions, 10 deletions

diff --git a/internal/executor/channel.go b/internal/executor/channel.go
index debe21d..30d826c 100644
--- a/internal/executor/channel.go
+++ b/internal/executor/channel.go
@@ -112,20 +112,30 @@ func (c *storeChannel) PendingQuestion() (string, bool) {
 
 func (c *storeChannel) SpawnSubtask(_ context.Context, spec SubtaskSpec) (string, error) {
 	now := time.Now().UTC()
+	agent := task.AgentConfig{
+		Instructions: spec.Instructions,
+		MaxBudgetUSD: spec.MaxBudgetUSD,
+	}
+	if spec.Role != "" {
+		// Role-typed subtask: leave Type/Model empty so
+		// executor.Pool.execute() resolves tier 0 of the role's escalation
+		// ladder on dispatch, exactly like any other role-typed task.
+		agent.Role = spec.Role
+	} else {
+		// Backward-compatible default: every pre-Phase-6 caller of
+		// SpawnSubtask gets exactly this unchanged behavior.
+		agent.Type = "claude"
+		agent.Model = spec.Model
+	}
 	child := &task.Task{
 		ID:           uuid.NewString(),
 		Name:         spec.Name,
 		ParentTaskID: c.taskID,
-		Agent: task.AgentConfig{
-			Type:         "claude",
-			Model:        spec.Model,
-			Instructions: spec.Instructions,
-			MaxBudgetUSD: spec.MaxBudgetUSD,
-		},
-		Priority:  task.PriorityNormal,
-		State:     task.StatePending,
-		CreatedAt: now,
-		UpdatedAt: now,
+		Agent:        agent,
+		Priority:     task.PriorityNormal,
+		State:        task.StatePending,
+		CreatedAt:    now,
+		UpdatedAt:    now,
 	}
 	if err := c.store.CreateTask(child); err != nil {
 		return "", err