maestro-flow 0.3.27 → 0.3.28

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

@@ -129,10 +129,24 @@ After each barrier skill completes, read its artifacts and update `state.context
 }
 ```
 
+7. **Initialize plan tracking** (dual-track: status.json + update_plan):
+
+```
+functions.update_plan({
+  plan: steps.map((step, i) => ({
+    id: `step-${i}`,
+    title: `[${i + 1}/${steps.length}] ${step.skill}${barrier(step) ? ' [BARRIER]' : ''}`,
+    status: "open"
+  }))
+})
+```
+
 **`--dry-run`**: Display chain with `[BARRIER]` markers, stop.
 
 **User confirmation** (skip if AUTO_YES): Display plan, prompt `Proceed? (yes/no)`.
 
+**`--continue` plan rebuild**: When resuming, rebuild `update_plan` from status.json — completed steps → `"completed"`, current → `"in_progress"`, rest → `"open"`.
+
 ### Phase 2: Wave Execution Loop
 
 **While pending steps remain**, increment `waveNum` and repeat:
@@ -151,8 +165,21 @@ After each barrier skill completes, read its artifacts and update `state.context
    ```
 4. **Read results**: Update each step's `status`, `wave_n` from results CSV
 5. **Barrier check**: If wave was a barrier skill, run barrier analysis logic (read artifacts, update context)
-6. **Persist**: Append wave to `state.waves[]`, write `status.json`
-7. **Abort on failure**: If any result `status === 'failed'` → mark remaining steps `skipped`, set `state.status = 'aborted'`, break
+6. **Dual-track persist**:
+   - status.json: Append wave to `state.waves[]`, update step statuses, write `status.json`
+   - update_plan: Sync plan items from status.json step statuses:
+     ```
+     functions.update_plan({
+       plan: steps.map((step, i) => ({
+         id: `step-${i}`,
+         title: `[${i + 1}/${steps.length}] ${step.skill}`,
+         status: step.status === 'completed' ? 'completed'
+               : step.status === 'pending' && i === nextPendingIndex ? 'in_progress'
+               : step.status
+       }))
+     })
+     ```
+7. **Abort on failure**: If any result `status === 'failed'` → mark remaining steps `skipped` in both status.json and update_plan, set `state.status = 'aborted'`, break
 
 ### Skill Call Assembly
 
@@ -196,6 +223,10 @@ Object with all fields required: `status` ("completed"|"failed"), `skill_call` (
 
 ### Phase 3: Completion Report
 
+Finalize dual tracking:
+- status.json: `state.status = 'completed'`
+- update_plan: all steps → `"completed"` (skipped steps also marked completed)
+
 ```
 === COORDINATE COMPLETE ===
 Session:  <sessionId>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maestro-flow",
-  "version": "0.3.27",
+  "version": "0.3.28",
   "description": "Workflow orchestration CLI with MCP endpoint support and extensible architecture",
   "type": "module",
   "imports": {

package/workflows/maestro-chain-execute.md

@@ -3,10 +3,11 @@
 Upgraded version of maestro's original direct execution strategy.
 Reads session status.json, loops through steps with per-step engine selection,
 context propagation, post-step Gemini analysis, and error handling.
-Tracks all progress via status.json (the JSON file created during selection).
+Dual-track progress: status.json (persistence + resume) and TodoWrite (UI visibility).
 
 **Prerequisites:**
 - Session directory with valid status.json (status: "running", pending steps)
+- TodoWrite initialized by selection workflow (Step 3h) with `MAESTRO:{chain_name}:` prefix
 - $SESSION_PATH passed from maestro.md dispatch
 
 ## Step 1: Load Session
@@ -19,6 +20,18 @@ Set `$STEP_INDEX` = `current_step` (first pending step).
 
 Validate: `status == "running"` and at least one pending step exists.
 
+**TodoWrite sync (resume mode):** If TodoWrite has no `MAESTRO:{chain_name}:` entries (e.g., fresh context after `/maestro -c`), rebuild from status.json:
+
+```javascript
+const todos = steps.map((step, i) => ({
+  content: `MAESTRO:${chain_name}: [${i + 1}/${steps.length}] ${step.skill}`,
+  status: step.status === 'completed' ? 'completed'
+        : i === $STEP_INDEX ? 'in_progress'
+        : 'pending'
+}));
+TodoWrite({ todos });
+```
+
 Display banner:
 
 ```
@@ -127,15 +140,35 @@ CLI: capture `exec_id` from stderr `[MAESTRO_EXEC_ID=<id>]`.
 
 **Persist context back to status.json** after each step — write updated `context` field and `current_step`. This enables resume via `/maestro -c`.
 
-### 3d. Handle result
-
-**Success:** mark step `status = "completed"`, set `completed_at` in status.json.
-CLI: save output to `step-{N}-output.txt` in session directory.
+### 3d. Handle result & sync dual tracking
+
+**Success:**
+1. status.json: mark step `status = "completed"`, set `completed_at`
+2. TodoWrite: mark current step `completed`, next step `in_progress`
+3. CLI: save output to `step-{N}-output.txt` in session directory
+
+```javascript
+// Dual-track update after each step
+function updateDualTracking(stepIndex, total, chain_name, result) {
+  // 1. status.json — already updated in 3c
+  // 2. TodoWrite — sync UI
+  const todos = getAllTodos().map(todo => {
+    if (!todo.content.startsWith(`MAESTRO:${chain_name}:`)) return todo;
+    const num = extractStepNum(todo.content);
+    if (num === stepIndex + 1) return { ...todo, status: result };
+    if (num === stepIndex + 2 && result === 'completed') return { ...todo, status: 'in_progress' };
+    return todo;
+  });
+  TodoWrite({ todos });
+}
+```
 
 **Failure:**
-- `auto_mode` → retry once, then skip (mark `"skipped"`).
-- Interactive → offer: Retry (max 2) / Skip / Abort.
-- Abort → **Error E003** — update status.json `status = "aborted"`, display resume hint: `/maestro -c`.
+1. status.json: mark step `"failed"` or `"skipped"`
+2. TodoWrite: mark step `completed` (skipped) or keep `in_progress` (retry)
+3. `auto_mode` → retry once, then skip
+4. Interactive → offer: Retry (max 2) / Skip / Abort
+5. Abort → status.json `status = "aborted"`, TodoWrite mark remaining `pending`, display resume hint: `/maestro -c`
 
 ### 3e. Post-step analysis (CLI steps only)
 
@@ -176,7 +209,9 @@ On callback:
 
 ## Step 4: Completion Report
 
-Update status.json: `status = "completed"`.
+Finalize dual tracking:
+1. status.json: `status = "completed"`
+2. TodoWrite: all steps marked `completed` (or `completed` for skipped)
 
 ```
 ============================================================

package/workflows/maestro.codex.md

@@ -290,8 +290,8 @@ Build context: `{ current_phase, user_intent, issue_id, spec_session_id: null, s
 
 ```
 MAESTRO-COORDINATE: {chain_name}  (dry run)
-  1. ${step.cmd} {step.args}
-  2. ${step.cmd} {step.args}
+  1. ${step.skill} {step.args}
+  2. ${step.skill} {step.args}
   …
 ```
 
@@ -310,7 +310,7 @@ Create session directory `.workflow/.maestro/maestro-{timestamp}/`.
 
 **Auto-flag injection** (when AUTO_YES): `maestro-analyze/-brainstorm/-roadmap/-ui-design` → `-y`, `maestro-plan` → `--auto`, `quality-test` → `--auto-fix`, `quality-retrospective` → `--auto-yes`.
 
-Initialize `state.json` with: session_id, intent, chain_name, auto_yes, context (phase, dirs, issue_id, gaps), waves[], and steps[] (each with index, cmd, args, status=pending).
+Initialize `state.json` with: session_id, intent, chain_name, auto_yes, context (phase, dirs, issue_id, gaps), waves[], and steps[] (each with index, skill, args, status=pending).
 
 ---
 

package/workflows/maestro.md

@@ -272,15 +272,27 @@ Create session directory `.workflow/.maestro/maestro-{YYYYMMDD-HHMMSS}/` and wri
     "spec_session_id": null,
     "scratch_dir": null
   },
-  "steps": [{ "index": 0, "skill": "{skill_name}", "args": "{args}", "engine": "{cli|internal from 3e}", "status": "pending", "started_at": null, "completed_at": null }],
+  "steps": [{ "index": 0, "skill": "{chainMap[].cmd}", "args": "{chainMap[].args}", "engine": "{cli|internal from 3e}", "status": "pending", "started_at": null, "completed_at": null }],
   "current_step": "{$START_STEP or 0}",
   "status": "running"
 }
 ```
 
+### 3h: Initialize TodoWrite tracking
+
+Create TodoWrite entries with `MAESTRO:{chain_name}:` prefix for UI-visible progress tracking. TodoWrite and status.json form dual-track system — TodoWrite for user visibility, status.json for persistence and resume.
+
+```javascript
+const todos = steps.map((step, i) => ({
+  content: `MAESTRO:${chain_name}: [${i + 1}/${steps.length}] ${step.skill}`,
+  status: i === 0 ? 'in_progress' : 'pending'
+}));
+TodoWrite({ todos });
+```
+
 ## Step 4: Dispatch to execution workflow
 
-status.json already created in Step 3g with `steps[]` and `context`.
+status.json already created in Step 3g, TodoWrite initialized in Step 3h.
 
 1. Read `~/.maestro/workflows/maestro-chain-execute.md`
 2. Follow it with `$SESSION_PATH` = session directory from Step 3g