maestro-flow 0.3.2 → 0.3.4

package/.claude/skills/team-testing/roles/generator/role.md

@@ -1,98 +1,98 @@
----
-role: generator
-prefix: TESTGEN
-inner_loop: true
-message_types:
-  success: tests_generated
-  revision: tests_revised
-  error: error
----
-
-# Test Generator
-
-Generate test code by layer (L1 unit / L2 integration / L3 E2E). Acts as the Generator in the Generator-Critic loop. Supports revision mode for GC loop iterations.
-
-## Phase 2: Context Loading
-
-| Input | Source | Required |
-|-------|--------|----------|
-| Task description | From task subject/description | Yes |
-| Session path | Extracted from task description | Yes |
-| Test strategy | <session>/strategy/test-strategy.md | Yes |
-| .msg/meta.json | <session>/wisdom/.msg/meta.json | No |
-
-1. Extract session path and layer from task description
-2. Load test specs: Run `ccw spec load --category test` for test framework conventions and coverage targets
-3. Read test strategy:
-
-```
-Read("<session>/strategy/test-strategy.md")
-```
-
-3. Read source files to test (from strategy priority_files, limit 20)
-4. Read .msg/meta.json for framework and scope context
-
-5. Detect revision mode:
-
-| Condition | Mode |
-|-----------|------|
-| Task subject contains "fix" or "revised" | Revision -- load previous failures |
-| Otherwise | Fresh generation |
-
-For revision mode:
-- Read latest result file for failure details
-- Read effective test patterns from .msg/meta.json
-
-6. Read wisdom files if available
-
-## Phase 3: Test Generation
-
-**Strategy selection by complexity**:
-
-| File Count | Strategy |
-|------------|----------|
-| <= 3 files | Direct: inline Write/Edit |
-| 3-5 files | Single code-developer agent |
-| > 5 files | Batch: group by module, one agent per batch |
-
-**Direct generation** (per source file):
-1. Generate test path: `<session>/tests/<layer>/<test-file>`
-2. Generate test code: happy path, edge cases, error handling
-3. Write test file
-
-**CLI delegation** (medium/high complexity):
-
-```
-Bash({
-  command: `maestro cli -p "PURPOSE: Generate <layer> tests using <framework> to achieve coverage target; success = all priority files covered with quality tests
-TASK: • Analyze source files • Generate test cases (happy path, edge cases, errors) • Write test files with proper structure • Ensure import resolution
-MODE: write
-CONTEXT: @<source-files> @<session>/strategy/test-strategy.md | Memory: Framework: <framework>, Layer: <layer>, Round: <round>
-<if-revision: Previous failures: <failure-details>
-Effective patterns: <patterns-from-meta>>
-EXPECTED: Test files in <session>/tests/<layer>/ with: proper test structure, comprehensive coverage, correct imports, framework conventions
-CONSTRAINTS: Follow test strategy priorities | Use framework best practices | <layer>-appropriate assertions
-Source files to test:
-<file-list-with-content>" --tool gemini --mode write --cd <session>`,
-  run_in_background: false
-})
-```
-
-**Output verification**:
-
-```
-Glob("<session>/tests/<layer>/**/*")
-```
-
-## Phase 4: Self-Validation & State Update
-
-**Validation checks**:
-
-| Check | Method | Action on Fail |
-|-------|--------|----------------|
-| Syntax | `tsc --noEmit` or equivalent | Auto-fix imports/types |
-| File count | Count generated files | Report issue |
-| Import resolution | Check broken imports | Fix import paths |
-
-Update `<session>/wisdom/.msg/meta.json` under `generator` namespace:
-- Merge `{ "generator": { test_files, layer, round, is_revision } }`
+---
+role: generator
+prefix: TESTGEN
+inner_loop: true
+message_types:
+  success: tests_generated
+  revision: tests_revised
+  error: error
+---
+
+# Test Generator
+
+Generate test code by layer (L1 unit / L2 integration / L3 E2E). Acts as the Generator in the Generator-Critic loop. Supports revision mode for GC loop iterations.
+
+## Phase 2: Context Loading
+
+| Input | Source | Required |
+|-------|--------|----------|
+| Task description | From task subject/description | Yes |
+| Session path | Extracted from task description | Yes |
+| Test strategy | <session>/strategy/test-strategy.md | Yes |
+| .msg/meta.json | <session>/wisdom/.msg/meta.json | No |
+
+1. Extract session path and layer from task description
+2. Load test specs: Run `ccw spec load --category test` for test framework conventions and coverage targets
+3. Read test strategy:
+
+```
+Read("<session>/strategy/test-strategy.md")
+```
+
+3. Read source files to test (from strategy priority_files, limit 20)
+4. Read .msg/meta.json for framework and scope context
+
+5. Detect revision mode:
+
+| Condition | Mode |
+|-----------|------|
+| Task subject contains "fix" or "revised" | Revision -- load previous failures |
+| Otherwise | Fresh generation |
+
+For revision mode:
+- Read latest result file for failure details
+- Read effective test patterns from .msg/meta.json
+
+6. Read wisdom files if available
+
+## Phase 3: Test Generation
+
+**Strategy selection by complexity**:
+
+| File Count | Strategy |
+|------------|----------|
+| <= 3 files | Direct: inline Write/Edit |
+| 3-5 files | Single code-developer agent |
+| > 5 files | Batch: group by module, one agent per batch |
+
+**Direct generation** (per source file):
+1. Generate test path: `<session>/tests/<layer>/<test-file>`
+2. Generate test code: happy path, edge cases, error handling
+3. Write test file
+
+**CLI delegation** (medium/high complexity):
+
+```
+Bash({
+  command: `maestro delegate "PURPOSE: Generate <layer> tests using <framework> to achieve coverage target; success = all priority files covered with quality tests
+TASK: • Analyze source files • Generate test cases (happy path, edge cases, errors) • Write test files with proper structure • Ensure import resolution
+MODE: write
+CONTEXT: @<source-files> @<session>/strategy/test-strategy.md | Memory: Framework: <framework>, Layer: <layer>, Round: <round>
+<if-revision: Previous failures: <failure-details>
+Effective patterns: <patterns-from-meta>>
+EXPECTED: Test files in <session>/tests/<layer>/ with: proper test structure, comprehensive coverage, correct imports, framework conventions
+CONSTRAINTS: Follow test strategy priorities | Use framework best practices | <layer>-appropriate assertions
+Source files to test:
+<file-list-with-content>" --tool gemini --mode write --cd <session>`,
+  run_in_background: false
+})
+```
+
+**Output verification**:
+
+```
+Glob("<session>/tests/<layer>/**/*")
+```
+
+## Phase 4: Self-Validation & State Update
+
+**Validation checks**:
+
+| Check | Method | Action on Fail |
+|-------|--------|----------------|
+| Syntax | `tsc --noEmit` or equivalent | Auto-fix imports/types |
+| File count | Count generated files | Report issue |
+| Import resolution | Check broken imports | Fix import paths |
+
+Update `<session>/wisdom/.msg/meta.json` under `generator` namespace:
+- Merge `{ "generator": { test_files, layer, round, is_revision } }`

package/.codex/skills/maestro-coordinate/SKILL.md

@@ -307,4 +307,4 @@ Resume: $maestro-coordinate --continue
 6. **Close before spawn**: Always `close_agent` the current step agent before spawning the next
 7. **Dry-run is read-only**: Stop after displaying the chain plan — never spawn agents
 8. **Timeout handling**: One urge via `send_message`; if still timed out → mark `failed`
-9. **No CLI fallback**: All execution is agent-native — no `exec_command("maestro cli ...")`
+9. **No CLI fallback**: All execution is agent-native — no `exec_command("maestro delegate ...")`

package/.codex/skills/manage-issue-analyze/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: maestro-issue-analyze
-description: Root cause analysis for a specific issue via CLI exploration. Gathers codebase context (grep or semantic deep search), runs maestro cli gemini analysis, and attaches a structured analysis record to the issue in issues.jsonl.
+description: Root cause analysis for a specific issue via CLI exploration. Gathers codebase context (grep or semantic deep search), runs maestro delegate gemini analysis, and attaches a structured analysis record to the issue in issues.jsonl.
 argument-hint: "<ISS-ID> [--tool gemini|qwen] [--depth standard|deep]"
 allowed-tools: Read, Write, Bash, Glob, Grep
 ---
@@ -26,7 +26,7 @@ $maestro-issue-analyze "ISS-20260401-001 --tool qwen --depth standard"
 
 ## Overview
 
-Sequential 4-step pipeline: load issue → gather codebase context → run CLI analysis → attach analysis record. The CLI analysis step invokes `maestro cli --tool gemini --mode analysis` to produce a structured root-cause record written back into issues.jsonl. This is the first step in the issue resolution workflow: **analyze → plan → execute**.
+Sequential 4-step pipeline: load issue → gather codebase context → run CLI analysis → attach analysis record. The CLI analysis step invokes `maestro delegate --to gemini --mode analysis` to produce a structured root-cause record written back into issues.jsonl. This is the first step in the issue resolution workflow: **analyze → plan → execute**.
 
 ```
 Load Issue  →  Gather Context  →  CLI Analysis  →  Attach Record
@@ -119,7 +119,7 @@ CONSTRAINTS: Evidence required — file:line for each claim`
 
 Write(`/tmp/iss-analyze-${issue.id}.txt`, promptContent)
 functions.exec_command({
-  cmd: `maestro cli -p "$(cat /tmp/iss-analyze-${issue.id}.txt)" --tool ${tool} --mode analysis`,
+  cmd: `maestro delegate "$(cat /tmp/iss-analyze-${issue.id}.txt)" --to ${tool} --mode analysis`,
   workdir: "."
 })
 ```

package/.codex/skills/manage-issue-execute/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: maestro-issue-execute
-description: Execute a planned solution for an issue via dual-mode dispatch. Auto-detects server UP (POST to /api/execution/dispatch) or DOWN (direct maestro cli). Updates issue status on completion with next-step routing to close, debug, or verify.
+description: Execute a planned solution for an issue via dual-mode dispatch. Auto-detects server UP (POST to /api/execution/dispatch) or DOWN (direct maestro delegate). Updates issue status on completion with next-step routing to close, debug, or verify.
 argument-hint: "<ISS-ID> [--executor claude-code|codex|gemini] [--dry-run]"
 allowed-tools: Read, Write, Bash, Glob, Grep
 ---
@@ -27,7 +27,7 @@ $maestro-issue-execute "ISS-20260401-001 --executor gemini"
 
 ## Overview
 
-Sequential 4-step pipeline with conditional dispatch: load issue → dry-run check → detect mode → execute + update. Server-UP path posts to the orchestration API; Server-DOWN path invokes `maestro cli` directly. This is the third step in the issue resolution workflow: **analyze → plan → execute**.
+Sequential 4-step pipeline with conditional dispatch: load issue → dry-run check → detect mode → execute + update. Server-UP path posts to the orchestration API; Server-DOWN path invokes `maestro delegate` directly. This is the third step in the issue resolution workflow: **analyze → plan → execute**.
 
 ```
 Load Issue  →  [dry-run?]  →  Detect Mode  →  Dispatch  →  Update Status
@@ -79,7 +79,7 @@ const serverUp = healthCheck.stdout.trim() === "200"
 | Mode | Condition | Action |
 |------|-----------|--------|
 | Server UP | HTTP 200 from /health | POST to `/api/execution/dispatch` |
-| Server DOWN | Any other result | Direct `maestro cli` execution |
+| Server DOWN | Any other result | Direct `maestro delegate` execution |
 
 ```javascript
 functions.update_plan({
@@ -124,7 +124,7 @@ functions.exec_command({
 // Write prompt to temp file to avoid shell injection
 Write(`/tmp/iss-exec-${issue.id}.txt`, execPrompt)
 functions.exec_command({
-  cmd: `maestro cli -p "$(cat /tmp/iss-exec-${issue.id}.txt)" --tool ${executor === 'codex' ? 'codex' : 'claude'} --mode write`,
+  cmd: `maestro delegate "$(cat /tmp/iss-exec-${issue.id}.txt)" --to ${executor === 'codex' ? 'codex' : 'claude'} --mode write`,
   workdir: "."
 })
 ```

package/.codex/skills/manage-issue-plan/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: maestro-issue-plan
-description: Solution planning for a specific issue. Auto-detects analysis context, runs maestro cli planning, and attaches a structured solution record with ordered steps and verification criteria to the issue in issues.jsonl.
+description: Solution planning for a specific issue. Auto-detects analysis context, runs maestro delegate planning, and attaches a structured solution record with ordered steps and verification criteria to the issue in issues.jsonl.
 argument-hint: "<ISS-ID> [--tool gemini|qwen] [--from-analysis]"
 allowed-tools: Read, Write, Bash, Glob, Grep
 ---
@@ -82,7 +82,7 @@ CONSTRAINTS: Concrete steps only | File:line references required | No speculativ
 // Write prompt to temp file to avoid shell injection
 Write(`/tmp/iss-plan-${issueId}.txt`, prompt)
 functions.exec_command({
-  cmd: `maestro cli -p "$(cat /tmp/iss-plan-${issueId}.txt)" --tool ${tool} --mode analysis`,
+  cmd: `maestro delegate "$(cat /tmp/iss-plan-${issueId}.txt)" --to ${tool} --mode analysis`,
   workdir: "."
 })
 ```

package/.codex/skills/quality-business-test/SKILL.md

@@ -0,0 +1,223 @@
+---
+name: maestro-business-test
+description: PRD-forward business testing with requirement traceability, multi-layer execution (L1 Interface → L2 Business Rule → L3 Scenario), fixture generation, and feedback loop.
+argument-hint: "<phase> [--spec SPEC-xxx] [--layer L1|L2|L3] [--gen-code] [--dry-run] [--re-run] [--auto]"
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Agent, AskUserQuestion
+---
+
+## Auto Mode
+
+`--auto` skips interactive confirmation of test plan. `--dry-run` extracts scenarios only without execution.
+
+# Business Test (PRD-Forward)
+
+## Usage
+
+```bash
+$maestro-business-test "3"                          # test phase 3 against PRD
+$maestro-business-test "3 --layer L1"               # L1 interface tests only
+$maestro-business-test "3 --gen-code"               # generate framework-specific test classes
+$maestro-business-test "3 --dry-run"                # extract scenarios only, don't execute
+$maestro-business-test "3 --re-run"                 # re-run only previously failed scenarios
+$maestro-business-test "3 --spec SPEC-auth-2026-04" # explicit spec reference
+$maestro-business-test "3 --auto"                   # skip plan confirmation
+```
+
+**Flags**:
+- `<phase>`: Phase number (required)
+- `--spec SPEC-xxx`: Explicit spec package reference (default: auto-detect from index.json)
+- `--layer L1|L2|L3`: Run only specific layer
+- `--gen-code`: Generate framework-specific test classes (JUnit/RestAssured, supertest/vitest, pytest/httpx)
+- `--dry-run`: Extract scenarios and fixtures only, don't execute
+- `--re-run`: Re-run only previously failed/blocked scenarios
+- `--auto`: Skip interactive confirmations
+
+**Output**: `{phase_dir}/.tests/business/business-test-plan.json` + `business-test-report.json` + `business-test-summary.md`
+
+---
+
+## Overview
+
+Validate built features against PRD acceptance criteria through automated multi-layer business testing. Unlike quality-test (interactive UAT from code gaps) and quality-test-gen (generate tests from coverage gaps), this starts from REQ-*.md acceptance criteria and works forward.
+
+**Three-track testing** (complementary, not replacements):
+
+| Command | Input Source | Verification Angle |
+|---------|-------------|-------------------|
+| `quality-business-test` | REQ-*.md acceptance criteria | **PRD-forward** — are business rules satisfied? |
+| `quality-test` | verification.json must_haves | **Code-backward** — does the code work? |
+| `quality-test-gen` | validation.json gaps | **Coverage-backward** — is coverage sufficient? |
+
+**Layer definitions:**
+
+| Layer | Name | Tests | Source |
+|-------|------|-------|--------|
+| L1 | Interface Contract | Single endpoint request/response, input validation, schema compliance | Architecture API endpoints + REQ AC |
+| L2 | Business Rule | Multi-step logic, state transitions, business constraints, edge cases | REQ acceptance criteria + NFR |
+| L3 | Business Scenario | Full user flows, multi-service chains, error propagation | Epic user stories |
+
+---
+
+## Implementation
+
+### Step 1: Resolve Target & Load Spec Package
+
+1. Parse `$ARGUMENTS` for phase number and flags
+2. Set `PHASE_DIR = .workflow/phases/{NN}-{slug}/`
+3. Load `index.json` -> find `spec_ref` -> locate `.workflow/.spec/SPEC-xxx/`
+4. **Full mode**: Read `requirements/_index.md` + all `REQ-*.md` + `NFR-*.md` + `architecture/_index.md` + `epics/EPIC-*.md`
+5. **Degraded mode** (no spec package): Read `index.json.success_criteria` + `plan.json` convergence criteria + `.summaries/TASK-*.md`
+6. If `--re-run`: load previous `business-test-report.json`, filter to failed/blocked scenarios
+
+### Step 2: Extract Business Test Scenarios from PRD
+
+For each `REQ-NNN-{slug}.md`:
+
+1. Parse `## Acceptance Criteria` section
+2. Map RFC 2119 keywords to priority:
+
+| Keyword | Priority | Failure = |
+|---------|----------|-----------|
+| MUST / SHALL | critical | blocker |
+| SHOULD / RECOMMENDED | high | major |
+| MAY / OPTIONAL | medium | minor |
+
+3. Classify scenario into layer:
+
+| Source | Layer | Category |
+|--------|-------|----------|
+| Architecture API endpoints + REQ AC about request/response | L1 | api_contract |
+| REQ AC about business logic, validation, state changes | L2 | business_rule |
+| Architecture state machine transitions | L2 | state_transition |
+| Epic user stories (multi-step flows) | L3 | user_flow |
+| NFR performance/security constraints | L2 | non_functional |
+
+4. Generate scenario JSON with `id`, `req_ref` (REQ-NNN:AC-N), `layer`, `priority`, `name`, `category`, `endpoint`, `input`, `expected`, `preconditions`, `postconditions`, `mock_services`
+
+**Degraded mode**: Extract from success_criteria (each -> L2 scenario), plan.json convergence criteria (each -> L1/L2), all default priority: high. No L3 in degraded mode.
+
+### Step 3: Generate Test Data (Fixtures)
+
+Three tiers:
+
+**Tier 1 — Schema-derived**: From REQ data models, generate valid/invalid/boundary variants per entity:
+- valid: satisfies all constraints
+- invalid: violate each constraint individually (null, empty, overflow, wrong type)
+- boundary: edge values (min, max, min-1, max+1)
+
+**Tier 2 — Criteria-derived**: From "MUST return X when Y" -> `{ input: Y, expected: X }`. From "MUST validate Z" -> `{ input: invalid_Z, expected: error }`.
+
+**Tier 3 — Scenario-derived (L3 only)**: From Epic user stories -> scenario packs with coordinated entity IDs across steps.
+
+**Microservice mocks**: From architecture API contract -> request/response pairs for WireMock stubs.
+
+### Step 4: Write Test Plan & Confirm
+
+1. Archive previous `business-test-plan.json` to `.history/` if exists
+2. Write `.tests/business/business-test-plan.json` with scenarios, fixtures, mock_contracts, requirement_coverage_plan
+3. Display plan summary (scenario counts per layer, fixture counts, requirement coverage)
+4. If not `--auto`: wait for user confirmation (yes/edit/cancel)
+5. If `--dry-run`: stop here, report plan
+
+### Step 5: Generate Test Code (if --gen-code)
+
+Detect project tech stack from `.workflow/specs/project-tech.json` or codebase scan.
+
+| Stack | L1 | L2 | L3 |
+|-------|----|----|-----|
+| Java/Spring Boot | RestAssured + MockMvc | JUnit 5 Parameterized + WireMock | TestContainers |
+| TypeScript/Node | supertest + vitest | vitest + nock | playwright/cypress |
+| Python | httpx + pytest | pytest + responses | pytest + selenium |
+
+Each test method includes REQ-NNN:AC-N reference in display name. Test files placed in `.tests/business/{layer}/`.
+
+If no `--gen-code`: scenarios stay as structured JSON for AI agent execution.
+
+### Step 6: Execute Tests (Progressive L1 → L2 → L3)
+
+**Fail-fast**: L1 critical failures -> STOP (don't run L2). L2 critical failures -> STOP (don't run L3).
+
+**Generator-Critic loop per layer (max 3 iterations):**
+
+| Iteration | Action |
+|-----------|--------|
+| 1 | Run all scenarios. Critic: classify failures as test_defect / code_defect / env_issue |
+| 2 | Auto-fix test_defects, re-run ALL scenarios |
+| 3 | Final confirmation. Remaining failures = confirmed code_defects |
+
+**Execution modes:**
+- `--gen-code`: run via test framework (`mvn test`, `npx vitest`, etc.)
+- default: AI agent executes scenarios against running application
+
+Record results in `.tests/business/test-results-iter-{N}.json`.
+
+### Step 7: Build Traceability Matrix
+
+Map each result to `REQ-NNN:AC-N`:
+
+```
+FOR each REQ:
+  FOR each AC:
+    ac_status = "passed" if ALL scenarios passed
+                "failed" if ANY failed
+                "blocked" if ANY blocked (none failed)
+                "untested" if no scenarios mapped
+  verdict = "verified" if all MUST+SHOULD passed
+            "partial" if some failed
+            "unverified" if all failed/untested
+```
+
+### Step 8: Generate Reports
+
+1. Archive previous report/summary to `.history/`
+2. Write `.tests/business/business-test-report.json` with:
+   - `layers`: per-layer stats (total, passed, failed, blocked, pass_rate)
+   - `requirement_coverage`: per-REQ criteria results with failure details
+   - `failures`: each with req_ref, severity, expected/actual, fix_suggestion
+   - `summary`: total_requirements, fully_verified, partially_verified, unverified, coverage_pct
+3. Write `.tests/business/business-test-summary.md` (human-readable tables)
+4. Update `index.json` with `business_test` section
+
+### Step 9: Feedback Loop
+
+1. Auto-create issues from failures in `.workflow/issues/issues.jsonl` (each with `req_ref`, `source: "business-test"`)
+2. Report results
+3. Route next step:
+
+| Result | Suggestion |
+|--------|------------|
+| All requirements verified | Skill({ skill: "maestro-phase-transition", args: "{phase}" }) |
+| Failures found | Skill({ skill: "quality-debug", args: "--from-business-test {phase}" }) |
+| `--re-run` all pass | Skill({ skill: "maestro-verify", args: "{phase}" }) |
+| Low coverage (< 60%) | Skill({ skill: "quality-test-gen", args: "{phase}" }) |
+
+**Closure criteria**: Requirement marked "verified" ONLY when ALL MUST+SHOULD acceptance criteria pass.
+
+---
+
+## Error Handling
+
+| Code | Severity | Condition | Recovery |
+|------|----------|-----------|----------|
+| E001 | error | Phase number required | Prompt user for phase number |
+| E002 | error | Phase directory not found | Verify phase exists in .workflow/phases/ |
+| E003 | error | No spec package AND no success_criteria | Run maestro-spec-generate or maestro-plan first |
+| E004 | error | L1 critical failures block L2/L3 | Fix blockers via quality-debug |
+| W001 | warning | Degraded mode (no spec package) | Consider running maestro-spec-generate |
+| W002 | warning | Some REQs have no testable AC | Note in report |
+| W003 | warning | Generator-Critic loop exhausted | Accept current state |
+| W004 | warning | Mock services unavailable for L3 | Skip L3 or use --gen-code |
+
+---
+
+## Core Rules
+
+- **PRD is source of truth** -- business rules drive test scenarios, not code structure
+- **RFC 2119 keyword priority** -- MUST = critical, SHOULD = high, MAY = medium
+- **Fail-fast across layers** -- critical L1 failures block L2/L3
+- **Generator-Critic loop max 3 iterations** per layer
+- **Traceability on every result** -- every pass/fail maps to REQ-NNN:AC-N
+- **Agent calls use `run_in_background: false`** for synchronous execution
+- **Auto-create issues** in `.workflow/issues/issues.jsonl` for every failure
+- **Degraded mode** works without spec package (from success_criteria + plan.json)
+- **Never modify source code** -- this command tests, it doesn't fix

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

@@ -28,8 +28,8 @@ Universal team coordination skill: analyze task -> generate role-specs -> dispat
   (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
+    maestro delegate --mode analysis  - analysis and exploration
+    maestro delegate --mode write     - code generation and modification
 ```
 
 ## Delegation Lock
@@ -48,7 +48,7 @@ Before calling ANY tool, apply this check:
 | `Read` on `roles/`, `commands/`, `specs/` | ALLOWED | Loading own instructions |
 | `Read/Grep/Glob` on project source code | BLOCKED | Delegate to worker |
 | `Edit` on any file outside `.workflow/` | BLOCKED | Delegate to worker |
-| `Bash("maestro cli ...")` | BLOCKED | Only workers call CLI |
+| `Bash("maestro delegate ...")` | BLOCKED | Only workers call CLI |
 | `Bash` running build/test/lint commands | BLOCKED | Delegate to worker |
 
 **If a tool call is BLOCKED**: STOP. Create a task, spawn a worker.
@@ -65,8 +65,8 @@ Before calling ANY tool, apply this check:
 | Session path | `.workflow/.team/TC-<slug>-<date>/` |
 | Worker agent | `team-worker` |
 | Message bus | `mcp__maestro-tools__team_msg(session_id=<session-id>, ...)` |
-| CLI analysis | `maestro cli --mode analysis` |
-| CLI write | `maestro cli --mode write` |
+| CLI analysis | `maestro delegate --mode analysis` |
+| CLI write | `maestro delegate --mode write` |
 | Max roles | 5 |
 
 ## Role Router
@@ -92,8 +92,8 @@ 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 |
+| maestro delegate --mode analysis | Analysis, exploration, pattern discovery |
+| maestro delegate --mode write | Code generation, modification, refactoring |
 
 ### Dispatch
 

package/.codex/skills/team-coordinate/roles/coordinator/role.md

@@ -18,7 +18,7 @@ Orchestrate the team-coordinate workflow: task analysis, dynamic role-spec gener
 ```
 WRONG: Read("src/components/Button.tsx")           — worker work
 WRONG: Grep(pattern="useState", path="src/")       — worker work
-WRONG: Bash("maestro cli -p '...' --tool gemini")      — worker work
+WRONG: Bash("maestro delegate '...' --to gemini")      — worker work
 WRONG: Edit("src/utils/helper.ts", ...)             — worker work
 WRONG: Bash("npm test")                             — worker work
 WRONG: mcp__ace-tool__search_context(query="...")   — worker work

package/.codex/skills/team-lifecycle-v4/SKILL.md

@@ -71,7 +71,7 @@ Before calling ANY tool, apply this check:
 | `Read` on `roles/`, `commands/`, `specs/`, `templates/` | ALLOWED | Loading own instructions |
 | `Read/Grep/Glob` on project source code | BLOCKED | Delegate to worker |
 | `Edit` on any file outside `.workflow/` | BLOCKED | Delegate to worker |
-| `Bash("maestro cli ...")` | BLOCKED | Only workers call CLI |
+| `Bash("maestro delegate ...")` | BLOCKED | Only workers call CLI |
 | `Bash` running build/test/lint commands | BLOCKED | Delegate to worker |
 
 **If a tool call is BLOCKED**: STOP. Create a task, spawn a worker.
@@ -86,7 +86,7 @@ Before calling ANY tool, apply this check:
 - **Session path**: `.workflow/.team/TLV4-<slug>-<date>/`
 - **State file**: `<session>/tasks.json`
 - **Discovery files**: `<session>/discoveries/{task_id}.json`
-- **CLI tools**: `maestro cli --mode analysis` (read-only), `maestro cli --mode write` (modifications)
+- **CLI tools**: `maestro delegate --mode analysis` (read-only), `maestro delegate --mode write` (modifications)
 
 ## Worker Spawn Template
 

package/.codex/skills/team-lifecycle-v4/instructions/agent-instruction.md

@@ -27,7 +27,7 @@ This instruction is loaded by team-worker agents when spawned with roles: `analy
 
 2. **Explore domain** (use CLI analysis tools):
    ```bash
-   maestro cli -p "PURPOSE: Research domain for {requirement}
+   maestro delegate "PURPOSE: Research domain for {requirement}
    TASK: • Identify problem statement • Define target users • Extract constraints • Map integration points
    CONTEXT: @**/* | Memory: {requirement}
    EXPECTED: Structured research context with problem/users/domain/constraints
@@ -294,7 +294,7 @@ This instruction is loaded by team-worker agents when spawned with roles: `analy
 
 2. **Explore codebase** (use CLI analysis tools):
    ```bash
-   maestro cli -p "PURPOSE: Explore codebase for {requirement}
+   maestro delegate "PURPOSE: Explore codebase for {requirement}
    TASK: • Identify relevant files • Find existing patterns • Locate integration points
    CONTEXT: @**/* | Memory: {requirement}
    EXPECTED: Exploration findings with file paths and patterns

package/.codex/skills/team-lifecycle-v4/roles/analyst/role.md

@@ -36,7 +36,7 @@ Research and codebase exploration for context gathering.
 4. If topic references file (@path or .md/.txt) -> read it
 5. CLI seed analysis:
    ```
-   Bash({ command: `maestro cli -p "PURPOSE: Analyze topic, extract structured seed info.
+   Bash({ command: `maestro delegate "PURPOSE: Analyze topic, extract structured seed info.
    TASK: * Extract problem statement * Identify target users * Determine domain
    * List constraints * Identify 3-5 exploration dimensions
    TOPIC: <topic-content>
@@ -54,7 +54,7 @@ Research and codebase exploration for context gathering.
 
 When project detected:
 ```
-Bash({ command: `maestro cli -p "PURPOSE: Explore codebase for context
+Bash({ command: `maestro delegate "PURPOSE: Explore codebase for context
 TASK: * Identify tech stack * Map architecture patterns * Document conventions * List integration points
 MODE: analysis
 CONTEXT: @**/*

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

@@ -14,7 +14,7 @@ Orchestrate team-lifecycle-v4: analyze -> dispatch -> spawn -> monitor -> report
 ```
 WRONG: Read("src/...")                              — worker work
 WRONG: Grep/Glob on project source                  — worker work
-WRONG: Bash("maestro cli -p '...' --tool gemini")       — worker work
+WRONG: Bash("maestro delegate '...' --to gemini")       — worker work
 WRONG: Edit/Write on project source files            — worker work
 WRONG: Bash("npm test"), Bash("tsc"), etc.           — worker work
 ```
@@ -47,7 +47,7 @@ WRONG: Bash("npm test"), Bash("tsc"), etc.           — worker work
 - Modify task output artifacts
 - Spawn workers with general-purpose agent (MUST use team_worker)
 - Generate more than 5 worker roles
-- Call CLI tools (maestro cli) — only workers use CLI
+- Call CLI tools (maestro delegate) — only workers use CLI
 
 ## Command Execution Protocol
 When coordinator needs to execute a specific phase:

package/.codex/skills/team-lifecycle-v4/roles/executor/commands/implement.md

@@ -51,7 +51,7 @@ CONSTRAINTS: Only modify listed files | Follow existing patterns
 
 CLI call:
 ```
-Bash(`maestro cli -p "<prompt>" --tool <tool> --mode write --rule development-implement-feature`)
+Bash(`maestro delegate "<prompt>" --to <tool> --mode write --rule development-implement-feature`)
 ```
 
 Resume strategy: