@orchestrator-claude/cli 3.0.1 → 3.1.0

package/templates/base/claude/agents/code-archaeologist.md

@@ -496,7 +496,7 @@ Se ferramenta nao instalada: SKIP (nao e blocker)
 4. MUST sanitize ALL secrets in outputs (replace with `***REDACTED***`)
 5. MUST classify findings by severity (CRITICAL/HIGH/MEDIUM/LOW)
 6. MUST generate all 3 artifacts (analysis-report, dead-code-report, tech-debt)
-7. MUST update orchestrator-index.json after completion
+7. MUST return structured output to CLI for state update (workflow state managed via PostgreSQL)
 8. MUST create checkpoint after analysis complete
 
 ### MUST NOT (Forbidden)
@@ -561,50 +561,9 @@ After completing ANALYZE phase:
    - `.orchestrator/artifacts/legacy-analysis/{workflowId}/dead-code-report.md`
    - `.orchestrator/artifacts/legacy-analysis/{workflowId}/tech-debt.md`
 
-2. Update orchestrator-index.json:
-   ```json
-   {
-     "activeWorkflow": {
-       "currentPhase": "analyze",
-       "status": "completed"
-     },
-     "artifacts": [
-       {
-         "id": "art-analyze-001",
-         "type": "analysis-report",
-         "path": ".orchestrator/artifacts/legacy-analysis/{workflowId}/analysis-report.md",
-         "status": "completed",
-         "createdAt": "{timestamp}",
-         "phase": "analyze",
-         "findingsCount": {
-           "critical": 2,
-           "high": 8,
-           "medium": 15,
-           "low": 23
-         }
-       },
-       {
-         "id": "art-analyze-002",
-         "type": "dead-code-report",
-         "path": ".orchestrator/artifacts/legacy-analysis/{workflowId}/dead-code-report.md",
-         "status": "completed",
-         "createdAt": "{timestamp}",
-         "phase": "analyze",
-         "deadCodeLOC": 12450,
-         "percentageOfCodebase": 23
-       },
-       {
-         "id": "art-analyze-003",
-         "type": "tech-debt",
-         "path": ".orchestrator/artifacts/legacy-analysis/{workflowId}/tech-debt.md",
-         "status": "completed",
-         "createdAt": "{timestamp}",
-         "phase": "analyze",
-         "estimatedEffort": "320h"
-       }
-     ]
-   }
-   ```
+2. Return structured output to CLI for state update:
+
+   Artifacts are automatically registered in PostgreSQL when stored via MCP `artifactStore` tool. The CLI will use MCP tools to update workflow state after artifact storage.
 
 3. Create checkpoint (MANDATORY after ANALYZE):
    ```
@@ -701,7 +660,7 @@ Before claiming phase complete, MUST provide evidence:
 - [ ] tech-debt.md generated using template
 - [ ] All findings classified by severity
 - [ ] All artifacts saved to correct paths
-- [ ] orchestrator-index.json updated
+- [ ] Structured output returned to CLI for state update
 - [ ] Checkpoint created
 
 **FORBIDDEN**: Claiming completion without generating all 3 artifacts.

package/templates/base/claude/agents/implementer.md

@@ -303,23 +303,9 @@ npm run build  # PASSOU
 
 **ATENCAO:** Alem de implementar codigo, voce DEVE manter a governanca do workflow.
 
-### 1. Atualizar orchestrator-index.json
-
-Apos **CADA TAREFA** completada, atualize o arquivo `.orchestrator/orchestrator-index.json`:
-
-```json
-{
-  "activeWorkflow": {
-    "currentPhase": "implement",
-    "status": "in_progress"
-  },
-  "implementation": {
-    "completedTasks": [/* IDs das tasks completas */],
-    "currentTask": "TASK-XXX",
-    "progress": "X/Y tasks"
-  }
-}
-```
+### 1. Return Structured Output for Task Progress
+
+After **EACH TASK** completed, return structured output to the CLI with task completion status. The CLI will use MCP tools to update workflow state in PostgreSQL (workflow state managed via PostgreSQL).
 
 ### 2. Criar Checkpoints
 
@@ -334,8 +320,7 @@ Parametros:
 
 ### 3. Gerar implementation-report.md
 
-Ao **FINALIZAR TODAS AS TAREFAS**, crie o artefato em:
-`.orchestrator/artifacts/implement/implementation-report.md`
+Ao **FINALIZAR TODAS AS TAREFAS**, crie o artefato e persista via MCP tool `artifactStore` (phase: implement).
 
 Formato obrigatorio:
 ```markdown
@@ -381,66 +366,28 @@ Validacao:
 - [ ] Build sem erros
 ```
 
-### 4. Registrar Artefato em orchestrator-index.json
-
-Adicione o artefato ao array `artifacts`:
-
-```json
-{
-  "artifacts": [
-    {
-      "id": "art-XXX",
-      "type": "implementation",
-      "path": ".orchestrator/artifacts/implement/implementation-report.md",
-      "status": "completed",
-      "createdAt": "{timestamp}",
-      "workflowId": "{workflowId}",
-      "phase": "implement"
-    }
-  ]
-}
-```
+### 4. Artifact Registration (automatic via MCP tools)
 
-### 5. Atualizar Gates
+**Note**: The artifact will be automatically registered in PostgreSQL by the domain layer when you use `artifactStore`. Sub-agents MUST NOT edit `.orchestrator/orchestrator-index.json` directly.
 
-Ao finalizar, atualize o gate da fase implement:
+### 5. Return Structured Output for Final State
 
-```json
-{
-  "gates": {
-    "implement": {
-      "passed": true,
-      "evaluatedAt": "{timestamp}"
-    }
-  }
-}
-```
-
-### 6. Atualizar Status Final
-
-Ao completar TODAS as tarefas:
-
-```json
-{
-  "activeWorkflow": {
-    "currentPhase": "completed",
-    "status": "completed",
-    "completedAt": "{timestamp}"
-  }
-}
-```
+Ao finalizar todas as tarefas, return structured output to the CLI indicating completion. The CLI will use MCP tools to update workflow state in PostgreSQL:
+- Phase gate: implement.passed = true
+- Workflow status: "completed"
+- Completion timestamp
 
 ### Checklist de Governanca (OBRIGATORIO)
 
 Antes de considerar a fase IMPLEMENT finalizada:
 
 - [ ] Todas as tarefas do tasks.md implementadas
-- [ ] orchestrator-index.json atualizado com progresso
+- [ ] Structured output returned to CLI for state update
 - [ ] Checkpoints criados a cada grupo de tarefas
-- [ ] implementation-report.md criado
-- [ ] Artefato registrado em artifacts[]
-- [ ] Gate implement.passed = true
-- [ ] Status do workflow = "completed"
+- [ ] implementation-report.md persistido via MCP tool `artifactStore`
+- [ ] Artefato automaticamente registrado em PostgreSQL pelo domain layer
+- [ ] Gate implement.passed = true (updated via CLI)
+- [ ] Status do workflow = "completed" (updated via CLI)
 - [ ] Testes passando (npm run test)
 - [ ] Coverage >= 80% (npm run test:coverage)
 - [ ] Build sem erros (npm run build)

package/templates/base/claude/agents/legacy-discoverer.md

@@ -364,7 +364,7 @@ LOW:
 4. MUST generate inventory.json validated against schema
 5. MUST sanitize secrets in all outputs (replace with `***REDACTED***`)
 6. MUST catalog >= 95% of assets vs reality (if pattern set is good)
-7. MUST update orchestrator-index.json after completion
+7. MUST return structured output to CLI for state update (workflow state managed via PostgreSQL)
 8. MUST classify findings by severity (CRITICAL/HIGH/MEDIUM/LOW)
 
 ### MUST NOT (Forbidden)
@@ -424,25 +424,9 @@ After completing DISCOVER phase:
 1. Save discovery-report.md to:
    `.orchestrator/artifacts/legacy-analysis/{workflowId}/discovery-report.md`
 
-2. Update orchestrator-index.json:
-   ```json
-   {
-     "activeWorkflow": {
-       "currentPhase": "discover",
-       "status": "completed"
-     },
-     "artifacts": [
-       {
-         "id": "art-discover-001",
-         "type": "discovery-report",
-         "path": ".orchestrator/artifacts/legacy-analysis/{workflowId}/discovery-report.md",
-         "status": "completed",
-         "createdAt": "{timestamp}",
-         "phase": "discover"
-       }
-     ]
-   }
-   ```
+2. Return structured output to CLI for state update:
+
+   Artifacts are automatically registered in PostgreSQL when stored via MCP `artifactStore` tool. The CLI will use MCP tools to update workflow state after artifact storage.
 
 After completing INVENTORY phase:
 
@@ -452,27 +436,9 @@ After completing INVENTORY phase:
 2. Validate against schema:
    `.orchestrator/templates/legacy/inventory.json.schema`
 
-3. Update orchestrator-index.json:
-   ```json
-   {
-     "activeWorkflow": {
-       "currentPhase": "inventory",
-       "status": "completed"
-     },
-     "artifacts": [
-       {
-         "id": "art-inventory-001",
-         "type": "inventory",
-         "path": ".orchestrator/artifacts/legacy-analysis/{workflowId}/inventory.json",
-         "status": "completed",
-         "createdAt": "{timestamp}",
-         "phase": "inventory",
-         "validated": true,
-         "schema": ".orchestrator/templates/legacy/inventory.json.schema"
-       }
-     ]
-   }
-   ```
+3. Return structured output to CLI for state update:
+
+   Artifacts are automatically registered in PostgreSQL when stored via MCP `artifactStore` tool. The CLI will use MCP tools to update workflow state after artifact storage.
 
 4. Create checkpoint (MANDATORY after INVENTORY):
    ```
@@ -554,7 +520,7 @@ Before claiming phase complete, MUST provide evidence:
 - [ ] Red flags classified by severity
 - [ ] Secrets sanitized (if any found)
 - [ ] Artifact saved to correct path
-- [ ] orchestrator-index.json updated
+- [ ] Structured output returned to CLI for state update
 
 ### INVENTORY Phase Checklist
 
@@ -564,7 +530,7 @@ Before claiming phase complete, MUST provide evidence:
 - [ ] >= 95% asset coverage vs reality
 - [ ] JSON is valid and parseable
 - [ ] Artifact saved to correct path
-- [ ] orchestrator-index.json updated
+- [ ] Structured output returned to CLI for state update
 - [ ] Checkpoint created
 
 **FORBIDDEN**: Claiming completion without evidence.

package/templates/base/claude/agents/legacy-synthesizer.md

@@ -959,7 +959,7 @@ This analysis followed the **RFC-004 Legacy Analysis Workflow** with 6 phases:
 5. MUST identify quick wins (high impact, low effort)
 6. MUST document risks with probability, impact, and mitigations
 7. MUST generate all 3 final artifacts (migration-roadmap, architecture-proposal, final-report)
-8. MUST update orchestrator-index.json after completion
+8. MUST return structured output to CLI for state update (workflow state managed via PostgreSQL)
 9. MUST create final checkpoint after RECOMMEND phase complete
 
 ### MUST NOT (Forbidden)
@@ -1003,48 +1003,9 @@ After completing RECOMMEND phase:
    - `.orchestrator/artifacts/legacy-analysis/{workflowId}/architecture-proposal.md`
    - `.orchestrator/artifacts/legacy-analysis/{workflowId}/final-report.md`
 
-2. Update orchestrator-index.json:
-   ```json
-   {
-     "activeWorkflow": {
-       "currentPhase": "recommend",
-       "status": "completed",
-       "completedAt": "{timestamp}"
-     },
-     "artifacts": [
-       {
-         "id": "art-recommend-001",
-         "type": "migration-roadmap",
-         "path": ".orchestrator/artifacts/legacy-analysis/{workflowId}/migration-roadmap.md",
-         "status": "completed",
-         "createdAt": "{timestamp}",
-         "phase": "recommend",
-         "strategy": "strangler-fig",
-         "totalEffort": "1020-1530h",
-         "phases": 7
-       },
-       {
-         "id": "art-recommend-002",
-         "type": "architecture-proposal",
-         "path": ".orchestrator/artifacts/legacy-analysis/{workflowId}/architecture-proposal.md",
-         "status": "completed",
-         "createdAt": "{timestamp}",
-         "phase": "recommend",
-         "targetArchitecture": "modular-monolith"
-       },
-       {
-         "id": "art-recommend-003",
-         "type": "final-report",
-         "path": ".orchestrator/artifacts/legacy-analysis/{workflowId}/final-report.md",
-         "status": "completed",
-         "createdAt": "{timestamp}",
-         "phase": "recommend",
-         "totalArtifacts": 12,
-         "totalIssues": 48
-       }
-     ]
-   }
-   ```
+2. Return structured output to CLI for state update:
+
+   Artifacts are automatically registered in PostgreSQL when stored via MCP `artifactStore` tool. The CLI will use MCP tools to update workflow state after artifact storage.
 
 3. Create final checkpoint (MANDATORY):
    ```
@@ -1054,15 +1015,7 @@ After completing RECOMMEND phase:
      - description: "Complete RECOMMEND phase - {strategy} strategy, {X} phases, {Y}h effort"
    ```
 
-4. Mark workflow as completed:
-   ```json
-   {
-     "activeWorkflow": {
-       "status": "completed",
-       "completedAt": "{timestamp}"
-     }
-   }
-   ```
+4. CLI will mark workflow as completed via MCP tools → PostgreSQL
 
 ## Verification Before Completion
 
@@ -1082,9 +1035,9 @@ Before claiming phase complete, MUST provide evidence:
 - [ ] architecture-proposal.md generated
 - [ ] final-report.md generated using template
 - [ ] All 3 artifacts saved to correct paths
-- [ ] orchestrator-index.json updated
+- [ ] Structured output returned to CLI for state update
 - [ ] Final checkpoint created
-- [ ] Workflow marked as completed
+- [ ] Workflow marked as completed (via CLI)
 
 **FORBIDDEN**: Claiming completion without reading ALL artifacts or generating ALL 3 final artifacts.
 

package/templates/base/claude/agents/orchestrator.md

@@ -83,12 +83,12 @@ The role: **Choose actions using MCP tools, delegate artifact creation to specia
 **CRITICAL: Violating these rules breaks checkpoints, metrics, and recovery.**
 
 You MUST NOT:
-- Use Edit/Write tools on `orchestrator-index.json` (MCP tools manage state)
+- Use Edit/Write tools on `.orchestrator/orchestrator-index.json` (workflow state managed via PostgreSQL)
 - Use Edit/Write tools to create artifacts (subagents create them)
 - Spawn subagents internally via Task tool (use executeAction instead)
 - Execute multiple phases in a single invocation
 - Skip MCP tools for "efficiency"
-- Update `agentInvocations` or `checkpoints` arrays manually
+- Attempt to manually update workflow state (MCP tools → REST API → PostgreSQL)
 
 **WHY:** The deterministic layer (MCP tools) triggers:
 - Auto-checkpoints after artifact approval
@@ -111,7 +111,7 @@ getContext() → executeAction("advance_to_specify") → RETURN
 getContext() → executeAction("advance_to_specify") → Task(specifier) ← WRONG!
 ```
 
-The CLI reads `pendingAction` from orchestrator-index.json and invokes the appropriate agent. Your job is to SET the pendingAction via executeAction(), not to execute it yourself.
+The CLI reads `pendingAction` via MCP tools (PostgreSQL) and invokes the appropriate agent. Your job is to SET the pendingAction via executeAction(), not to execute it yourself.
 
 ## Example Flow
 
@@ -124,7 +124,7 @@ User: "Create OAuth2 API"
 5. **RETURN** ← You stop here! CLI handles the rest.
 
 **What happens next (NOT your responsibility):**
-- CLI reads pendingAction from orchestrator-index.json
+- CLI reads pendingAction via MCP tools (PostgreSQL)
 - CLI invokes specifier agent
 - Specifier creates spec.md
 - CLI invokes orchestrator again for next phase

package/templates/base/claude/agents/planner.md

@@ -275,29 +275,11 @@ O artefato deve:
 
 **ATENCAO:** Alem de gerar o artefato, voce DEVE manter a governanca do workflow.
 
-### 1. Registrar Artefato em orchestrator-index.json
-
-Apos criar o `plan.md`, atualize `.orchestrator/orchestrator-index.json`:
-
-```json
-{
-  "activeWorkflow": {
-    "currentPhase": "plan",
-    "status": "in_progress"
-  },
-  "artifacts": [
-    {
-      "id": "art-XXX",
-      "type": "plan",
-      "path": ".orchestrator/artifacts/plan/plan.md",
-      "status": "draft",
-      "createdAt": "{timestamp}",
-      "workflowId": "{workflowId}",
-      "phase": "plan"
-    }
-  ]
-}
-```
+### 1. Artifact Registration (automatic via MCP tools)
+
+Artifacts are automatically registered in PostgreSQL when stored via MCP `artifactStore` tool. Sub-agents MUST NOT edit `.orchestrator/orchestrator-index.json` directly.
+
+The CLI will use MCP tools to update workflow state in PostgreSQL after artifact storage.
 
 ### 2. Validar Artefato
 
@@ -321,28 +303,17 @@ Parametros:
   - description: "Complete PLAN phase - [nome da feature]"
 ```
 
-### 4. Atualizar Gate
+### 4. Return Structured Output
 
-Atualize o gate da fase plan:
-
-```json
-{
-  "gates": {
-    "plan": {
-      "passed": true,
-      "evaluatedAt": "{timestamp}"
-    }
-  }
-}
-```
+Return structured output to the CLI for state update. The CLI will use MCP tools to update the phase gate in PostgreSQL.
 
 ### Checklist de Governanca (OBRIGATORIO)
 
 Antes de considerar a fase PLAN finalizada:
 
 - [ ] plan.md criado em .orchestrator/artifacts/plan/
-- [ ] Artefato registrado em orchestrator-index.json
+- [ ] Structured output returned to CLI for state update
 - [ ] Validacao executada via artifact-validator
 - [ ] Status do artefato = "validated"
 - [ ] Checkpoint criado via MCP
-- [ ] Gate plan.passed = true
+- [ ] Gate plan.passed = true (updated via CLI)

package/templates/base/claude/agents/researcher.md

@@ -301,29 +301,11 @@ Limites de uso:
 
 **ATENCAO:** Alem de gerar o artefato, voce DEVE manter a governanca do workflow.
 
-### 1. Registrar Artefato em orchestrator-index.json
-
-Apos criar o `research-context.md`, atualize `.orchestrator/orchestrator-index.json`:
-
-```json
-{
-  "activeWorkflow": {
-    "currentPhase": "research",
-    "status": "in_progress"
-  },
-  "artifacts": [
-    {
-      "id": "art-XXX",
-      "type": "research",
-      "path": ".orchestrator/artifacts/research/research-context.md",
-      "status": "completed",
-      "createdAt": "{timestamp}",
-      "workflowId": "{workflowId}",
-      "phase": "research"
-    }
-  ]
-}
-```
+### 1. Artifact Registration (automatic via MCP tools)
+
+Artifacts are automatically registered in PostgreSQL when stored via MCP `artifactStore` tool. Sub-agents MUST NOT edit `.orchestrator/orchestrator-index.json` directly.
+
+The CLI will use MCP tools to update workflow state in PostgreSQL after artifact storage.
 
 ### 2. Criar Checkpoint (se pesquisa for significativa)
 
@@ -336,27 +318,16 @@ Parametros:
   - description: "Complete RESEARCH phase - [topico pesquisado]"
 ```
 
-### 3. Atualizar Gate (se fase RESEARCH for usada)
+### 3. Return Structured Output
 
-Se o workflow incluir fase RESEARCH explicita:
-
-```json
-{
-  "gates": {
-    "research": {
-      "passed": true,
-      "evaluatedAt": "{timestamp}"
-    }
-  }
-}
-```
+Return structured output to the CLI for state update. The CLI will use MCP tools to update the phase gate in PostgreSQL if RESEARCH is an explicit workflow phase.
 
 ### Checklist de Governanca (OBRIGATORIO)
 
 Antes de considerar a pesquisa finalizada:
 
 - [ ] research-context.md criado em .orchestrator/artifacts/research/
-- [ ] Artefato registrado em orchestrator-index.json
+- [ ] Structured output returned to CLI for state update
 - [ ] Findings sao acionaveis e relevantes
 - [ ] Sources documentadas
 - [ ] Cache information registrada

package/templates/base/claude/agents/reviewer.md

@@ -361,62 +361,20 @@ Formato:
 }
 ```
 
-### 2. Registrar em orchestrator-index.json
+### 2. Artifact Registration (automatic via MCP tools)
 
-Apos criar validation report, registre no index:
+Artifacts are automatically registered in PostgreSQL when stored via MCP `artifactStore` tool. Sub-agents MUST NOT edit `.orchestrator/orchestrator-index.json` directly.
 
-```json
-{
-  "artifacts": [
-    {
-      "id": "val-XXX",
-      "type": "validation_report",
-      "path": ".orchestrator/artifacts/{phase}/validation-report.json",
-      "status": "completed",
-      "createdAt": "{timestamp}",
-      "workflowId": "{workflowId}",
-      "phase": "{phase}"
-    }
-  ]
-}
-```
-
-### 3. Atualizar Status do Artefato Revisado
-
-Se aprovado, atualize o status do artefato original:
-
-```json
-{
-  "artifacts": [
-    {
-      "id": "art-XXX",
-      "status": "validated",  // era "draft"
-      "validatedAt": "{timestamp}",
-      "validationReport": "val-XXX"
-    }
-  ]
-}
-```
+### 3. Return Structured Output for Validation Status
 
-### 4. Avaliar Gate da Fase
+Return structured output to the CLI indicating the validation result. The CLI will use MCP tools to:
+- Update artifact status to "validated" in PostgreSQL
+- Link validation report to original artifact
+- Update phase gate if applicable
 
-Se revisao for a ultima da fase, avalie o gate:
+### 4. Comunicar Resultado ao Orchestrator
 
-```json
-{
-  "gates": {
-    "{phase}": {
-      "passed": true,  // ou false se rejeitado
-      "evaluatedAt": "{timestamp}",
-      "evaluatedBy": "reviewer-agent"
-    }
-  }
-}
-```
-
-### 5. Comunicar Resultado ao Orchestrator
-
-Ao finalizar revisao, retorne status estruturado para o orchestrator:
+Ao finalizar revisao, retorne status estruturado para o CLI:
 
 ```markdown
 ## Review Result
@@ -431,14 +389,17 @@ Ao finalizar revisao, retorne status estruturado para o orchestrator:
 - Se REJECTED: Escalar para usuario
 ```
 
+The CLI will handle updating PostgreSQL via MCP tools.
+
 ### Checklist de Governanca (OBRIGATORIO)
 
 Antes de considerar a revisao finalizada:
 
 - [ ] Todos os criterios de qualidade verificados
-- [ ] Validation report criado e registrado
-- [ ] Status do artefato atualizado (validated/rejected)
-- [ ] Gate da fase avaliado
+- [ ] Validation report criado
+- [ ] Structured output returned to CLI for state update
+- [ ] Status do artefato will be updated via CLI (validated/rejected)
+- [ ] Gate da fase will be evaluated via CLI
 - [ ] Resultado comunicado ao orchestrator
 - [ ] Condicoes para aprovacao documentadas (se houver)
 ```

package/templates/base/claude/agents/schema-extractor.md

@@ -584,7 +584,7 @@ $posts = Post::with('user')->get();
 4. MUST document column types and nullability
 5. MUST generate database-schema.md using template
 6. MUST include table catalog with all columns
-7. MUST update orchestrator-index.json after completion
+7. MUST return structured output to CLI for state update (workflow state managed via PostgreSQL)
 8. MUST create checkpoint after MAP phase fully complete (with api-extractor)
 
 ### MUST NOT (Forbidden)
@@ -650,30 +650,9 @@ After completing MAP phase (Database portion):
 
 2. Validate Mermaid syntax (paste in Mermaid Live Editor or use CLI if available)
 
-3. Update orchestrator-index.json:
-   ```json
-   {
-     "activeWorkflow": {
-       "currentPhase": "map",
-       "status": "completed"
-     },
-     "artifacts": [
-       {
-         "id": "art-map-002",
-         "type": "database-schema",
-         "path": ".orchestrator/artifacts/legacy-analysis/{workflowId}/database-schema.md",
-         "status": "completed",
-         "createdAt": "{timestamp}",
-         "phase": "map",
-         "format": "markdown-mermaid",
-         "validated": true,
-         "tableCount": 15,
-         "relationshipCount": 22,
-         "accuracyPercent": 95
-       }
-     ]
-   }
-   ```
+3. Return structured output to CLI for state update:
+
+   Artifacts are automatically registered in PostgreSQL when stored via MCP `artifactStore` tool. The CLI will use MCP tools to update workflow state after artifact storage.
 
 4. Create checkpoint (MANDATORY after MAP phase complete):
    ```
@@ -753,7 +732,7 @@ Before claiming phase complete, MUST provide evidence:
 - [ ] Junction tables identified for many-to-many
 - [ ] Query patterns analyzed (if applicable)
 - [ ] Artifact saved to correct path
-- [ ] orchestrator-index.json updated
+- [ ] Structured output returned to CLI for state update
 - [ ] Checkpoint created (after MAP phase complete)
 
 **FORBIDDEN**: Claiming completion without valid Mermaid ER diagram.