maestro-flow 0.2.1 → 0.3.0

package/.claude/agents/team-supervisor.md

@@ -48,18 +48,28 @@ Triggered when coordinator sends a checkpoint request message:
 
 1. **Parse request**: Extract `task_id` and `scope` from coordinator message
 2. **Claim task**: `TaskUpdate({ taskId: "<task_id>", status: "in_progress" })`
-3. **Incremental context load**: Only load data new since last wake:
+3. **Read worker progress** (optional): Check progress milestones for risk assessment:
+   ```javascript
+   const progressMsgs = mcp__maestro__team_msg({
+     operation: "list", session_id: "<session_id>", type: "progress", last: 50
+   })
+   const blockerMsgs = mcp__maestro__team_msg({
+     operation: "list", session_id: "<session_id>", type: "blocker", last: 10
+   })
+   // Use progress data to assess worker health and identify stalled tasks
+   ```
+4. **Incremental context load**: Only load data new since last wake:
    - Role states: `team_msg(operation="get_state")` for newly completed roles
    - Message bus: `team_msg(operation="list", session_id, last=30)` for recent messages
    - Artifacts: Read files in scope not already in context_accumulator
    - Wisdom: Read `<session>/wisdom/*.md` for new entries
-4. **Execute checks**: Follow checkpoint-specific instructions from role_spec body
-5. **Write report**: Output to `<session>/artifacts/CHECKPOINT-NNN-report.md`
-6. **Complete task**: `TaskUpdate({ taskId: "<task_id>", status: "completed" })`
-7. **Publish state**: Log `state_update` via `team_msg` with verdict, score, findings
-8. **Accumulate context**: Append checkpoint results to `context_accumulator`
-9. **Report to coordinator**: SendMessage with verdict summary, findings, quality trend
-10. **Go idle**: Wait for next checkpoint request or shutdown
+5. **Execute checks**: Follow checkpoint-specific instructions from role_spec body
+6. **Write report**: Output to `<session>/artifacts/CHECKPOINT-NNN-report.md`
+7. **Complete task**: `TaskUpdate({ taskId: "<task_id>", status: "completed" })`
+8. **Publish state**: Log `state_update` via `team_msg` with verdict, score, findings
+9. **Accumulate context**: Append checkpoint results to `context_accumulator`
+10. **Report to coordinator**: SendMessage with verdict summary, findings, quality trend
+11. **Go idle**: Wait for next checkpoint request or shutdown
 
 ### 4. Crash Recovery
 

package/.claude/agents/team-worker.md

@@ -80,6 +80,10 @@ Follow the instructions loaded from the role_spec body. This contains the domain
 - Use CLI tools (`maestro cli`) or direct tools (Read, Grep, Glob) for analysis — see @~/.maestro/templates/search-tools.md for tool selection
 - If agent delegation is needed, send a request to the coordinator via SendMessage
 
+### Context-Aware Signal Emission (Optional)
+
+During Phase 2-4 execution, if you detect codebase signals relevant to specialist injection (SQL usage, auth modules, ML imports, performance-sensitive code, etc.), include `tech_profile` in your Phase 5 state_update data. This enables the coordinator to evaluate specialist injection for the pipeline.
+
 ### 6. Publish Results
 
 After execution, publish contributions:
@@ -88,20 +92,98 @@ After execution, publish contributions:
 2. Prepare state data for the reporting phase
 3. Append discoveries to wisdom files (`learnings.md`, `decisions.md`, `issues.md`)
 
+### Progress Milestone Protocol
+
+Report progress via `mcp__maestro__team_msg` at natural phase boundaries. This enables coordinator status dashboards and timeout forensics.
+
+**Milestone Reporting** — at each phase boundary:
+
+```javascript
+mcp__maestro__team_msg({
+  operation: "log",
+  session_id: "<session_id>",
+  from: "<task_id>",
+  to: "coordinator",
+  type: "progress",
+  summary: "[<task_id>] <brief phase description> (<pct>%)",
+  data: {
+    task_id: "<task_id>",
+    role: "<role>",
+    status: "in_progress",
+    progress_pct: <0-100>,
+    phase: "<what just completed>",
+    key_info: "<most important finding or decision>"
+  }
+})
+```
+
+**Role-Specific Milestones**:
+
+| Role | ~30% | ~60% | ~90% |
+|------|------|------|------|
+| analyst/researcher | Context loaded | Core analysis done | Verification complete |
+| writer/drafter | Sources gathered | Draft written | Self-review done |
+| planner | Requirements parsed | Plan structured | Dependencies validated |
+| executor/implementer | Context loaded | Core changes done | Tests passing |
+| reviewer/tester | Scope mapped | Reviews/tests done | Report compiled |
+
+**Blocker Reporting** — immediately on errors (don't wait for next milestone):
+
+```javascript
+mcp__maestro__team_msg({
+  operation: "log",
+  session_id: "<session_id>",
+  from: "<task_id>",
+  to: "coordinator",
+  type: "blocker",
+  summary: "[<task_id>] BLOCKED: <brief description>",
+  data: {
+    task_id: "<task_id>",
+    role: "<role>",
+    blocker_detail: "<what is blocking>",
+    severity: "high|medium",
+    attempted: "<what was tried>"
+  }
+})
+```
+
+**Completion Report** — after final report SendMessage:
+
+```javascript
+mcp__maestro__team_msg({
+  operation: "log",
+  session_id: "<session_id>",
+  from: "<task_id>",
+  to: "coordinator",
+  type: "task_complete",
+  summary: "[<task_id>] Complete: <one-line result>",
+  data: {
+    task_id: "<task_id>",
+    role: "<role>",
+    status: "completed",
+    progress_pct: 100,
+    artifact: "<artifact_path>",
+    files_modified: []
+  }
+})
+```
+
+**Overhead Rule**: Max 3-4 milestone messages per task. Each summary < 200 chars. Only report at natural phase boundaries, not every minor step.
+
 ### 7. Report and Advance
 
 Determine report variant based on loop state:
 
 **Loop continuation** (inner_loop=true AND more same-prefix tasks pending):
 1. `TaskUpdate` -- mark current task `completed`
-2. Log `state_update` via `team_msg` with task results
+2. Log `state_update` via `team_msg` with task results and optional `tech_profile` (if codebase signals detected in Phase 2-4)
 3. Accumulate summary to in-memory `context_accumulator`
 4. Interrupt check: consensus_blocked HIGH or errors >= 3 -- SendMessage and STOP
 5. Return to step 3 (Task Discovery)
 
 **Final report** (no more same-prefix tasks OR inner_loop=false):
 1. `TaskUpdate` -- mark current task `completed`
-2. Log `state_update` via `team_msg`
+2. Log `state_update` via `team_msg` (include `tech_profile` if codebase signals detected)
 3. Compile and send final report via SendMessage to coordinator:
    - Tasks completed (count + list)
    - Artifacts produced (paths)

package/.claude/commands/manage-harvest.md

@@ -0,0 +1,131 @@
+---
+name: manage-harvest
+description: Extract knowledge from workflow artifacts and route to wiki / spec / issue stores
+argument-hint: "[<session-id|path>] [--to wiki|spec|issue|auto] [--source <type>] [--recent N] [--dry-run] [-y]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Glob
+  - Grep
+  - Agent
+  - AskUserQuestion
+---
+<purpose>
+Extract knowledge fragments from workflow artifacts (analysis results, brainstorm outputs, debug sessions, lite-plan/fix results, scratchpad notes, completed sessions) and route them into the project's three knowledge stores: wiki entries, spec conventions, and trackable issues.
+
+Complements `quality-retrospective` (which is phase-scoped) by harvesting from **any** workflow artifact. Prevents knowledge loss from completed analysis and planning sessions that would otherwise only exist as stale files.
+
+**Closed-loop**: harvest extracts → wiki/spec/issue stores → downstream commands consume (wiki-digest, spec-load, manage-issue-plan).
+</purpose>
+
+<required_reading>
+@workflows/harvest.md
+</required_reading>
+
+<deferred_reading>
+- @workflows/issue.md (issues.jsonl schema for issue routing — read when creating issues in Stage 6c)
+- @workflows/specs-add.md (spec entry format — read when routing to spec in Stage 6b)
+</deferred_reading>
+
+<context>
+Arguments: $ARGUMENTS
+
+**Modes (auto-detected):**
+- No arguments → `scan` mode: discover all harvestable artifacts, interactive selection
+- `<session-id>` (e.g., `ANL-auth-20260410`, `WFS-xxx`) → `session` mode: harvest specific session
+- `<path>` (e.g., `.workflow/.analysis/ANL-auth-20260410/`) → `path` mode: harvest from explicit directory
+
+**Flags:**
+- `--to <target>` — Force routing: `wiki`, `spec`, `issue`, `auto` (default: `auto`)
+- `--source <type>` — Filter source type: `analysis`, `brainstorm`, `debug`, `lite-plan`, `lite-fix`, `scratchpad`, `session`, `learning`, `all` (default: `all`)
+- `--recent N` — Only artifacts updated within last N days (default: 30)
+- `--dry-run` — Preview extraction and routing without writing
+- `-y` / `--yes` — Skip confirmation prompts
+- `--min-confidence N` — Minimum extraction confidence 0.0-1.0 (default: 0.5)
+
+**Source registry (scan paths):**
+| Source Type | Scan Path | Key Files |
+|-------------|-----------|-----------|
+| `analysis` | `.workflow/.analysis/ANL-*/` | `conclusions.json`, `*.md` |
+| `brainstorm` | `.workflow/scratch/brainstorm-*/` | `guidance-specification.md` |
+| `lite-plan` | `.workflow/.lite-plan/*/` | `plan.json`, `plan-overview.md` |
+| `lite-fix` | `.workflow/.lite-fix/*/` | `fix-plan.json` |
+| `debug` | `.workflow/.debug/*/` | `debug-log.md`, `hypothesis-*.md` |
+| `scratchpad` | `.workflow/.scratchpad/` | `*.md`, `*.json` |
+| `session` | `.workflow/active/WFS-*/` | `workflow-session.json` |
+| `learning` | `.workflow/learning/` | `lessons.jsonl`, `digest-*.md` |
+
+**Storage written:**
+- `.workflow/harvest/harvest-log.jsonl` — provenance log (prevents duplicate harvesting)
+- `.workflow/harvest/harvest-report-{date}.md` — per-run report
+- Wiki entries via `maestro wiki create`
+- Spec entries via `Skill({ skill: "spec-add" })`
+- Issue entries appended to `.workflow/issues/issues.jsonl`
+
+**Storage read (never modified):**
+- All artifact source files (read-only until routing stage)
+- `.workflow/harvest/harvest-log.jsonl` (dedup check)
+</context>
+
+<execution>
+Follow 'workflows/harvest.md' Stages 1–8 in order. Key invariants:
+
+1. **Read-only until Stage 6** — Stages 1–5 must not write anything. All extraction and classification happens in-memory.
+2. **Dedup before write** — Stage 7 (dedup_check) runs BEFORE each write in Stage 6. Check harvest-log.jsonl, wiki search, issues.jsonl, and learnings.md for existing matches.
+3. **Stable fragment IDs** — `HRV-{8 hex}` from `hash(source_id + content_hash)` so re-runs on same artifacts do not create duplicates.
+4. **Reuse existing routing infrastructure**:
+   - Wiki: `maestro wiki create --type <type> --slug harvest-<source_type>-<short_id>`
+   - Spec: `Skill({ skill: "spec-add", args: "<type> <content>" })`
+   - Issue: append to `issues.jsonl` matching canonical schema from `workflows/issue.md`
+5. **Never modify source artifacts** — harvest is purely extractive. Source files remain untouched.
+6. **Confidence filtering** — fragments below `--min-confidence` are logged but not routed.
+7. **Provenance tracking** — every routed item logged to `harvest-log.jsonl` with fragment_id, source reference, and target reference.
+
+**Fragment extraction uses source-specific parsing** (see harvest.md Stage 3b for per-source patterns). The agent should read each artifact file and identify discrete knowledge items: findings, decisions, patterns, bugs, risks, tasks, lessons, recommendations.
+
+**Classification uses category-to-target mapping** (see harvest.md Stage 4). Override with `--to` flag if user wants all items in one store.
+
+**Next-step routing on completion:**
+- Review wiki entries → `maestro wiki list --type note`
+- Connect wiki graph → `Skill({ skill: "wiki-connect", args: "--fix" })`
+- Triage issues → `Skill({ skill: "manage-issue", args: "list --source harvest" })`
+- View specs → `Skill({ skill: "spec-load", args: "--category general" })`
+- Full retrospective → `Skill({ skill: "quality-retrospective" })`
+</execution>
+
+<error_codes>
+| Code | Severity | Condition | Recovery |
+|------|----------|-----------|----------|
+| E001 | error | `.workflow/` not initialized | Run `Skill({ skill: "maestro-init" })` first |
+| E002 | error | Invalid `--to` target (must be: wiki, spec, issue, auto) | Display valid options |
+| E003 | error | Invalid `--source` type | Display valid source types from registry |
+| E004 | error | Session ID not found in any source path | Show available sessions with `--source all` |
+| E005 | error | Path does not exist or contains no parseable artifacts | Verify path and file structure |
+| W001 | warning | No harvestable artifacts found within `--recent` window | Widen time window or check `.workflow/` contents |
+| W002 | warning | `maestro wiki create` failed — wiki entries saved to `.workflow/harvest/wiki-pending-*.md` | Apply pending entries manually or retry |
+| W003 | warning | Some fragments below confidence threshold — logged but not routed | Lower `--min-confidence` to include |
+| W004 | warning | Duplicate fragments skipped | Review harvest-log.jsonl for prior routing |
+| W005 | warning | `.workflow/issues/` directory missing | Auto-create directory and empty issues.jsonl |
+</error_codes>
+
+<success_criteria>
+- [ ] Mode correctly resolved (scan / session / path)
+- [ ] Source artifacts discovered and listed with metadata
+- [ ] User selected artifact(s) to harvest (or auto-selected via session/path mode)
+- [ ] All files in selected artifacts loaded and parsed
+- [ ] Knowledge fragments extracted with category, confidence, tags
+- [ ] Fragments filtered by `--min-confidence`
+- [ ] Routing classification applied (auto or forced by `--to`)
+- [ ] Dedup check passed against harvest-log.jsonl and existing stores
+- [ ] If `--dry-run`: preview displayed, no files written
+- [ ] If not dry-run: all routed items written to target stores
+- [ ] Wiki entries created via `maestro wiki create` (or fallback to pending files)
+- [ ] Spec entries added via `spec-add` mechanism
+- [ ] Issue entries appended to `issues.jsonl` with canonical schema
+- [ ] `harvest-log.jsonl` updated with provenance for each routed item
+- [ ] `harvest-report-{date}.md` written with full summary
+- [ ] No source artifacts modified
+- [ ] Summary displayed with counts and next-step routing
+</success_criteria>

package/.claude/skills/team-coordinate/SKILL.md

@@ -0,0 +1,266 @@
+---
+name: team-coordinate
+description: Universal team coordination skill with dynamic role generation. Uses team-worker agent architecture with role-spec files. Only coordinator is built-in -- all worker roles are generated at runtime as role-specs and spawned via team-worker agent. Beat/cadence model for orchestration. Triggers on "Team Coordinate ".
+allowed-tools: TeamCreate(*), TeamDelete(*), SendMessage(*), TaskCreate(*), TaskUpdate(*), TaskList(*), TaskGet(*), Agent(*), AskUserQuestion(*), Read(*), Write(*), Edit(*), Bash(*), Glob(*), Grep(*), mcp__ccw-tools__team_msg(*)
+---
+
+# Team Coordinate 
+
+Universal team coordination skill: analyze task -> generate role-specs -> dispatch -> execute -> deliver. Only the **coordinator** is built-in. All worker roles are **dynamically generated** as lightweight role-spec files and spawned via the `team-worker` agent.
+
+
+## Architecture
+
+```
++---------------------------------------------------+
+|  Skill(skill="team-coordinate")                 |
+|  args="task description"                           |
++-------------------+-------------------------------+
+                    |
+         Orchestration Mode (auto -> coordinator)
+                    |
+              Coordinator (built-in)
+              Phase 0-5 orchestration
+                    |
+    +-------+-------+-------+-------+
+    v       v       v       v       v
+ [team-worker agents, each loaded with a dynamic role-spec]
+  (roles generated at runtime from task analysis)
+
+  CLI Tools (callable by any worker):
+    maestro cli --mode analysis  - analysis and exploration
+    maestro cli --mode write     - code generation and modification
+```
+
+## Shared Constants
+
+| Constant | Value |
+|----------|-------|
+| Session prefix | `TC` |
+| Session path | `.workflow/.team/TC-<slug>-<date>/` |
+| Worker agent | `team-worker` |
+| Message bus | `mcp__ccw-tools__team_msg(session_id=<session-id>, ...)` |
+| CLI analysis | `maestro cli --mode analysis` |
+| CLI write | `maestro cli --mode write` |
+| Max roles | 5 |
+
+## Role Router
+
+This skill is **coordinator-only**. Workers do NOT invoke this skill -- they are spawned as `team-worker` agents directly.
+
+### Input Parsing
+
+Parse `$ARGUMENTS`. No `--role` needed -- always routes to coordinator.
+
+### Role Registry
+
+Only coordinator is statically registered. All other roles are dynamic, stored as role-specs in session.
+
+| Role | File | Type |
+|------|------|------|
+| coordinator | [roles/coordinator/role.md](roles/coordinator/role.md) | built-in orchestrator |
+| (dynamic) | `<session>/role-specs/<role-name>.md` | runtime-generated role-spec |
+
+### CLI Tool Usage
+
+Workers can use CLI tools for analysis and code operations:
+
+| Tool | Purpose |
+|------|---------|
+| maestro cli --mode analysis | Analysis, exploration, pattern discovery |
+| maestro cli --mode write | Code generation, modification, refactoring |
+
+### Dispatch
+
+Always route to coordinator. Coordinator reads `roles/coordinator/role.md` and executes its phases.
+
+### Orchestration Mode
+
+User just provides task description.
+
+**Invocation**: `Skill(skill="team-coordinate", args="task description")`
+
+**Lifecycle**:
+```
+User provides task description
+  -> coordinator Phase 1: task analysis (detect capabilities, build dependency graph)
+  -> coordinator Phase 2: generate role-specs + initialize session
+  -> coordinator Phase 3: create task chain from dependency graph
+  -> coordinator Phase 4: spawn first batch workers (background) -> STOP
+  -> Worker executes -> SendMessage callback -> coordinator advances next step
+  -> Loop until pipeline complete -> Phase 5 report + completion action
+```
+
+**User Commands** (wake paused coordinator):
+
+| Command | Action |
+|---------|--------|
+| `check` / `status` | Output execution status graph, no advancement |
+| `resume` / `continue` | Check worker states, advance next step |
+| `revise <TASK-ID> [feedback]` | Revise specific task with optional feedback |
+| `feedback <text>` | Inject feedback into active pipeline |
+| `improve [dimension]` | Auto-improve weakest quality dimension |
+
+---
+
+## Coordinator Spawn Template
+
+### v2 Worker Spawn (all roles)
+
+When coordinator spawns workers, use `team-worker` agent with role-spec path:
+
+```
+Agent({
+  subagent_type: "team-worker",
+  description: "Spawn <role> worker",
+  team_name: <team-name>,
+  name: "<role>",
+  run_in_background: true,
+  prompt: `## Role Assignment
+role: <role>
+role_spec: <session-folder>/role-specs/<role>.md
+session: <session-folder>
+session_id: <session-id>
+team_name: <team-name>
+requirement: <task-description>
+inner_loop: <true|false>
+
+## Progress Milestones
+session_id: <session-id>
+Report progress via team_msg at natural phase boundaries (context loaded -> core work done -> verification).
+Report blockers immediately via team_msg type="blocker".
+Report completion via team_msg type="task_complete" after final SendMessage.
+
+Read role_spec file to load Phase 2-4 domain instructions.
+Execute built-in Phase 1 (task discovery) -> role-spec Phase 2-4 -> built-in Phase 5 (report).`
+})
+```
+
+**Inner Loop roles** (role has 2+ serial same-prefix tasks): Set `inner_loop: true`. The team-worker agent handles the loop internally.
+
+**Single-task roles**: Set `inner_loop: false`.
+
+---
+
+## Completion Action
+
+When pipeline completes (all tasks done), coordinator presents an interactive choice:
+
+```
+AskUserQuestion({
+  questions: [{
+    question: "Team pipeline complete. What would you like to do?",
+    header: "Completion",
+    multiSelect: false,
+    options: [
+      { label: "Archive & Clean (Recommended)", description: "Archive session, clean up team" },
+      { label: "Keep Active", description: "Keep session for follow-up work" },
+      { label: "Export Results", description: "Export deliverables to target directory, then clean" }
+    ]
+  }]
+})
+```
+
+### Action Handlers
+
+| Choice | Steps |
+|--------|-------|
+| Archive & Clean | Update session status="completed" -> TeamDelete -> output final summary with artifact paths |
+| Keep Active | Update session status="paused" -> output: "Resume with: Skill(skill='team-coordinate', args='resume')" |
+| Export Results | AskUserQuestion(target path) -> copy artifacts to target -> Archive & Clean |
+
+---
+
+## Specs Reference
+
+| Spec | Purpose |
+|------|---------|
+| [specs/pipelines.md](specs/pipelines.md) | Dynamic pipeline model, task naming, dependency graph |
+| [specs/role-spec-template.md](specs/role-spec-template.md) | Template for dynamic role-spec generation |
+| [specs/quality-gates.md](specs/quality-gates.md) | Quality thresholds and scoring dimensions |
+| [specs/knowledge-transfer.md](specs/knowledge-transfer.md) | Context transfer protocols between roles |
+
+---
+
+## Session Directory
+
+```
+.workflow/.team/TC-<slug>-<date>/
++-- team-session.json           # Session state + dynamic role registry
++-- task-analysis.json          # Phase 1 output: capabilities, dependency graph
++-- role-specs/                 # Dynamic role-spec definitions (generated Phase 2)
+|   +-- <role-1>.md             # Lightweight: 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
+```
+
+### 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>"
+}
+```
+
+---
+
+## Session Resume
+
+Coordinator supports `resume` / `continue` for interrupted sessions:
+
+1. Scan `.workflow/.team/TC-*/team-session.json` for active/paused sessions
+2. Multiple matches -> AskUserQuestion for selection
+3. Audit TaskList -> reconcile session state <-> task status
+4. Reset in_progress -> pending (interrupted tasks)
+5. Rebuild team and spawn needed workers only
+6. Create missing tasks, set dependencies via TaskUpdate({ addBlockedBy })
+7. Kick first executable task -> Phase 4 coordination loop
+
+---
+
+## Error Handling
+
+| Scenario | Resolution |
+|----------|------------|
+| Unknown command | Error with available command list |
+| Dynamic role-spec not found | Error, coordinator may need to regenerate |
+| Command file not found | Fallback to inline execution |
+| CLI tool fails | Worker proceeds with direct implementation, logs warning |
+| Explore cache corrupt | Clear cache, re-explore |
+| Fast-advance spawns wrong task | Coordinator reconciles on next callback |
+| capability_gap reported | Coordinator generates new role-spec via handleAdapt |
+| Completion action fails | Default to Keep Active, log warning |