maestro-flow 0.4.6 → 0.4.8

package/.codex/skills/team-executor/roles/executor/role.md

@@ -1,173 +0,0 @@
-# Executor Role
-
-Orchestrate the team-executor workflow: session validation, state reconciliation, team_worker dispatch, progress monitoring, completion action. The sole built-in role -- all worker roles are loaded from session role-specs and spawned via team_worker agent.
-
-## Identity
-
-- **Name**: `executor` | **Tag**: `[executor]`
-- **Responsibility**: Validate session -> Reconcile state -> Create session -> Dispatch team_worker agents -> Monitor progress -> Completion action -> Report results
-
-## Boundaries
-
-### MUST
-- Validate session structure before any execution
-- Reconcile session state with tasks.json on startup
-- Reset in_progress tasks to pending (interrupted tasks)
-- Detect fast-advance orphans and reset to pending
-- Spawn team_worker agents via spawn_agent and wait via wait_agent
-- Monitor progress via wait_agent and route messages
-- Maintain session state persistence (tasks.json)
-- Handle capability_gap reports with warning only (cannot generate role-specs)
-- Execute completion action when pipeline finishes
-
-### MUST NOT
-- Execute task work directly (delegate to workers)
-- Modify task output artifacts (workers own their deliverables)
-- Call CLI tools or spawn utility members directly for implementation (code-developer, etc.)
-- Generate new role-specs (use existing session role-specs only)
-- Skip session validation
-- Override consensus_blocked HIGH without user confirmation
-- Spawn workers with `general-purpose` agent (MUST use `team_worker`)
-
-> **Core principle**: executor is the orchestrator, not the executor. All actual work is delegated to session-defined worker roles via team_worker agents. Unlike team-coordinate coordinator, executor CANNOT generate new role-specs.
-
----
-
-## Entry Router
-
-When executor is invoked, first detect the invocation type:
-
-| Detection | Condition | Handler |
-|-----------|-----------|---------|
-| Status check | Arguments contain "check" or "status" | -> handleCheck |
-| Manual resume | Arguments contain "resume" or "continue" | -> handleResume |
-| Capability gap | Message contains "capability_gap" | -> handleAdapt |
-| Pipeline complete | All tasks completed, no pending/in_progress | -> handleComplete |
-| New execution | None of above | -> Phase 0 |
-
-For check/resume/adapt/complete: load `commands/monitor.md` and execute the appropriate handler, then STOP.
-
----
-
-## Phase 0: Session Validation + State Reconciliation
-
-**Objective**: Validate session structure and reconcile session state with actual task status.
-
-### Step 1: Session Validation
-
-Validate session structure (see SKILL.md Session Validation):
-- [ ] Directory exists at session path
-- [ ] `tasks.json` exists and parses
-- [ ] `task-analysis.json` exists and parses
-- [ ] `role-specs/` directory has >= 1 .md files
-- [ ] All roles in tasks.json#roles have corresponding role-spec .md files
-- [ ] Role-spec files have valid YAML frontmatter + Phase 2-4 sections
-
-If validation fails -> ERROR with specific reason -> STOP
-
-### Step 2: Load Session State
-
-Read tasks.json and task-analysis.json.
-
-### Step 3: Reconcile with tasks.json
-
-Compare tasks.json task statuses with session expectations, bidirectional sync.
-
-### Step 4: Reset Interrupted Tasks
-
-Reset any in_progress tasks to pending.
-
-### Step 5: Detect Fast-Advance Orphans
-
-In_progress tasks without matching active_agents + created > 5 minutes -> reset to pending.
-
-### Step 6: Create Missing Tasks (if needed)
-
-For each task in task-analysis, check if exists in tasks.json, create if missing.
-
-### Step 7: Update Session File
-
-Write reconciled tasks.json.
-
-### Step 8: Session Setup
-
-Initialize session folder if needed.
-
-**Success**: Session validated, state reconciled, session ready -> Phase 1
-
----
-
-## Phase 1: Spawn-and-Wait
-
-**Objective**: Spawn first batch of ready workers as team_worker agents, wait for completion, then continue.
-
-**Workflow**:
-1. Load `commands/monitor.md`
-2. Find tasks with: status=pending, deps all resolved, owner assigned
-3. For each ready task -> spawn team_worker via spawn_agent, wait via wait_agent
-4. Process results, advance pipeline
-5. Repeat until all tasks complete or pipeline blocked
-6. Output status summary with execution graph
-
-**Pipeline advancement** driven by:
-- Synchronous wait_agent loop (automatic)
-- User "check" -> handleCheck (status only)
-- User "resume" -> handleResume (advance)
-
----
-
-## Phase 2: Report + Completion Action
-
-**Objective**: Completion report, interactive completion choice, and follow-up options.
-
-**Workflow**:
-1. Load session state -> count completed tasks, duration
-2. List all deliverables with output paths in `<session>/artifacts/`
-3. Include discussion summaries (if inline discuss was used)
-4. Summarize wisdom accumulated during execution
-5. Output report:
-
-```
-[executor] ============================================
-[executor] TASK COMPLETE
-[executor]
-[executor] Deliverables:
-[executor]   - <artifact-1.md> (<producer role>)
-[executor]   - <artifact-2.md> (<producer role>)
-[executor]
-[executor] Pipeline: <completed>/<total> tasks
-[executor] Roles: <role-list>
-[executor] Duration: <elapsed>
-[executor]
-[executor] Session: <session-folder>
-[executor] ============================================
-```
-
-6. **Execute Completion Action** (based on tasks.json completion_action):
-
-| Mode | Behavior |
-|------|----------|
-| `interactive` | request_user_input with Archive/Keep/Export options |
-| `auto_archive` | Execute Archive & Clean (rm -rf session folder) without prompt |
-| `auto_keep` | Execute Keep Active without prompt |
-
-**Interactive handler**: See SKILL.md Completion Action section.
-
----
-
-## Agent Lifecycle Management
-- **Close agents promptly**: Call `close_agent` immediately after collecting a worker's result — do NOT leave completed agents running. Idle agents waste resources. At pipeline end, verify all agents closed via `list_agents`.
-
-## Error Handling
-
-| Error | Resolution |
-|-------|------------|
-| Session validation fails | ERROR with specific reason, suggest re-run team-coordinate |
-| Task timeout | Log, mark failed, ask user to retry or skip |
-| Worker crash | Reset task to pending in tasks.json, respawn via spawn_agent |
-| Session corruption | Attempt recovery, fallback to manual reconciliation |
-| capability_gap reported | handleAdapt: WARN only, cannot generate new role-specs |
-| Pipeline stall (no ready, no running) | Check for missing tasks, report to user |
-| Fast-advance conflict | Executor reconciles, no duplicate spawns |
-| Role-spec file not found | ERROR, cannot proceed without role definition |
-| Completion action fails | Default to Keep Active, log warning |

package/.codex/skills/team-executor/specs/session-schema.md

@@ -1,230 +0,0 @@
-# Session Schema
-
-Required session structure for team-executor v2. All components MUST exist for valid execution. Updated for role-spec architecture (lightweight Phase 2-4 files instead of full role.md files).
-
-## Directory Structure
-
-```
-<session-folder>/
-+-- team-session.json           # Session state + dynamic role registry (REQUIRED)
-+-- task-analysis.json          # Task analysis output: capabilities, dependency graph (REQUIRED)
-+-- role-specs/                 # Dynamic role-spec definitions (REQUIRED, >= 1 .md file)
-|   +-- <role-1>.md             # Lightweight: YAML frontmatter + Phase 2-4 only
-|   +-- <role-2>.md
-+-- artifacts/                  # All MD deliverables from workers
-|   +-- <artifact>.md
-+-- .msg/                       # Team message bus + state
-|   +-- messages.jsonl          # Message log
-|   +-- meta.json               # Session metadata + cross-role state
-+-- wisdom/                     # Cross-task knowledge
-|   +-- learnings.md
-|   +-- decisions.md
-|   +-- issues.md
-+-- explorations/               # Shared explore cache
-|   +-- cache-index.json
-|   +-- explore-<angle>.json
-+-- discussions/                # Inline discuss records
-|   +-- <round>.md
-```
-
-## Validation Checklist
-
-team-executor validates the following before execution:
-
-### Required Components
-
-| Component | Validation | Error Message |
-|-----------|------------|---------------|
-| `--session` argument | Must be provided | "Session required. Usage: --session=<path-to-TC-folder>" |
-| Directory | Must exist at path | "Session directory not found: <path>" |
-| `team-session.json` | Must exist, parse as JSON, and contain all required fields | "Invalid session: team-session.json missing, corrupt, or missing required fields" |
-| `task-analysis.json` | Must exist, parse as JSON, and contain all required fields | "Invalid session: task-analysis.json missing, corrupt, or missing required fields" |
-| `role-specs/` directory | Must exist and contain >= 1 .md file | "Invalid session: no role-spec files in role-specs/" |
-| Role-spec file mapping | Each role in team-session.json#roles must have .md file | "Role-spec file not found: role-specs/<role>.md" |
-| Role-spec structure | Each role-spec must have YAML frontmatter + Phase 2-4 sections | "Invalid role-spec: role-specs/<role>.md missing required section" |
-
-### Validation Order
-
-Validate in sequence; halt on first error:
-
-| Step | Target | Required Fields / Checks | Error on Failure |
-|------|--------|--------------------------|------------------|
-| 1 | `--session=<path>` argument | Must be provided | "Session required. Usage: --session=<path-to-TC-folder>" |
-| 2 | Directory at path | Must exist | "Session directory not found: <path>" |
-| 3 | `team-session.json` | Exists, valid JSON, contains: `session_id` (string), `task_description` (string), `status` (active\|paused\|completed), `team_name` (string), `roles` (non-empty array) | "Invalid session: team-session.json missing, corrupt, or missing required fields" |
-| 4 | `task-analysis.json` | Exists, valid JSON, contains: `capabilities` (array), `dependency_graph` (object), `roles` (non-empty array) | "Invalid session: task-analysis.json missing, corrupt, or missing required fields" |
-| 5 | `role-specs/` directory | Exists, contains >= 1 `.md` file | "Invalid session: no role-spec files in role-specs/" |
-| 6 | Role-spec mapping | Each role in `team-session.json#roles` has matching `role-specs/<role.name>.md`; each file passes Role-Spec Structure Validation | "Role-spec file not found: role-specs/<role.name>.md" |
-
-All checks pass -> proceed to Phase 0.
-
----
-
-## team-session.json Schema
-
-```json
-{
-  "session_id": "TC-<slug>-<date>",
-  "task_description": "<original user input>",
-  "status": "active | paused | completed",
-  "team_name": "<team-name>",
-  "roles": [
-    {
-      "name": "<role-name>",
-      "prefix": "<PREFIX>",
-      "responsibility_type": "<type>",
-      "inner_loop": false,
-      "role_spec": "role-specs/<role-name>.md"
-    }
-  ],
-  "pipeline": {
-    "dependency_graph": {},
-    "tasks_total": 0,
-    "tasks_completed": 0
-  },
-  "active_workers": [],
-  "completed_tasks": [],
-  "completion_action": "interactive",
-  "created_at": "<timestamp>"
-}
-```
-
-### Required Fields
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `session_id` | string | Unique session identifier |
-| `task_description` | string | Original task description from user |
-| `status` | string | One of: "active", "paused", "completed" |
-| `team_name` | string | Team name for Agent tool |
-| `roles` | array | List of role definitions |
-| `roles[].name` | string | Role name (must match .md filename) |
-| `roles[].prefix` | string | Task prefix for this role |
-| `roles[].role_spec` | string | Relative path to role-spec file |
-
-### Optional Fields
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `pipeline` | object | Pipeline metadata |
-| `active_workers` | array | Currently running workers |
-| `completed_tasks` | array | List of completed task IDs |
-| `completion_action` | string | Completion mode: interactive, auto_archive, auto_keep |
-| `created_at` | string | ISO timestamp |
-
----
-
-## task-analysis.json Schema
-
-```json
-{
-  "capabilities": [
-    {
-      "name": "<capability-name>",
-      "description": "<description>",
-      "artifact_type": "<type>"
-    }
-  ],
-  "dependency_graph": {
-    "<task-id>": {
-      "depends_on": ["<dependency-task-id>"],
-      "role": "<role-name>"
-    }
-  },
-  "roles": [
-    {
-      "name": "<role-name>",
-      "prefix": "<PREFIX>",
-      "responsibility_type": "<type>",
-      "inner_loop": false,
-      "role_spec_metadata": {
-        "additional_members": [],
-        "message_types": {
-          "success": "<prefix>_complete",
-          "error": "error"
-        }
-      }
-    }
-  ],
-  "complexity_score": 0
-}
-```
-
----
-
-## Role-Spec File Schema
-
-Each role-spec in `role-specs/<role-name>.md` follows the lightweight format with YAML frontmatter + Phase 2-4 body.
-
-### Required Structure
-
-```markdown
----
-role: <name>
-prefix: <PREFIX>
-inner_loop: <true|false>
-message_types:
-  success: <type>
-  error: error
----
-
-# <Role Name> — Phase 2-4
-
-## Phase 2: <Name>
-<domain-specific context loading>
-
-## Phase 3: <Name>
-<domain-specific execution>
-
-## Phase 4: <Name>
-<domain-specific validation>
-```
-
-### Role-Spec Structure Validation
-
-Each `role-specs/<role>.md` must satisfy:
-
-| Check | Required | Error on Failure |
-|-------|----------|------------------|
-| YAML frontmatter (between `---` markers) | Present | "Invalid role-spec: missing frontmatter" |
-| Frontmatter fields | `role` (string), `prefix` (string), `inner_loop` (boolean), `message_types` (object) | "Invalid role-spec: missing required field" |
-| Body sections | `## Phase 2`, `## Phase 3`, `## Phase 4` headings present | "Invalid role-spec: missing Phase N" |
-
-All checks pass -> role-spec valid.
-
----
-
-## Example Valid Session
-
-```
-.workflow/.team/TC-auth-feature-2026-02-27/
-+-- team-session.json           # Valid JSON with session metadata
-+-- task-analysis.json          # Valid JSON with dependency graph
-+-- role-specs/
-|   +-- researcher.md           # YAML frontmatter + Phase 2-4
-|   +-- developer.md            # YAML frontmatter + Phase 2-4
-|   +-- tester.md               # YAML frontmatter + Phase 2-4
-+-- artifacts/                  # (may be empty)
-+-- .msg/                       # Team message bus + state (messages.jsonl + meta.json)
-+-- wisdom/
-|   +-- learnings.md
-|   +-- decisions.md
-|   +-- issues.md
-+-- explorations/
-|   +-- cache-index.json
-+-- discussions/                # (may be empty)
-```
-
----
-
-## Recovery from Invalid Sessions
-
-If session validation fails:
-
-1. **Missing team-session.json**: Re-run team-coordinate with original task
-2. **Missing task-analysis.json**: Re-run team-coordinate with resume
-3. **Missing role-spec files**: Re-run team-coordinate with resume
-4. **Invalid frontmatter**: Manual fix or re-run team-coordinate
-5. **Corrupt JSON**: Manual inspection or re-run team-coordinate
-
-**team-executor cannot fix invalid sessions** -- it can only report errors and suggest recovery steps.

package/.codex/skills/team-lifecycle-v4/roles/coordinator/commands/analyze.md

@@ -1,56 +0,0 @@
-# Analyze Task
-
-Parse user task -> detect capabilities -> build dependency graph -> design roles.
-
-**CONSTRAINT**: Text-level analysis only. NO source code reading, NO codebase exploration.
-
-## Signal Detection
-
-| Keywords | Capability | Prefix |
-|----------|------------|--------|
-| investigate, explore, research | analyst | RESEARCH |
-| write, draft, document | writer | DRAFT |
-| implement, build, code, fix | executor | IMPL |
-| design, architect, plan | planner | PLAN |
-| test, verify, validate | tester | TEST |
-| analyze, review, audit | reviewer | REVIEW |
-
-## Dependency Graph
-
-Natural ordering tiers:
-- Tier 0: analyst, planner (knowledge gathering)
-- Tier 1: writer (creation requires context)
-- Tier 2: executor (implementation requires plan/design)
-- Tier 3: tester, reviewer (validation requires artifacts)
-
-## Complexity Scoring
-
-| Factor | Points |
-|--------|--------|
-| Per capability | +1 |
-| Cross-domain | +2 |
-| Parallel tracks | +1 per track |
-| Serial depth > 3 | +1 |
-
-Results: 1-3 Low, 4-6 Medium, 7+ High
-
-## Role Minimization
-
-- Cap at 5 roles
-- Merge overlapping capabilities
-- Absorb trivial single-step roles
-
-## Output
-
-Write <session>/task-analysis.json:
-```json
-{
-  "task_description": "<original>",
-  "pipeline_type": "<spec-only|impl-only|full-lifecycle|...>",
-  "capabilities": [{ "name": "<cap>", "prefix": "<PREFIX>", "keywords": ["..."] }],
-  "dependency_graph": { "<TASK-ID>": { "role": "<role>", "blockedBy": ["..."], "priority": "P0|P1|P2" } },
-  "roles": [{ "name": "<role>", "prefix": "<PREFIX>", "inner_loop": false }],
-  "complexity": { "score": 0, "level": "Low|Medium|High" },
-  "needs_research": true
-}
-```

package/.codex/skills/team-lifecycle-v4/roles/coordinator/commands/dispatch.md

@@ -1,61 +0,0 @@
-# Dispatch Tasks
-
-Create task chains from dependency graph, write to tasks.json with proper deps relationships.
-
-## Workflow
-
-1. Read task-analysis.json -> extract dependency_graph
-2. Read specs/pipelines.md -> get task registry for selected pipeline
-3. Topological sort tasks (respect deps)
-4. Validate all owners exist in role registry (SKILL.md)
-5. For each task (in order):
-   - Add task entry to tasks.json `tasks` object (see template below)
-   - Set deps array with upstream task IDs
-   - Assign wave number based on dependency depth
-6. Update tasks.json metadata: total count, wave assignments
-7. Validate chain (no orphans, no cycles, all refs valid)
-
-## Task Entry Template
-
-Each task in tasks.json `tasks` object:
-```json
-{
-  "<TASK-ID>": {
-    "title": "<concise title>",
-    "description": "PURPOSE: <goal> | Success: <criteria>\nTASK:\n  - <step 1>\n  - <step 2>\nCONTEXT:\n  - Session: <session-folder>\n  - Upstream artifacts: <list>\n  - Key files: <list>\nEXPECTED: <artifact path> + <quality criteria>\nCONSTRAINTS: <scope limits>\n---\nInnerLoop: <true|false>\nRoleSpec: <project>/.codex/skills/team-lifecycle-v4/roles/<role>/role.md",
-    "role": "<role-name>",
-    "pipeline_phase": "<phase>",
-    "deps": ["<upstream-task-id>", "..."],
-    "context_from": ["<upstream-task-id>", "..."],
-    "wave": 1,
-    "status": "pending",
-    "findings": null,
-    "quality_score": null,
-    "supervision_verdict": null,
-    "error": null
-  }
-}
-```
-
-## InnerLoop Flag Rules
-
-- true: Role has 2+ serial same-prefix tasks (writer: DRAFT-001->004)
-- false: Role has 1 task, or tasks are parallel
-
-## CHECKPOINT Task Rules
-
-CHECKPOINT tasks are dispatched like regular tasks but handled differently at spawn time:
-
-- Added to tasks.json with proper deps (upstream tasks that must complete first)
-- Owner: supervisor
-- **NOT spawned as team_worker** — coordinator wakes the resident supervisor via followup_task
-- If `supervision: false` in tasks.json, skip creating CHECKPOINT tasks entirely
-- RoleSpec in description: `<project>/.codex/skills/team-lifecycle-v4/roles/supervisor/role.md`
-
-## Dependency Validation
-
-- No orphan tasks (all tasks have valid owner)
-- No circular dependencies
-- All deps references exist in tasks object
-- Session reference in every task description
-- RoleSpec reference in every task description

package/.codex/skills/team-lifecycle-v4/roles/coordinator/commands/monitor.md

@@ -1,113 +0,0 @@
-# Monitor Pipeline
-
-Synchronous pipeline coordination using spawn_agent + wait_agent.
-
-## Constants
-
-- WORKER_AGENT: team_worker
-- SUPERVISOR_AGENT: team_supervisor (resident, woken via followup_task)
-
-## Handler Router
-
-| Source | Handler |
-|--------|---------|
-| "capability_gap" | handleAdapt |
-| "check" or "status" | handleCheck |
-| "resume" or "continue" | handleResume |
-| All tasks completed | handleComplete |
-| Default | handleSpawnNext |
-
-## handleCheck
-
-Read-only status report from tasks.json + team_msg progress, then STOP.
-
-Read tasks.json + team_msg (type="progress", last=50) + team_msg (type="blocker", last=10). Aggregate latest milestone per task.
-
-**Output format**:
-```
-[coordinator] Pipeline Status — Progress: <done>/<total> (<pct>%)
-[coordinator] Active Workers: <task_id> <role> <milestone_phase> <pct>% "<summary>" <time_ago>
-[coordinator] Blockers: <count or "none"> (detail per blocker if any)
-[coordinator] Completed: <list>
-[coordinator] Ready: <pending with resolved deps>
-[coordinator] Commands: 'resume' to advance | 'check' to refresh
-```
-
-**CLI monitoring**: `maestro agent-msg list -s "<session_id>" --type progress --last 10`
-
-## handleResume
-
-**Agent Health Check** (v4): Cross-check `list_agents()` against `active_agents`. Missing agents -> reset task to pending. Crashed supervisor (resident + no CHECKPOINT in_progress + pending CHECKPOINT exists) -> respawn with recovery: true.
-
-```
-Load active_agents -> route:
-  none -> handleSpawnNext
-  has agents -> health check, process completions -> handleSpawnNext
-```
-
-## handleSpawnNext
-
-Find ready tasks, spawn workers, wait for completion, process results.
-
-1. Read tasks.json
-2. Collect: completedTasks, inProgressTasks, readyTasks (pending + all deps completed)
-3. No ready + nothing in progress -> handleComplete
-4. No ready + work in progress -> report waiting, STOP
-5. Has ready -> separate regular tasks and CHECKPOINT tasks
-
-### Spawn Regular Tasks
-
-For each ready non-CHECKPOINT task:
-
-**Spawn worker message template**:
-```
-## Role Assignment
-role: <role> | role_spec: <skillRoot>/roles/<role>/role.md
-session: <session-folder> | session_id: <session-id>
-requirement: <requirement> | inner_loop: <true|false>
-Read role_spec for Phase 2-4 instructions. Execute Phase 1 -> role Phase 2-4 -> Phase 5 (report).
-## Task Context
-task_id: <id> | title: <title> | description: <description> | pipeline_phase: <phase>
-## Upstream Context
-<prevContext>
-## Progress Milestones
-Report progress via team_msg at phase boundaries. Blockers via type="blocker". Completion via type="task_complete" after report_agent_job_result.
-```
-
-**Result collection**: `wait_agent({ timeout_ms: 1800000 })` (30 min), drain progress + blockers from team_msg, log execution trace.
-
-**Timeout escalation**: STATUS_CHECK (3 min) -> FINALIZE with interrupt (3 min) -> mark timed_out with last progress context, close_agent. Normal completion -> read `discoveries/{task_id}.json` for status/findings/quality_score/error. Missing file -> status="failed". Close each agent (use task_name, not agentId).
-
-**Cross-Agent Supplementary Context** (v4): Use `send_message` (not `followup_task`) to deliver upstream results to running downstream workers as non-interrupting supplementary context.
-
-### Handle CHECKPOINT Tasks
-
-For each ready CHECKPOINT task:
-
-1. Ensure supervisor in active_agents (resident: true). Not found -> spawn via SKILL.md Supervisor Spawn Template.
-2. Wake supervisor via `followup_task` with checkpoint scope (dep task IDs) + pipeline progress.
-3. `wait_agent` (30 min) with standard timeout escalation (STATUS_CHECK -> FINALIZE -> timed_out).
-4. Read `artifacts/${task.id}-report.md`, parse verdict:
-   - **pass** -> mark completed, proceed
-   - **warn** -> log risks to wisdom, mark completed, proceed
-   - **block** -> request_user_input: Override / Revise upstream / Abort
-
-### Persist and Loop
-
-Write tasks.json -> more tasks ready? -> loop handleSpawnNext. All done -> handleComplete. Blocked -> report, STOP.
-
-## handleComplete
-
-**Cleanup Verification** (v4): `list_agents()` -> close any still-running team agents (including resident supervisor).
-
-Pipeline done. Generate summary (deliverables, stats, discussions). Route by completion_action: interactive (Archive/Keep/Export) | auto_archive | auto_keep.
-
-## handleAdapt
-
-Capability gap reported mid-pipeline.
-
-1. Parse gap description
-2. Check if existing role covers it -> redirect
-3. Role count < 5 -> generate dynamic role-spec in <session>/role-specs/
-4. Add new task to tasks.json, spawn worker via spawn_agent + wait_agent
-5. Role count >= 5 -> merge or pause