maestro-flow 0.3.14 → 0.3.16

package/workflows/status.md

@@ -17,31 +17,14 @@ Status dashboard with intelligent routing.
 3. Read `.workflow/roadmap.md`:
    - Extract phase list with titles
 
-4. Load Issue State:
-   - If `.workflow/issues/issues.jsonl` exists:
-     - Read all lines, parse each as JSON
-     - Compute statistics:
-       ```
-       by_status: {
-         registered: count(status == "registered"),
-         diagnosed:  count(status == "diagnosed"),
-         planning:   count(status == "planning"),
-         planned:    count(status == "planned"),
-         executing:  count(status == "executing")
-       }
-       by_severity: {
-         critical: count(severity == "critical"),
-         high:     count(severity == "high"),
-         medium:   count(severity == "medium"),
-         low:      count(severity == "low")
-       }
-       total_open:    count where status NOT in [completed, failed, deferred]
-       critical_open: count where severity == "critical" AND status NOT in [completed, failed, deferred]
-       critical_issues: list of {id, title, status} where severity == "critical" AND status NOT in [completed, failed, deferred]
-       ```
-     - Store as issue_state
-   - Else:
-     - issue_state = null (no issues tracked)
+4. Load Issue State from `.workflow/issues/issues.jsonl` (if exists):
+   ```
+   Compute: by_status (registered/diagnosed/planning/planned/executing counts),
+     by_severity (critical/high/medium/low counts),
+     total_open (exclude completed/failed/deferred),
+     critical_open + critical_issues list {id, title, status}
+   ```
+   If file missing → issue_state = null
 
 ---
 
@@ -50,37 +33,15 @@ Status dashboard with intelligent routing.
 Derive phase progress from `state.json.artifacts[]`:
 
 ```
-// Group artifacts by phase for current milestone
-milestone_artifacts = state.json.artifacts.filter(a => a.milestone == current_milestone)
-
-// Build phase view from roadmap + artifact registry
-phases_from_roadmap = parse roadmap.md → list of { number, slug, title }
-
-FOR each phase IN phases_from_roadmap:
-  phase_artifacts = milestone_artifacts.filter(a => a.phase == phase.number)
-  has_analyze = phase_artifacts.some(a => a.type == "analyze" && a.status == "completed")
-  has_plan = phase_artifacts.some(a => a.type == "plan" && a.status == "completed")
-  has_execute = phase_artifacts.some(a => a.type == "execute" && a.status == "completed")
-  has_verify = phase_artifacts.some(a => a.type == "verify" && a.status == "completed")
-
-  // Derive status from artifact chain
-  status = has_verify ? "verified" :
-           has_execute ? "executed" :
-           has_plan ? "planned" :
-           has_analyze ? "analyzed" :
-           "pending"
-
-  // Get task counts from plan artifacts
-  plan_artifact = phase_artifacts.find(a => a.type == "plan" && a.status == "completed")
-  IF plan_artifact:
-    plan_json = read .workflow/{plan_artifact.path}/plan.json
-    tasks_total = plan_json.task_ids.length
-    tasks_completed = count .task/TASK-*.json where status == "completed"
-
-phases[] = { number, slug, title, status, tasks_total, tasks_completed, has_verify }
-
-// Also show adhoc artifacts
-adhoc_artifacts = milestone_artifacts.filter(a => a.scope == "adhoc")
+milestone_artifacts = artifacts filtered by current_milestone
+phases_from_roadmap = parse roadmap.md → { number, slug, title }
+
+Per phase: check completed artifact types (analyze/plan/execute/verify)
+  → derive status: verified > executed > planned > analyzed > pending
+  → get task counts from plan artifact's plan.json if available
+
+Output: phases[] = { number, slug, title, status, tasks_total, tasks_completed, has_verify }
+Also collect: adhoc_artifacts (scope == "adhoc")
 ```
 
 ---
@@ -88,100 +49,35 @@ adhoc_artifacts = milestone_artifacts.filter(a => a.scope == "adhoc")
 ## Step 2.5: Artifact Registry Consistency Check
 
 ```
-IF .workflow/roadmap.md exists:
-  roadmap_phases = parse phase headings from roadmap.md (count "### Phase N:" entries)
-  artifact_phases = unique phase numbers from milestone_artifacts
-
-  // Check for unregistered work (artifacts without matching roadmap phases)
-  orphan_artifacts = milestone_artifacts.filter(a => a.phase && !roadmap_phases.includes(a.phase))
-  IF orphan_artifacts.length > 0:
-    Display WARNING: "Artifacts reference phases not in roadmap"
-
-ELSE IF NOT .workflow/roadmap.md exists AND milestone_artifacts.length > 0:
-  Display WARNING:
-    ⚠️  Roadmap missing but artifact registry has {milestone_artifacts.length} entries.
-    This may indicate a completed milestone. Run /maestro continue to plan next milestone.
+If roadmap exists → warn if any artifacts reference phases not in roadmap (orphan check)
+If roadmap missing but artifacts exist → warn: may indicate completed milestone, suggest /maestro continue
 ```
 
 ---
 
 ## Step 3: Compute Progress
 
-1. Count by status:
-   ```
-   total     = phases.length
-   completed = phases.filter(status == "completed").length
-   executing = phases.filter(status == "executing").length
-   planning  = phases.filter(status == "planning").length
-   exploring = phases.filter(status == "exploring").length
-   pending   = phases.filter(status == "pending").length
-   blocked   = phases.filter(status == "blocked").length
-   ```
-
-2. Calculate overall progress:
-   ```
-   progress_pct = (completed / total) * 100
-   ```
+```
+Count phases by status: completed, executing, planning, exploring, pending, blocked
+progress_pct = (completed / total) * 100
+```
 
 ---
 
 ## Step 4: Display Dashboard
 
 ```
-====================================================
-  PROJECT: {project_name}
-  MILESTONE: {current_milestone}
-  STATUS: {status}
-  PROGRESS: [{progress_bar}] {completed}/{total} phases ({progress_pct}%)
-====================================================
-
-PHASES:
-  {for each phase}
-  [{status_icon}] Phase {number}: {title}
-      Status: {status}
-      Tasks: {tasks_completed}/{tasks_total}
-      Verification: {verification_status}
-  {/for}
-
-CONTEXT:
-  Key Decisions: {key_decisions, comma-separated}
-  Blockers: {blockers or "none"}
-  Deferred: {deferred or "none"}
-
-====================================================
+PROJECT / MILESTONE / STATUS / PROGRESS bar ({completed}/{total} phases)
+Per phase: [{status_icon}] Phase {N}: {title} — status, task counts, verification
+CONTEXT: key_decisions, blockers, deferred
 ```
 
 ### Step 4.1: Render Issue Summary
 
-If issue_state is not null:
+If issue_state exists: display ISSUES panel (open count, critical count, by-status breakdown, critical issues list).
+- Omit critical sub-section if none. Note blockers→issues migration if applicable. Note deferred items.
 
-```
-┌─────────────────────────────────────────┐
-│ ISSUES                                  │
-├─────────────────────────────────────────┤
-│ Open: {total_open}                      │
-│   Critical: {critical_open}             │
-│   By Status:                            │
-│     registered: {N} | diagnosed: {N}    │
-│     planning: {N}   | planned: {N}      │
-│     executing: {N}                      │
-│                                         │
-│ Critical Issues:                        │
-│   {id} | {title (truncated 40ch)} | {status}  │
-│   ...                                   │
-└─────────────────────────────────────────┘
-```
-
-If critical_issues is empty, omit the "Critical Issues:" sub-section.
-
-If accumulated_context.blockers is non-empty AND issue_state has critical issues:
-  - Print: "Note: Blockers are now tracked as critical issues in .workflow/issues/issues.jsonl"
-
-If accumulated_context.deferred is non-empty:
-  - Print: "Note: Deferred items are tracked as deferred issues. Use /manage-issue list --status deferred"
-
-Else (issue_state is null):
-  - Print: "ISSUES: No issues tracked. Use /manage-issue create or /maestro-verify to discover issues."
+If issue_state is null: "No issues tracked. Use /manage-issue create or /maestro-verify to discover issues."
 
 Status icons:
 - `[x]` completed
@@ -193,36 +89,9 @@ Status icons:
 ### Step 4.2: Render Worktree Status
 
 ```
-IF file_exists(".workflow/worktree-scope.json"):
-  // Running inside a worktree
-  Read .workflow/worktree-scope.json → scope
-  Display:
-    ┌─────────────────────────────────────────┐
-    │ WORKTREE MODE                           │
-    ├─────────────────────────────────────────┤
-    │ Milestone: {scope.milestone}            │
-    │ Branch:    {scope.branch}               │
-    │ Phases:    {scope.owned_phases}         │
-    │ Main:      {scope.main_worktree}        │
-    └─────────────────────────────────────────┘
-
-ELSE IF file_exists(".workflow/worktrees.json"):
-  // Running in main worktree with active worktrees
-  Read .workflow/worktrees.json → registry
-  activeWorktrees = registry.worktrees.filter(w => w.status === "active")
-
-  IF activeWorktrees.length > 0:
-    Display:
-      ┌─────────────────────────────────────────┐
-      │ ACTIVE WORKTREES                        │
-      ├─────────────────────────────────────────┤
-      {for each wt in activeWorktrees}
-      │ {wt.milestone} | {wt.branch} | {wt.path} │
-      {/for}
-      │                                         │
-      │ Sync:  /maestro-fork <milestone> --sync │
-      │ Merge: /maestro-merge <milestone>       │
-      └─────────────────────────────────────────┘
+If .workflow/worktree-scope.json exists → WORKTREE MODE panel: milestone, branch, owned_phases, main_worktree
+Else if .workflow/worktrees.json has active entries → ACTIVE WORKTREES panel: milestone/branch/path per worktree,
+  with sync (/maestro-fork --sync) and merge (/maestro-merge) hints
 ```
 
 ---
@@ -231,49 +100,38 @@ ELSE IF file_exists(".workflow/worktrees.json"):
 
 ### Step 5.0: Issue-Aware Routing
 
-If issue_state is not null, evaluate issue-based recommendations BEFORE status routing:
-
-If critical_open > 0:
-  - Recommend: "{critical_open} critical issues require attention"
-  - Suggest: Skill({ skill: "manage-issue", args: "list --severity critical" })
-  - Suggest: Skill({ skill: "quality-debug", args: "--from-uat" })
-
-If by_status.diagnosed > 0:
-  - Recommend: "{diagnosed} issues diagnosed and ready for planning"
-  - Suggest: Skill({ skill: "maestro-plan", args: "--gaps" })
-
-If by_status.registered > 0:
-  - Recommend: "{registered} new issues need investigation"
-  - Suggest: Skill({ skill: "quality-debug" })
+If issue_state exists, evaluate BEFORE status routing:
+- critical_open > 0 → suggest manage-issue list --severity critical, quality-debug --from-uat
+- diagnosed > 0 → suggest maestro-plan --gaps
+- registered > 0 → suggest quality-debug
 
 ### Step 5.1: Status-Based Routing
 
-Based on current project status, suggest the next command:
-
-```
-STATUS ROUTING TABLE:
--------------------------------------------------------------
-Current Status    | Suggested Command           | Reason
--------------------------------------------------------------
-idle              | /workflow:init              | Project needs initialization
-exploring         | /maestro-analyze -q        | Continue exploration, lock decisions
-                  | /workflow:plan {phase}      | Ready to plan
-planning          | /workflow:plan {phase}      | Resume planning
-executing         | /workflow:execute {phase}   | Resume execution
-verifying         | /workflow:verify {phase}    | Complete verification
-                  | /workflow:review {phase}    | Code quality review
-                  | /workflow:test {phase}      | Run tests
-reviewing         | /workflow:review {phase}    | Complete review
-testing           | /workflow:test {phase}      | Complete testing
-completed (phase) | /workflow:phase-transition  | Move to next phase
-completed (all)   | /workflow:milestone-audit   | Audit milestone
-blocked           | /workflow:debug             | Resolve blockers
--------------------------------------------------------------
-```
+Based on current project state, suggest the next command:
+
+| Current State | Suggested Command |
+|---|---|
+| No phases planned | /maestro-brainstorm 1 or /maestro-plan 1 |
+| Phase pending, needs analysis | /maestro-analyze \<N\> |
+| Phase pending, needs decisions | /maestro-analyze \<N\> -q |
+| Phase planned, not executed | /maestro-execute \<N\> |
+| Phase executing, tasks blocked | /quality-debug \<N\> |
+| Phase executed, not verified | /maestro-verify \<N\> |
+| Phase verified with gaps | /maestro-plan \<N\> --gaps |
+| Phase verified, not reviewed | /quality-review \<N\> |
+| Phase reviewed, BLOCK verdict | /maestro-plan \<N\> --gaps |
+| Phase reviewed, PASS/WARN | /quality-test \<N\> |
+| Low test coverage | /quality-test-gen \<N\> |
+| UAT passed, all phases done | /maestro-milestone-audit |
+| UAT has failures | /quality-debug --from-uat \<N\> |
+| Need integration tests | /quality-integration-test \<N\> |
+| All milestone phases complete | /maestro-milestone-audit |
+| Milestone audit passed | /maestro-milestone-complete |
+| Ad-hoc small task | /maestro-quick \<task\> |
 
 Display:
 ```
-NEXT STEP: /workflow:{suggested_command}
+NEXT STEP: {suggested_command}
   {reason}
 ```
 

package/workflows/sync.md

@@ -27,42 +27,24 @@ Change detection, impact chain traversal, and codebase documentation synchroniza
 ### Step 1: Parse Input and Validate
 
 ```
-Parse $ARGUMENTS for flags:
-  --full = complete resync mode (process all tracked files)
-  --since <ref> = diff since specific commit or ref
-  --dry-run = preview mode, no writes
-  No flags = incremental sync since last tracked sync point
-
-Verify .workflow/ directory exists.
-  If not initialized: abort with E001.
+Parse flags: --full (resync all), --since <ref> (diff baseline), --dry-run (preview)
+Default: incremental sync since last tracked sync point
+Require .workflow/ exists → else abort E001
 ```
 
 ### Step 2: Detect Changed Files
 
 ```
-If --full flag:
-  Collect all files tracked in doc-index.json code_locations as changed_files[]
-
-Else:
-  Run: git diff --name-only <since-ref>
-    If --since not provided: git diff --name-only HEAD~1
-    If no prior commit: git diff --name-only --cached
-
-  Output: changed_files[] — list of file paths that changed
-
-If no files changed: emit W001 ("No changes detected") and exit.
+--full → collect all files from doc-index.json code_locations
+else  → git diff --name-only <since-ref|HEAD~1|--cached>
+No files changed → emit W001, exit
 ```
 
 ### Step 3: Load Doc Index
 
 ```
-Read: .workflow/codebase/doc-index.json
-
-Extract:
-  - components[] (with code_locations, feature_ids, symbols)
-  - features[] (with component_ids, requirement_ids)
-  - requirements[]
-  - architecture_decisions[]
+Read .workflow/codebase/doc-index.json
+Extract: components[], features[], requirements[], architecture_decisions[]
 ```
 
 ### Step 4: Impact Chain Traversal
@@ -70,150 +52,55 @@ Extract:
 For each `changed_file` in `changed_files[]`:
 
 ```
-a. Find matching components:
-   Filter components where code_locations[] contains changed_file
-   (use path matching — file may be relative or absolute)
-
-b. From components -> find features:
-   For each matched component:
-     Collect feature_ids from the component entry
-     OR: Find features where component_ids[] contains the component.id
-
-c. From features -> find requirements:
-   For each matched feature:
-     Collect requirement_ids from the feature entry
-     OR: Find requirements where feature_id matches
-
-d. Aggregate all affected:
-   affected = {
-     files: [changed_file],
-     components: [unique component entries],
-     features: [unique feature entries],
-     requirements: [unique requirement entries]
-   }
+Traverse impact chain: file → components (via code_locations match)
+  → features (via component.feature_ids) → requirements (via feature.requirement_ids)
+Aggregate deduplicated: { files, components, features, requirements }
 ```
 
-Deduplicate across all changed files to build the total impact set.
-
 ### Step 5: Update Doc Index (skip if --dry-run)
 
 ```
-For each affected component in doc-index.json:
-  Update last_updated timestamp
-  Re-scan code_locations to refresh symbols[] if the component's files changed
-    - Read each code_location file
-    - Extract exported symbols (classes, functions, interfaces, types, constants)
-    - Update symbols[] array
-
-For each affected feature in doc-index.json:
-  Update last_updated timestamp
-  Update status if needed (based on component changes)
-
+Affected components → refresh last_updated, re-scan code_locations for exported symbols[]
+Affected features   → refresh last_updated, update status from component changes
 Write updated doc-index.json
 ```
 
 ### Step 6: Regenerate Affected Docs (skip if --dry-run)
 
 ```
-For each affected component:
-  Regenerate .workflow/codebase/tech-registry/{component-slug}.md
-  Content template:
-    # {component.name}
-    - **ID**: {component.id}
-    - **Type**: {component.type}
-    - **Code Locations**: {code_locations joined}
-    - **Features**: {feature_ids joined}
-    ## Symbols
-    {symbols as bullet list}
-    ## Last Updated
-    {timestamp}
-
-For each affected feature:
-  Regenerate .workflow/codebase/feature-maps/{feature-slug}.md
-  Content template:
-    # {feature.name}
-    - **ID**: {feature.id}
-    - **Status**: {feature.status}
-    - **Phase**: {feature.phase}
-    - **Components**: {component_ids joined}
-    - **Requirements**: {requirement_ids joined}
-    ## Component Details
-    {for each component: name, type, key symbols}
-    ## Last Updated
-    {timestamp}
+Affected components → regenerate .workflow/codebase/tech-registry/{component-slug}.md
+  Template: name, id, type, code_locations, feature_ids, symbols list, timestamp
+
+Affected features → regenerate .workflow/codebase/feature-maps/{feature-slug}.md
+  Template: name, id, status, phase, component_ids, requirement_ids, component details, timestamp
 ```
 
 ### Step 7: Update State and Specs (skip if --dry-run)
 
 ```
-Update state.json:
-  - Set last_sync timestamp to current time
-  - Record change summary (files changed, components/features affected)
-  - Update last_updated timestamp
-
-Update index.json:
-  - For each affected phase (if phase-scoped files changed), update the phase index
+state.json → set last_sync timestamp, record change summary, update last_updated
+index.json → update affected phase indexes
 
-Check if changes warrant spec updates:
-  - If patterns or conventions changed: append learnings to relevant spec files
-  - If new architectural patterns emerged: note in appropriate spec
-  - Skip if no spec-relevant changes detected
+Spec updates: if patterns/conventions changed → append learnings to relevant spec files
 
-Check if dependency manifests changed (project.md Tech Stack refresh):
-  dependency_files = ["package.json", "go.mod", "pyproject.toml", "Cargo.toml",
-                      "requirements.txt", "pom.xml", "build.gradle", "Gemfile"]
-  changed_deps = changed_files.filter(f => dependency_files.includes(basename(f)))
-  If changed_deps.length > 0 AND .workflow/project.md exists:
-    Re-scan dependency manifests for current tech stack
-    Update .workflow/project.md Tech Stack section with detected changes
-    Display: "project.md: Tech Stack refreshed from {changed_deps.join(', ')}"
+Dependency manifest check (package.json, go.mod, pyproject.toml, Cargo.toml,
+  requirements.txt, pom.xml, build.gradle, Gemfile):
+  If any changed AND .workflow/project.md exists → refresh Tech Stack section
 ```
 
 ### Step 8: Create Action Log
 
 ```
-Determine action hash:
-  git rev-parse --short HEAD (or use the since-ref hash)
-
+hash = git rev-parse --short HEAD (or since-ref)
 Write .workflow/codebase/action-logs/{hash}.md:
-
-  # Changes in {hash}
-
-  **Date**: {ISO timestamp}
-  **Sync Baseline**: {since-ref}
-
-  ## Files Changed
-  {bullet list of changed_files}
-
-  ## Components Affected
-  {bullet list: component.id - component.name (component.type)}
-
-  ## Features Affected
-  {bullet list: feature.id - feature.name}
-
-  ## Requirements Affected
-  {bullet list: requirement.id - requirement.title}
-
-  ## Impact Summary
-  - Files changed: {count}
-  - Components affected: {count}
-  - Features affected: {count}
-  - Requirements affected: {count}
+  Sections: date, baseline, files changed, components/features/requirements affected, impact counts
 ```
 
 ### Step 9: Report
 
-Display summary to user:
-
 ```
-Sync complete:
-  Changed files: N
-  Components affected: N (list IDs)
-  Features affected: N (list IDs)
-  Requirements affected: N (list IDs)
-  Specs updated: {list or "none"}
-  Action log: .workflow/codebase/action-logs/{hash}.md
-  If --dry-run: note that no changes were written
+Display: changed files count, affected components/features/requirements (with IDs),
+  specs updated, action log path. Note if --dry-run (no writes).
 ```
 
 ---