maestro-flow 0.3.12 → 0.3.13

package/workflows/fork.md

@@ -121,25 +121,17 @@ IF syncMode:
 ## Step 5: Validate & Confirm
 
 ```
-// Load phase status — artifact registry first, fallback to legacy phases/
+// Load phase status from artifact registry
 phaseList = []
 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)
+
+// 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 })
 
 // Validate: milestone should have at least one non-completed phase
 nonCompleted = phaseList.filter(p => p.status !== "completed")
@@ -198,63 +190,35 @@ IF directory_exists(".workflow/specs"):
 // 6e: Copy milestone artifacts to worktree
 ownedPhaseNumbers = milestonePhases.slice()  // all phases in this milestone
 
-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}/
+// 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}/
 
 // 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}/
+// 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}/
 
 // 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
+IF milestoneEntry.depends_on:
+  for (phaseNum of ownedPhaseNumbers):
+    phaseDeps[String(phaseNum)] = milestoneEntry.depends_on
+      .filter(d => !ownedPhaseNumbers.includes(d))
 
 // 6h: Write worktree-scope.json
 Write {wtPath}/.workflow/worktree-scope.json:
@@ -275,12 +239,9 @@ Read .workflow/state.json → mainState
 firstPending = phaseList.find(p => p.status !== "completed")
 scopedState = {
   ...mainState,
-  current_phase: firstPending?.phase ?? phaseList[0].phase,
   current_milestone: milestoneName,
   // Carry over milestone-scoped artifacts to worktree
-  artifacts: useArtifactRegistry
-    ? artifacts.filter(a => a.milestone === milestoneName || ownedPhaseNumbers.includes(a.phase))
-    : []
+  artifacts: artifacts.filter(a => a.milestone === milestoneName || ownedPhaseNumbers.includes(a.phase))
 }
 Write {wtPath}/.workflow/state.json: scopedState
 ```
@@ -320,19 +281,9 @@ registry.fork_sessions.push({
 Write .workflow/worktrees.json: registry
 
 // 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
+// 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)
 
 mainState.last_updated = getUtc8ISOString()
 Write .workflow/state.json: mainState

package/workflows/init.md

@@ -88,7 +88,7 @@ CHECK .workflow/state.json exists?
 
 5. **Create project files:**
    - `.workflow/project.md` from @templates/project.md + user answers (include Core Value, Requirements, Key Decisions)
-   - `.workflow/state.json` from template (status: "idle", current_phase: null)
+   - `.workflow/state.json` from template (status: "idle")
    - `.workflow/config.json` already created in step 2
 
 ### Path B: Brownfield (has code, no .workflow/)
@@ -119,14 +119,12 @@ If `.workflow/specs/` does not exist:
 1. Create `.workflow/specs/` directory
 2. Auto-trigger `/workflow:specs-setup` — **MUST follow `specs-setup.md` templates exactly**:
    - Scan codebase for conventions
-   - Generate `project-tech.json`
    - Generate `specs/coding-conventions.md`
    - Generate `specs/architecture-constraints.md`
    - Generate `specs/quality-rules.md`
    - Generate `specs/debug-notes.md`
    - Generate `specs/test-conventions.md`
    - Generate `specs/review-standards.md`
-   - Generate `specs/validation-rules.md`
    - Create empty `specs/learnings.md`
 
 
@@ -143,7 +141,6 @@ Verify all required directories and files exist:
   config.json        ✓
   specs/             ✓
   research/          ✓ (if research enabled)
-  phases/            ✓ (create empty)
   scratch/           ✓ (create empty)
   milestones/        ✓ (create empty)
   codebase/          ✓ (create empty)

package/workflows/integration-test.md

@@ -15,7 +15,7 @@ L0-L3 progressive layers: Static Analysis -> Unit -> Integration -> E2E
 | Input | Result |
 |-------|--------|
 | No arguments | Error E001 |
-| Phase number | Resolve phase dir (artifact registry or legacy `.workflow/phases/{NN}-{slug}/`) |
+| Phase number | Resolve phase dir from artifact registry |
 | `--max-iter N` | Set MAX_ITER = N (default 5) |
 | `--layer L2` | Start from L2 layer |
 
@@ -23,12 +23,11 @@ L0-L3 progressive layers: Static Analysis -> Unit -> Integration -> E2E
 ```
 Read .workflow/state.json → state
 artifacts = state.artifacts ?? []
-IF artifacts.length > 0:
-  art = artifacts.find(a => a.type === 'execute' && a.phase === phaseNum)
+art = artifacts.find(a => a.type === 'execute' && a.phase === phaseNum)
+IF art:
   PHASE_DIR = ".workflow/" + art.path
 ELSE:
-  Glob: .workflow/phases/{NN}-*/
-  PHASE_DIR = resolved path
+  ERROR "Phase {phaseNum} not found in artifact registry"
 ```
 
 Check for existing integration test session:

package/workflows/issue.md

@@ -180,11 +180,8 @@ Cross-milestone conflict check (for supplement issues):
    b. Identify phases belonging to OTHER milestones (not milestone_ref)
    c. For each other-milestone phase, resolve phase dir and check if plan.json exists:
       Read .workflow/state.json → state; artifacts = state.artifacts ?? []
-      IF artifacts.length > 0:
-        art = artifacts.find(a => a.type === 'plan' && a.phase === phaseNum)
-        IF art: Read .workflow/{art.path}/plan.json (if exists)
-      ELSE:
-        Read .workflow/phases/{NN}-{slug}/plan.json (if exists)
+      art = artifacts.find(a => a.type === 'plan' && a.phase === phaseNum)
+      IF art: Read .workflow/{art.path}/plan.json (if exists)
       Collect files_to_create[] as planned_files
    d. IF affected_components in the new issue overlap with planned_files:
       WARNING: "Conflict detected: this supplement issue affects components planned in milestone {other_milestone}"
@@ -456,10 +453,7 @@ Process bidirectional link:
 2. Locate task file:
    - Read .workflow/state.json → state
    - artifacts = state.artifacts ?? []
-   - IF artifacts.length > 0:
-       Search .workflow/scratch/*/.task/{TASK_ID}.json (artifact registry scratch paths)
-     ELSE:
-       Search .workflow/phases/*/.task/{TASK_ID}.json (legacy)
+   - Search artifact registry paths: .workflow/{artifact.path}/.task/{TASK_ID}.json
    - Also search .workflow/scratch/*/.task/{TASK_ID}.json (standalone scratch tasks)
    - If still not found → error: "Task {TASK_ID} not found"
 

package/workflows/learn.md

@@ -4,7 +4,7 @@ Atomic insight capture, search, and retrieval. Lightweight gstack-style "eureka
 
 Storage:
 - `.workflow/learning/lessons.jsonl` — append-only JSONL row per insight (shared with retrospective output)
-- `.workflow/learning/learning-index.json` — searchable index (mirrors `memory-index.json` schema)
+- `.workflow/learning/learning-index.json` — searchable index (searchable index)
 
 This workflow does NOT spawn agents or call CLI tools. It is a thin file operation: parse → infer → append → confirm.
 
@@ -83,17 +83,21 @@ phase_slug = null
 
 IF .workflow/state.json exists:
   state = read JSON
-  IF state.current_phase is not null:
-    phase = state.current_phase
+  artifacts = state.artifacts ?? []
+
+  # Derive current phase from artifacts (first phase with in_progress, or first without completed execute)
+  phase = null
+  inProgressArt = artifacts.find(a => a.type === 'execute' && a.status === 'in_progress')
+  IF inProgressArt:
+    phase = inProgressArt.phase
+  ELSE:
+    phaseNums = [...new Set(artifacts.map(a => a.phase).filter(Boolean))].sort()
+    phase = phaseNums.find(p => !artifacts.some(a => a.phase === p && a.type === 'execute' && a.status === 'completed'))
 
-    # Resolve slug — artifact registry first, fallback to legacy phases/
-    artifacts = state.artifacts ?? []
-    IF artifacts.length > 0:
-      art = artifacts.find(a => a.phase === phase)
-      phase_slug = art?.slug ?? "phase-" + phase
-    ELSE:
-      Glob ".workflow/phases/{NN}-*/" where NN == phase
-      phase_slug = matched directory basename (e.g. "01-auth")
+  IF phase is not null:
+    # Resolve slug from artifact registry
+    art = artifacts.find(a => a.phase === phase)
+    phase_slug = art?.slug ?? "phase-" + phase
 ```
 
 If `--phase 0` is passed, force `phase = null, phase_slug = null` regardless.
@@ -304,15 +308,12 @@ IF row is null → error E004: "Insight {target_id} not found"
 ```
 phase_context = null
 IF row.phase_slug is not null:
-  // Resolve phase dir — artifact registry first, fallback to legacy phases/
+  // Resolve phase dir from artifact registry
   Read .workflow/state.json → state
   artifacts = state.artifacts ?? []
   phase_dir = null
-  IF artifacts.length > 0:
-    art = artifacts.find(a => a.phase === row.phase && a.path)
-    IF art: phase_dir = ".workflow/" + art.path
-  ELSE:
-    phase_dir = ".workflow/phases/" + row.phase_slug
+  art = artifacts.find(a => a.phase === row.phase && a.path)
+  IF art: phase_dir = ".workflow/" + art.path
 
   IF phase_dir AND directory exists:
     phase_context = {
@@ -382,7 +383,7 @@ PHASE CONTEXT:
 | E002 | error | Unknown `--category` (allowed: pattern, antipattern, decision, tool, gotcha, technique) |
 | E003 | error | `show` mode requires an INS-id argument |
 | E004 | error | Insight id not found in lessons.jsonl |
-| W001 | warning | Auto-phase detection found a current_phase but no matching directory; phase set to null |
+| W001 | warning | Auto-phase detection found no matching artifact in registry; phase set to null |
 | W002 | warning | learning-index.json out of sync with lessons.jsonl (different row count); offer to rebuild |
 
 ---
@@ -392,7 +393,7 @@ PHASE CONTEXT:
 - [ ] Mode correctly routed (capture / list / search / show)
 - [ ] Capture mode: `lessons.jsonl` row appended, valid JSON, all required fields present
 - [ ] Capture mode: `learning-index.json` updated with matching entry
-- [ ] Capture mode: phase auto-link resolves correctly when state.json has current_phase
+- [ ] Capture mode: phase auto-link resolves correctly from artifact registry
 - [ ] Capture mode: category inference produces a sensible default when --category absent
 - [ ] List mode: filters apply; output sorted newest-first
 - [ ] Search mode: results ranked by title > tags > summary match

package/workflows/maestro.codex.md

@@ -37,7 +37,14 @@ if (fileExists(stateFile)) {
   const raw = JSON.parse(Read(stateFile));
   projectState = {
     initialized: true,
-    current_phase: raw.current_phase,
+    // Derive current_phase from artifacts (first in_progress execute, or first without completed execute)
+    current_phase: (() => {
+      const arts = raw.artifacts ?? [];
+      const ip = arts.find(a => a.type === 'execute' && a.status === 'in_progress');
+      if (ip) return ip.phase;
+      const phases = [...new Set(arts.map(a => a.phase).filter(Boolean))].sort((a,b) => a - b);
+      return phases.find(p => !arts.some(a => a.phase === p && a.type === 'execute' && a.status === 'completed')) ?? raw.current_phase ?? null;
+    })(),
     phase_slug: raw.phase_slug,
     phase_status: raw.phase_status,   // pending|exploring|planning|executing|verifying|testing|completed|blocked
     phase_artifacts: raw.phase_artifacts ?? {},

package/workflows/maestro.md

@@ -661,8 +661,17 @@ function resolvePhase(intent_analysis, project_state) {
   const phaseMatch = intent.match(/phase\s*(\d+)|^(\d+)$/);
   if (phaseMatch) return phaseMatch[1] || phaseMatch[2];
 
-  // 3. From project state
-  if (project_state.initialized) return project_state.current_phase;
+  // 3. From project state — derive from artifacts
+  if (project_state.initialized) {
+    // Derive current phase: first phase with in_progress execute, or first without completed execute
+    const arts = project_state.artifacts ?? [];
+    const inProgress = arts.find(a => a.type === 'execute' && a.status === 'in_progress');
+    if (inProgress) return inProgress.phase;
+    const phases = [...new Set(arts.map(a => a.phase).filter(Boolean))].sort((a,b) => a - b);
+    const current = phases.find(p => !arts.some(a => a.phase === p && a.type === 'execute' && a.status === 'completed'));
+    if (current) return current;
+    return project_state.latest_artifact?.phase ?? null;
+  }
 
   // 4. Scratch mode chains use {scratch_dir} instead of {phase}
   if (chainName === 'analyze-plan-execute') return null;
@@ -775,7 +784,7 @@ mkdir -p "${SESSION_DIR}"
 **Initialize execution context:**
 ```javascript
 const context = {
-  current_phase: resolvedPhase,
+  current_phase: resolvedPhase,  // derived from artifacts
   user_intent: intent,
   issue_id: resolvedIssueId,
   spec_session_id: null,

package/workflows/memory.md

@@ -8,7 +8,7 @@ Two memory stores with different purposes:
 
 | Store | Path | Format | Index |
 |-------|------|--------|-------|
-| `workflow` | `.workflow/memory/` | `MEM-*.md`, `TIP-*.md` | `memory-index.json` |
+| `workflow` | `.workflow/memory/` | `MEM-*.md`, `TIP-*.md` | `.workflow/wiki-index.json` (unified, auto-managed by WikiIndexer) |
 | `system` | `~/.claude/projects/{project}/memory/` | `MEMORY.md` + topic `.md` files | None (flat files) |
 
 **System memory path detection:**
@@ -30,7 +30,7 @@ Detect both memory store paths:
 ```bash
 # Workflow memory
 WF_MEMORY_DIR=".workflow/memory"
-WF_INDEX_FILE="$WF_MEMORY_DIR/memory-index.json"
+WF_INDEX_FILE=".workflow/wiki-index.json"  # unified index (auto-managed by WikiIndexer)
 
 # System memory — derive from project git root or cwd
 PROJECT_ROOT=$(pwd)
@@ -40,7 +40,7 @@ SYS_MEMORY_DIR="$HOME/.claude/projects/$(echo "$PROJECT_ROOT" | sed 's|[/\\:]|-|
 ```
 
 Verify which stores exist:
-- Workflow: check `$WF_INDEX_FILE` exists
+- Workflow: check `.workflow/memory/` directory exists (index is auto-managed)
 - System: check `$SYS_MEMORY_DIR/MEMORY.md` exists
 
 If neither exists, report E001.
@@ -69,7 +69,7 @@ Parse arguments and detect subcommand:
 List entries from targeted stores.
 
 **Workflow store** (if exists):
-1. Read `memory-index.json`
+1. Use `maestro wiki list --type memory --json` (reads unified `.workflow/wiki-index.json`)
 2. Apply filters (--tag, --type, --before, --after)
 3. Sort by timestamp descending
 
@@ -108,7 +108,7 @@ Hints:
 Full-text search across both stores.
 
 **Workflow store:**
-1. Search `memory-index.json` fields: `summary`, `tags`, `id`
+1. Use `maestro wiki search "<query>" --json` or filter `.workflow/wiki-index.json` fields: `summary`, `tags`, `id`
 2. For deeper matches, read individual `.md` files and search content
 
 **System store:**
@@ -138,7 +138,7 @@ View: /manage-memory view <ID|filename>
 Display full content of a memory entry.
 
 **Workflow entry** (ID matches `MEM-*` or `TIP-*`):
-1. Validate ID exists in `memory-index.json`
+1. Validate ID exists via `maestro wiki get <id>` or in `.workflow/wiki-index.json`
 2. Read the corresponding `.md` file
 3. Display with metadata header
 
@@ -188,9 +188,9 @@ Changes: {summary of edits}
 Remove a memory entry or file.
 
 **Workflow entry:**
-1. Validate ID in `memory-index.json`
+1. Validate ID via `maestro wiki get <id>` or in `.workflow/wiki-index.json`
 2. Show summary, confirm with AskUserQuestion (unless --confirm)
-3. Remove `.md` file + index entry
+3. Remove `.md` file (WikiIndexer auto-updates index on next access)
 
 **System file:**
 1. Validate file exists (NEVER allow deleting MEMORY.md — only topic files)
@@ -213,7 +213,7 @@ Bulk cleanup — workflow store only.
 
 At least one filter required: --tag, --type, --before, --after.
 
-1. Read `memory-index.json`, apply filters
+1. Read `.workflow/wiki-index.json`, apply filters
 2. Display candidates table
 3. If `--dry-run`, stop after display
 4. Confirm with AskUserQuestion
@@ -232,9 +232,9 @@ Post-operation integrity check.
 
 **Workflow store:**
 1. Scan `.workflow/memory/` for `.md` files
-2. Compare with `memory-index.json` entries
+2. Compare with `.workflow/wiki-index.json` entries (type=memory)
 3. Report orphaned files or dangling references
-4. Offer to fix inconsistencies
+4. Offer to fix inconsistencies (WikiIndexer re-indexes on next write)
 
 **System store:**
 1. Check MEMORY.md links to topic files
@@ -260,13 +260,9 @@ Parse arguments and detect execution mode:
 
 ```bash
 MEMORY_DIR=".workflow/memory"
-INDEX_FILE="$MEMORY_DIR/memory-index.json"
 mkdir -p "$MEMORY_DIR"
-
-# Initialize index if not exists
-if [ ! -f "$INDEX_FILE" ]; then
-  echo '{"entries":[],"_metadata":{"created":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","version":"1.0"}}' > "$INDEX_FILE"
-fi
+# Note: wiki-index.json is auto-managed by WikiIndexer at .workflow/wiki-index.json
+# No manual index initialization needed
 ```
 
 When ambiguous, use AskUserQuestion:
@@ -355,36 +351,14 @@ Write entry file with sections:
 - Tags (from --tag flag)
 - Context (auto-detected from recent conversation files)
 
-### Step 4: Update Index
-
-Append entry metadata to memory-index.json.
-
-Read `memory-index.json`, append new entry to `entries[]`:
+### Step 4: Wiki Index (Auto-managed)
 
-```json
-{
-  "id": "MEM-20260315-143022",
-  "type": "compact",
-  "timestamp": "2026-03-15T14:30:22Z",
-  "file": "MEM-20260315-143022.md",
-  "summary": "Session objective in one line",
-  "tags": [],
-  "project_root": "/path/to/project",
-  "session_id": "WFS-001"
-}
-```
+Memory files are automatically indexed by WikiIndexer into the unified `.workflow/wiki-index.json`. No manual index update is needed — the persistent index is regenerated on next `maestro wiki` access or any write operation.
 
-For tips:
-```json
-{
-  "id": "TIP-20260315-143022",
-  "type": "tip",
-  "timestamp": "2026-03-15T14:30:22Z",
-  "file": "TIP-20260315-143022.md",
-  "summary": "First 80 chars of note content",
-  "tags": ["config", "redis"],
-  "project_root": "/path/to/project"
-}
+For immediate visibility after capture:
+```bash
+maestro wiki get memory-{slug}         # verify entry exists in wiki
+maestro wiki list --type memory        # list all memory entries
 ```
 
 ### Step 5: Report
@@ -400,7 +374,7 @@ Type:    compact
 Plan:    {plan_source} ({plan_line_count} lines preserved)
 
 To restore: Read .workflow/memory/{ENTRY_ID}.md
-To search:  Read .workflow/memory/memory-index.json
+To search:  maestro wiki list --type memory
 ```
 
 **Tip mode:**
@@ -410,33 +384,14 @@ Entry:   {ENTRY_ID}
 File:    .workflow/memory/{ENTRY_ID}.md
 Tags:    {tags}
 
-To search: Read .workflow/memory/memory-index.json
+To search: maestro wiki list --type memory --tag {tags}
 ```
 
 ---
 
-## Index Schema
-
-```json
-{
-  "entries": [
-    {
-      "id": "MEM-20260315-143022",
-      "type": "compact | tip",
-      "timestamp": "2026-03-15T14:30:22Z",
-      "file": "MEM-20260315-143022.md",
-      "summary": "One-line description",
-      "tags": [],
-      "project_root": "D:\\project",
-      "session_id": "WFS-001 | null"
-    }
-  ],
-  "_metadata": {
-    "created": "2026-03-15T00:00:00Z",
-    "version": "1.0"
-  }
-}
-```
+## Index
+
+Memory entries are indexed in the unified `.workflow/wiki-index.json` by WikiIndexer. Each memory file becomes a wiki entry of type `memory` with fields derived from frontmatter (id, title, tags, summary). Use `maestro wiki list --type memory --json` to query the index programmatically.
 
 ## Compact Entry Structure
 
@@ -492,5 +447,5 @@ Quick note for ideas, snippets, reminders.
 
 ## Retrieval
 
-Read `.workflow/memory/memory-index.json` to find entries by type, tags, or date.
-Read individual `.md` files for full content.
+Use `maestro wiki list --type memory` to find entries by type, tags, or date.
+Use `maestro wiki get <id>` or read individual `.md` files for full content.