maestro-flow 0.3.10 → 0.3.12

package/workflows/fork.md

@@ -121,12 +121,25 @@ IF syncMode:
 ## Step 5: Validate & Confirm
 
 ```
-// Load phase index files for all milestone phases
+// Load phase status — artifact registry first, fallback to legacy phases/
 phaseList = []
-for (phaseNum of milestonePhases):
-  Glob: .workflow/phases/{NN}-*/index.json where NN matches phaseNum
-  Read index.json → phaseIndex
-  phaseList.push(phaseIndex)
+artifacts = projectState.artifacts ?? []
+useArtifactRegistry = artifacts.length > 0
+
+IF useArtifactRegistry:
+  // Derive phase status from artifact registry
+  for (phaseNum of milestonePhases):
+    execArtifacts = artifacts.filter(a => a.type === 'execute' && a.phase === phaseNum)
+    status = execArtifacts.some(a => a.status === 'completed') ? 'completed'
+           : execArtifacts.length > 0 ? 'in_progress'
+           : 'pending'
+    phaseList.push({ phase: phaseNum, title: "Phase " + phaseNum, status })
+ELSE:
+  // Legacy: load from phases/ directory
+  for (phaseNum of milestonePhases):
+    Glob: .workflow/phases/{NN}-*/index.json where NN matches phaseNum
+    Read index.json → phaseIndex
+    phaseList.push(phaseIndex)
 
 // Validate: milestone should have at least one non-completed phase
 nonCompleted = phaseList.filter(p => p.status !== "completed")
@@ -172,7 +185,7 @@ Bash("git branch -D {branch}") // ignore errors (may not exist)
 Bash("git worktree add -b {branch} {wtPath} {baseBranch}")
 
 // 6c: Create .workflow/ structure in worktree
-Bash("mkdir -p {wtPath}/.workflow/phases")
+Bash("mkdir -p {wtPath}/.workflow/scratch")
 
 // 6d: Copy shared context (read-only)
 Copy .workflow/project.md → {wtPath}/.workflow/project.md
@@ -182,46 +195,92 @@ IF file_exists(".workflow/config.json"):
 IF directory_exists(".workflow/specs"):
   Copy .workflow/specs/ → {wtPath}/.workflow/specs/
 
-// 6e: Copy ALL phase directories for this milestone
-ownedPhaseNumbers = []
-for (p of phaseList):
-  NN = String(p.phase).padStart(2, '0')
-  Copy .workflow/phases/{NN}-{p.slug}/ → {wtPath}/.workflow/phases/{NN}-{p.slug}/
-  ownedPhaseNumbers.push(p.phase)
-
-// 6f: Copy completed dependency phase dirs outside this milestone (read-only reference)
-allDeps = new Set()
-for (p of phaseList):
-  for (dep of p.depends_on):
-    IF NOT ownedPhaseNumbers.includes(dep):
-      allDeps.add(dep)
+// 6e: Copy milestone artifacts to worktree
+ownedPhaseNumbers = milestonePhases.slice()  // all phases in this milestone
 
-for (dep of allDeps):
-  depNN = String(dep).padStart(2, '0')
-  Glob: .workflow/phases/{depNN}-*/index.json
-  Read → depIndex
-  Copy .workflow/phases/{depNN}-{depIndex.slug}/ → {wtPath}/.workflow/phases/{depNN}-{depIndex.slug}/
+IF useArtifactRegistry:
+  // Copy scratch dirs for this milestone's artifacts
+  milestoneArtifacts = artifacts.filter(a =>
+    a.milestone === milestoneName && a.path
+  )
+  for (art of milestoneArtifacts):
+    IF directory_exists(".workflow/" + art.path):
+      Copy .workflow/{art.path}/ → {wtPath}/.workflow/{art.path}/
+ELSE:
+  // Legacy: copy phase directories
+  Bash("mkdir -p {wtPath}/.workflow/phases")
+  for (p of phaseList):
+    NN = String(p.phase).padStart(2, '0')
+    Copy .workflow/phases/{NN}-{p.slug}/ → {wtPath}/.workflow/phases/{NN}-{p.slug}/
+
+// 6f: Copy dependency artifacts (phases outside this milestone)
+IF useArtifactRegistry:
+  // Collect dependency phases from roadmap milestone entry
+  // (cross-milestone dependencies are defined in milestoneEntry.depends_on or roadmap)
+  depPhases = new Set()
+  IF milestoneEntry.depends_on:
+    for (dep of milestoneEntry.depends_on):
+      IF NOT ownedPhaseNumbers.includes(dep):
+        depPhases.add(dep)
+  // Copy dependency artifacts from main
+  for (dep of depPhases):
+    depArtifacts = artifacts.filter(a => a.phase === dep && a.path)
+    for (art of depArtifacts):
+      IF directory_exists(".workflow/" + art.path):
+        Copy .workflow/{art.path}/ → {wtPath}/.workflow/{art.path}/
+ELSE:
+  // Legacy: copy completed dependency phase dirs
+  allDeps = new Set()
+  for (p of phaseList):
+    IF p.depends_on:
+      for (dep of p.depends_on):
+        IF NOT ownedPhaseNumbers.includes(dep):
+          allDeps.add(dep)
+  for (dep of allDeps):
+    depNN = String(dep).padStart(2, '0')
+    Glob: .workflow/phases/{depNN}-*/index.json
+    Read → depIndex
+    Copy .workflow/phases/{depNN}-{depIndex.slug}/ → {wtPath}/.workflow/phases/{depNN}-{depIndex.slug}/
+
+// 6g: Build phase_dependencies map for worktree-scope
+phaseDeps = {}
+IF useArtifactRegistry:
+  IF milestoneEntry.depends_on:
+    for (phaseNum of ownedPhaseNumbers):
+      phaseDeps[String(phaseNum)] = milestoneEntry.depends_on
+        .filter(d => !ownedPhaseNumbers.includes(d))
+ELSE:
+  for (p of phaseList):
+    IF p.depends_on:
+      externalDeps = p.depends_on.filter(d => !ownedPhaseNumbers.includes(d))
+      IF externalDeps.length > 0:
+        phaseDeps[String(p.phase)] = externalDeps
 
-// 6g: Write worktree-scope.json
+// 6h: Write worktree-scope.json
 Write {wtPath}/.workflow/worktree-scope.json:
   {
     "worktree": true,
     "milestone_num": milestoneNum,
     "milestone": milestoneName,
     "owned_phases": ownedPhaseNumbers,
+    "phase_dependencies": phaseDeps,
     "main_worktree": resolve(cwd),
     "branch": branch,
     "base_commit": baseCommit,
     "created_at": getUtc8ISOString()
   }
 
-// 6h: Write scoped state.json
+// 6i: Write scoped state.json
 Read .workflow/state.json → mainState
 firstPending = phaseList.find(p => p.status !== "completed")
 scopedState = {
   ...mainState,
   current_phase: firstPending?.phase ?? phaseList[0].phase,
-  current_milestone: milestoneName
+  current_milestone: milestoneName,
+  // Carry over milestone-scoped artifacts to worktree
+  artifacts: useArtifactRegistry
+    ? artifacts.filter(a => a.milestone === milestoneName || ownedPhaseNumbers.includes(a.phase))
+    : []
 }
 Write {wtPath}/.workflow/state.json: scopedState
 ```
@@ -260,14 +319,20 @@ registry.fork_sessions.push({
 
 Write .workflow/worktrees.json: registry
 
-// Mark milestone phases as "forked" in main
-for (p of phaseList):
-  IF p.status !== "completed":
-    NN = String(p.phase).padStart(2, '0')
-    Read .workflow/phases/{NN}-{p.slug}/index.json → idx
-    idx.status = "forked"
-    idx.updated_at = getUtc8ISOString()
-    Write .workflow/phases/{NN}-{p.slug}/index.json: idx
+// Mark milestone phases as "forked"
+IF useArtifactRegistry:
+  // In artifact registry model, worktrees.json tracks forked state.
+  // No per-phase marking needed — the registry entry signals ownership.
+  // (worktrees.json already updated above with owned_phases)
+ELSE:
+  // Legacy: mark phase index.json as forked
+  for (p of phaseList):
+    IF p.status !== "completed":
+      NN = String(p.phase).padStart(2, '0')
+      Read .workflow/phases/{NN}-{p.slug}/index.json → idx
+      idx.status = "forked"
+      idx.updated_at = getUtc8ISOString()
+      Write .workflow/phases/{NN}-{p.slug}/index.json: idx
 
 mainState.last_updated = getUtc8ISOString()
 Write .workflow/state.json: mainState
@@ -295,7 +360,6 @@ Display:
     /maestro-plan {firstPending.phase}
     /maestro-execute {firstPending.phase}
     /maestro-verify {firstPending.phase}
-    /maestro-phase-transition {firstPending.phase}
     # ... repeat for next phases in milestone
 
   Or delegate (automated):