@polymorphism-tech/morph-spec 6.0.0 → 7.0.0

package/framework/rules/morph-workflow.md

@@ -13,20 +13,18 @@ stacks:
 
 **NEVER skip to code without a specification.** Every feature must progress through phases:
 
-1. **Proposal** — User story + acceptance criteria (`0-proposal/proposal.md`)
-2. **Design** — Technical spec + C# contracts + decisions (`2-design/`)
-3. **Plan** — Detailed implementation plan (`3-plan/plan.md`)
-4. **Tasks** — Atomic task list (`4-tasks/tasks.md`)
-5. **Implement** — Code + recap (`5-implement/recap.md`)
-
-UI-heavy features also include **UI/UX** phase (`1-ui/`) between Design and Tasks.
+1. **Proposal** — Problem statement + acceptance criteria (`0-proposal/proposal.md`)
+2. **Design** (optional, UI-heavy) — Design system + mockups + flows (`1-design/`)
+3. **Plan** — Technical spec + mandate + tasks (`2-plan/spec.md`, `mandate.md`, `tasks.json`)
+4. **Implement** — Code + recap (`3-implement/recap.md`)
+5. **Review** — Review report + Gate 3 (`4-review/review-report.md`)
 
 ---
 
 ## Phase Sequence
 
 ```
-proposal → [uiux] → design → plan → tasks → implement → [sync]
+proposal → [design] → plan → implement → review
 ```
 
 Use `morph-spec status {feature}` to see current phase and pending approval gates.
@@ -52,25 +50,11 @@ Use `morph-spec status {feature}` to see current phase and pending approval gate
 | `.morph/framework/` | **READ-ONLY** — framework files managed by morph-spec |
 | `.morph/config/config.json` | Project configuration (editable) |
 
-### mark-output types
-
-Use `morph-spec state mark-output <feature> <type>` with one of these exact type names:
+### output types
 
-| Type | Phase | kebab alias |
-|------|-------|-------------|
-| `proposal` | proposal | — |
-| `schemaAnalysis` | design | `schema-analysis` |
-| `spec` | design | — |
-| `contracts` | design | — |
-| `contractsVsa` | design | `contracts-vsa` |
-| `decisions` | design | — |
-| `plan` | plan | — |
-| `tasks` | tasks | — |
-| `uiDesignSystem` | uiux | `ui-design-system` |
-| `uiMockups` | uiux | `ui-mockups` |
-| `uiComponents` | uiux | `ui-components` |
-| `uiFlows` | uiux | `ui-flows` |
-| `recap` | implement | — |
+Output types are defined in `src/core/paths/output-schema.js`. State sync is
+handled automatically by the `state-sync.js` PostToolUse hook — the agent
+does not need to call mark-output explicitly.
 
 ---
 
@@ -80,14 +64,11 @@ All outputs go in `.morph/features/{feature}/`:
 
 | Phase | Path |
 |-------|------|
-| Proposal | `0-proposal/proposal.md` |
-| UI Design | `1-ui/design-system.md`, `mockups.md`, `components.md`, `flows.md` |
-| Spec | `2-design/spec.md` |
-| Contracts | `2-design/contracts.cs` |
-| Decisions | `2-design/decisions.md` |
-| Plan | `3-plan/plan.md` |
-| Tasks | `4-tasks/tasks.md` |
-| Recap | `5-implement/recap.md` |
+| Proposal | `0-proposal/proposal.md`, `stack-scan.md`, `migration-plan.md` (optional) |
+| Design (optional) | `1-design/design-system.md`, `mockups.md`, `components.md`, `flows.md` |
+| Plan | `2-plan/spec.md`, `mandate.md`, `tasks.json`, `decisions.md` |
+| Implement | `3-implement/recap.md` + source code |
+| Review | `4-review/review-report.md` |
 
 ---
 

package/framework/schemas/tasks.schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "MORPH-SPEC tasks.json",
+  "description": "Structured task list for a morph-spec feature. Replaces tasks.md.",
+  "type": "object",
+  "required": ["version", "feature", "tasks"],
+  "properties": {
+    "version": { "type": "string", "const": "1.0" },
+    "feature": { "type": "string", "minLength": 1 },
+    "tasks": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "title", "description", "dependencies", "effort", "doneCriteria", "status"],
+        "properties": {
+          "id": { "type": "string", "pattern": "^T\\d+$" },
+          "title": { "type": "string", "minLength": 1 },
+          "description": { "type": "string", "minLength": 1 },
+          "dependencies": {
+            "type": "array",
+            "items": { "type": "string", "pattern": "^T\\d+$" }
+          },
+          "effort": { "type": "string", "enum": ["S", "M", "L", "XL"] },
+          "doneCriteria": { "type": "string", "minLength": 1 },
+          "status": { "type": "string", "enum": ["pending", "in_progress", "done", "skipped", "blocked"] },
+          "outputs": { "type": "array", "items": { "type": "string" } },
+          "notes": { "type": "string" },
+          "group": { "type": "string", "enum": ["backend", "frontend", "tests", "infra", "docs"] }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/framework/skills/core/morph-apply/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: morph-apply
+description: Orquestra a execução autônoma de tasks de uma feature morph-spec. Analisa DAG de dependências em tasks.json e decide adaptativamente entre execução sequencial (auto-advance) ou paralela (Agent dispatch). Termina com morph-review e Gate 3.
+version: core
+when-to-invoke: após Gate 2 aprovado, ao receber instrução "use /morph-apply" ou "implementar feature"
+user-invokable: true
+---
+
+# morph-apply
+
+## Objetivo
+
+Executar todas as tasks pendentes de uma feature até `done`, aplicando `morph-eval` após cada uma, e finalizar com `morph-review` + Gate 3.
+
+## Quando invocar
+
+- Após Gate 2 aprovado (verificar `.morph/state.json → features[X].approvalGates.plan === true`).
+- Usuário pede "use /morph-apply {feature}" ou "implementar {feature}".
+
+## Argumentos
+
+- `{feature-name}` — nome da feature. Se ausente, usar a feature `in_progress` mais recente em `state.json`.
+
+## Pré-condições
+
+- `.morph/features/{feature}/2-plan/tasks.json` existe e é válido (schema check).
+- `.morph/features/{feature}/2-plan/spec.md` e `mandate.md` existem.
+- Gate 2 está marcado aprovado no state.json (ou trust:auto está ativo).
+
+## Fluxo
+
+### 1. Carregar contexto
+
+- Ler `.morph/config/config.json → trust`.
+- Parsear `tasks.json` via `src/lib/tasks/tasks-json-parser.js`:
+  ```js
+  import { parseTasksJson, getReadyTasks, getPendingTasks, updateTaskStatus, writeTasksJson, groupTasks } from '../../../src/lib/tasks/tasks-json-parser.js';
+  const data = await parseTasksJson('.morph/features/{feature}/2-plan/tasks.json');
+  ```
+
+### 2. Análise de DAG — decisão sequencial vs paralelo
+
+Construir o grafo de dependências e detectar subsets independentes.
+
+**Regras de decisão:**
+
+1. Se `data.tasks.length <= 3`: **sequencial** (overhead de Agent dispatch não compensa).
+2. Identificar tasks **100% independentes** (`dependencies: []`):
+   - Se `>= 3` tasks independentes existem: dispachar essas em **paralelo**, depois cair em sequencial para o resto.
+3. Caso contrário: **sequencial puro** com auto-advance.
+
+Logar a decisão:
+```
+DAG analysis: 12 tasks, 4 independent → parallel batch (T1, T3, T7, T9) + sequential remainder
+```
+
+### 3a. Modo Sequencial (auto-advance)
+
+Loop:
+```
+while (true):
+  ready = getReadyTasks(data)
+  if ready.length === 0:
+    break
+
+  task = ready[0]
+  updateTaskStatus(data, task.id, 'in_progress')
+  writeTasksJson(tasksPath, data)
+
+  invoke Skill(morph-implement) with task
+
+  result = invoke Skill(morph-eval) with implementation output
+
+  if result.score >= 8:
+    updateTaskStatus(data, task.id, 'done')
+  else:
+    // forçar pausa — qualidade é guardrail, trust não ignora aqui
+    AskUserQuestion: "Task {id} com score {score} — aceitar, reimplementar ou pular?"
+    options: [aceitar mesmo assim, reimplementar, pular task]
+
+  writeTasksJson(tasksPath, data)
+```
+
+### 3b. Modo Paralelo (para o subset independente)
+
+Para cada task independente:
+```
+dispatch Agent (subagent_type: "general-purpose") with prompt:
+  contexto: spec.md, mandate.md, task description completa, doneCriteria
+  instrução: |
+    Implemente esta task isoladamente. Não modifique spec.md, mandate.md.
+    Retorne:
+      - sumário das mudanças
+      - arquivos modificados (paths)
+      - auto-score 0-10 (rubric: completeness, correctness, mandate compliance)
+```
+
+Aguardar todos os agentes terminarem (Promise.all equivalente). Depois, sequencialmente:
+- Para cada output retornado:
+  - Aplicar `Skill(morph-eval)`.
+  - Se score >= 8: marcar `done`.
+  - Se score < 8: marcar `pending` novamente com nota — será re-executada no modo sequencial.
+
+Depois do batch paralelo, executar o restante em modo sequencial (passo 3a).
+
+### 4. Conclusão de tasks
+
+Quando `getPendingTasks(data).length === 0`:
+
+- Invocar `Skill(morph-review)` para gerar `.morph/features/{feature}/4-review/review-report.md`.
+- A skill morph-review chama `morph-eval` em escopo de feature inteira.
+
+### 5. Gate 3 (trust-aware)
+
+Sinais de risco para Gate 3:
+
+- Score médio < 8 no review-report.
+- Presença de erros não resolvidos.
+- Mudanças incidentais em standards/.morph/framework/.
+
+Mesma lógica do Gate 1/Gate 2 via `shouldPauseGate(config, signals)`:
+
+- Pause: `AskUserQuestion` com options `["aprovado, fechar feature", "preciso ajustar", "rollback"]`.
+- Auto: exibir summary do review-report e prosseguir.
+
+### 6. Pós Gate 3
+
+- Atualizar `state.features[feature].status = "completed"` via state-sync (hook detecta "aprovado" em AskUserQuestion answer).
+- Sinalizar: "Feature {nome} concluída. Rode `/morph-archive {feature}` para arquivar."
+- Não arquivar automaticamente.
+
+## Anti-padrões
+
+- Não dispachar paralelo se há deps cruzadas entre as tasks selecionadas (corrompe ordem).
+- Não pular `morph-eval` — silêncio em score >= 8 é o sinal correto.
+- Não reescrever spec.md/mandate.md durante implement (são read-only após Gate 2 — `protect-spec-files.js` hook bloqueia).
+- Não dispachar mais que 4 agentes em paralelo (sobrecarga de contexto + custo).
+
+## Output esperado
+
+- Todas as tasks em `tasks.json` com status `done` ou `skipped`.
+- `.morph/features/{feature}/3-implement/recap.md` produzido por morph-implement.
+- `.morph/features/{feature}/4-review/review-report.md` produzido por morph-review.
+- Gate 3 marcado aprovado em `.morph/state.json` (via state-sync hook ou Edit direto).
+- `state.features[feature].status === "completed"`.
+
+## Referências
+
+- `.morph/framework/MORPH.md` — charter NLH
+- `framework/skills/core/morph-implement/SKILL.md`
+- `framework/skills/core/morph-eval/SKILL.md`
+- `framework/skills/core/morph-review/SKILL.md`
+- `src/lib/tasks/tasks-json-parser.js` — DAG queries (`getReadyTasks`, `getPendingTasks`)
+- `src/lib/risk-detector.js` — `shouldPauseGate`

package/framework/skills/core/morph-brainstorming/SKILL.md

@@ -42,26 +42,22 @@ O harness conhece o stack por padrão. Não pergunte sobre tecnologia a menos qu
 
 ### Parte 2 — Detecção de contexto (greenfield vs brownfield)
 
-2. Use um `Explore` subagent para varrer o projeto com este prompt:
-
-   ```
-   Varredura de codebase para morph-brainstorming.
-
-   Procure e reporte:
-   1. Stack atual: leia .csproj (TargetFramework, PackageReferences), package.json (dependencies), 
-      migrations/ (ORM em uso). Liste tecnologias encontradas.
-   2. Estrutura de pastas: o projeto segue VSA (feature-folder) ou outra arquitetura?
-   3. Padrões em uso: Guid.NewGuid() ou Guid.CreateVersion7()? Classes sealed? Result pattern ou exceptions?
-   4. Features existentes: liste as pastas em src/ ou equivalente para mapear slices já implementados.
-   5. Dependências relevantes para esta feature: o que já existe que esta feature vai usar ou modificar?
-
-   Retorne apenas fatos observados — sem sugestões ou opiniões.
-   ```
-
-3. Com base na varredura:
-   - **Se o projeto não existe ainda (greenfield):** siga direto para a Parte 3.
-   - **Se o projeto existe e segue o stack padrão:** siga para a Parte 3.
-   - **Se o projeto existe mas desvia do stack padrão:** gere um `migration-plan.md` em `.morph/features/{feature}/0-proposal/` listando o que migrar e em que ordem. Faça UMA pergunta via `AskUserQuestion`: "A migração de stack deve ser incluída nesta feature ou tratada numa feature separada?" Registre a decisão e siga para a Parte 3.
+2. Invoque `Skill(morph-stack-scan)` para detectar contexto. A skill:
+   - Curto-circuita em projetos greenfield (sem source files) — retorna relatório vazio.
+   - Em brownfield, varre stack atual (.csproj, package.json, migrations), padrões (Guid.NewGuid vs Guid.CreateVersion7, sealed, result pattern), features existentes.
+   - Produz `.morph/features/{feature}/0-proposal/stack-scan.md`.
+
+3. Reconciliação de design-system (se aplicável):
+   - Comparar `.morph/context/design-system.md` (se existir) com o que foi detectado no stack-scan e com bundles/mocks recentes do usuário.
+   - Se houver **divergência** (tokens diferentes, framework version mismatch, fonte aprovada distinta):
+     - Marcar `signals.designSystemDivergence = true` no contexto da feature.
+     - Perguntar ao usuário via `AskUserQuestion` qual fonte usar, listando as fontes detectadas como options.
+     - Atualizar `.morph/context/design-system.md` com a fonte escolhida + entrada de changelog (data, motivo).
+
+4. Com base no relatório:
+   - **Greenfield:** seguir para a Parte 3.
+   - **Stack padrão:** seguir para a Parte 3.
+   - **Desvio de stack:** gerar `migration-plan.md` em `.morph/features/{feature}/0-proposal/`. Perguntar via `AskUserQuestion`: "A migração de stack deve ser incluída nesta feature ou tratada numa feature separada?" Registrar decisão e seguir.
 
 ### Parte 3 — Produção do proposal.md
 
@@ -76,21 +72,46 @@ O harness conhece o stack por padrão. Não pergunte sobre tecnologia a menos qu
 
    Um bom proposal.md tem no máximo 2 páginas. Se está crescendo além disso, o escopo precisa ser cortado.
 
-5. Apresente o Gate 1:
+5. Apresente o Gate 1 segundo trust mode.
+
+   Ler `.morph/config/config.json → trust` (default `"auto"`). Calcular sinais de risco via `src/lib/risk-detector.js`:
+
+   ```js
+   import { shouldPauseGate, getRiskSignals } from '../../../src/lib/risk-detector.js';
+   const signals = {
+     designSystemDivergence: /* from passo 3 */,
+     standardsViolations: /* lista de violações detectadas */,
+   };
+   const { pause, reason } = shouldPauseGate(config, signals);
+   const riskList = getRiskSignals(signals);
+   ```
+
+   **Se `pause === true`** (manual mode OU risco detectado em auto), use `AskUserQuestion`:
+
+   ```
+   question: "Gate 1 — Proposta de {nome} aprovada?{ reason ? ' Sinal de risco: ' + reason : '' }"
+   header: "Gate 1"
+   options:
+     - { label: "aprovado, prosseguir", description: "Aceitar a proposta e avançar para o planejamento" }
+     - { label: "preciso ajustar", description: "Apontar mudanças necessárias antes de prosseguir" }
+     - { label: "cancelar feature", description: "Abortar — feature não vai avançar" }
+   ```
+
+   Aguardar resposta. Se "preciso ajustar", aplique e reapresente.
+
+   **Se `pause === false`** (auto-aprovação), exibir summary curto e prosseguir sem aguardar:
 
    ```
-   ## Gate 1 — Proposta pronta para revisão
+   ## Gate 1 (auto-aprovado)
 
    **Feature:** {nome}
    **Problema:** {1 frase}
-   **Escopo:** {incluído} | Excluído: {exclusões explícitas}
-   **Stack:** {Em compliance / Desvios: X, Y}
-   **Riscos:** {principal risco identificado}
-
-   Aprovado? Responda "aprovado" para avançar para o planejamento.
+   **Escopo:** {incluído} | Excluído: {exclusões}
+   **Stack:** {compliance}
+   **Riscos:** {principal} (sinais detectados: nenhum)
    ```
 
-   Aguarde aprovação explícita. Se o usuário pedir ajustes, aplique e reapresente o gate.
+   O hook state-sync.js detecta a aprovação automaticamente. Em modo auto sem AskUserQuestion, a skill atualiza `.morph/state.json` via Edit direto (allowlist permite — ver settings.local.json).
 
 ## Output esperado
 - `.morph/features/{feature}/0-proposal/proposal.md` — proposta aprovada
@@ -98,5 +119,7 @@ O harness conhece o stack por padrão. Não pergunte sobre tecnologia a menos qu
 - Gate 1 apresentado e aprovado
 
 ## Referências
-- `framework/MORPH.md` — seções 1 (Papéis), 2 (Fases), 5 (Gates)
-- `framework/standards/STANDARDS.json` — para referência de standards relevantes à stack
+- `.morph/framework/MORPH.md` — seções 1 (Papéis), 2 (Fases), 5 (Gates), Trust Mode
+- `.morph/framework/standards/STANDARDS.json` — para referência de standards relevantes à stack
+- `framework/skills/core/morph-stack-scan/SKILL.md` — invocada na Parte 2
+- `src/lib/risk-detector.js` — `shouldPauseGate(config, signals)` para Gate 1

package/framework/skills/core/morph-implement/SKILL.md

@@ -2,7 +2,7 @@
 name: morph-implement
 description: Guia a execução de cada tarefa de implementação com standard e persona adequados
 version: core
-when-to-invoke: ao iniciar cada tarefa de implementação listada no tasks.md
+when-to-invoke: ao iniciar cada task de implementação listada em tasks.json
 user-invokable: false
 ---
 
@@ -13,7 +13,7 @@ Garantir que cada tarefa seja executada com o standard correto, a persona de age
 e que o resultado seja registrado no recap.md ao final.
 
 ## Quando invocar
-Ao iniciar cada tarefa do tasks.md — antes de escrever qualquer código.
+Ao iniciar cada task de `tasks.json` — antes de escrever qualquer código. Normalmente invocada pela skill orquestradora `morph-apply`, que passa o objeto da task atual.
 
 ## O que fazer
 
@@ -29,21 +29,21 @@ Ao iniciar cada tarefa do tasks.md — antes de escrever qualquer código.
    - Consulte `framework/agents.json` — encontre o agente cujo `domains` cobre o domínio da tarefa.
    - Leia o campo `persona` do agente e adote esse ponto de vista durante a implementação.
 
-4. Avalie se a tarefa se qualifica para sub-agent dispatch (ver critérios em `framework/MORPH.md` seção 6):
-   - Duração estimada > 5 minutos
+4. Avalie se a task se qualifica para sub-agent dispatch (ver critérios em `.morph/framework/MORPH.md` seção 6):
+   - Duração estimada > 5 minutos (effort L ou XL)
    - Mais de 3 tentativas de correção falharam no mesmo problema
    - Análise de arquivo com > 500 linhas
-   - Tarefa repetitiva com > 3 instâncias do mesmo padrão
+   - Task repetitiva com > 3 instâncias do mesmo padrão
    - Risco de contaminar o contexto principal com detalhes de baixo nível irrelevantes para o fluxo
 
    **Se sim — despache sub-agent com este template:**
    ```
-   Implementar [ID da tarefa]: [título da tarefa]
+   Implementar [ID]: [title da task]
 
-   Spec: [O que deve ser feito em 3-5 frases, extraído do tasks.md]
+   Spec: [description completa do tasks.json]
    Standard: [path do .md do standard identificado no passo 2]
-   Arquivos relevantes: [lista de paths que o sub-agent precisa ler ou modificar]
-   Done quando: [critério verificável do tasks.md]
+   Arquivos relevantes: [lista de paths]
+   Done quando: [doneCriteria do tasks.json]
 
    Retorne APENAS: (1) o que foi feito em 2-3 frases, (2) arquivos modificados,
    (3) problemas encontrados e como foram resolvidos, (4) auto-score 0-10.
@@ -69,15 +69,26 @@ Ao iniciar cada tarefa do tasks.md — antes de escrever qualquer código.
    - Deixe `eval_score` e `eval_dimensions` como `null` — serão preenchidos pelo morph-eval
    - Se esta for a última tarefa da fase, preencha `completed_at`
 
-8. Verifique o tasks.md por tarefas com status pendente. Se houver próxima tarefa, inicie-a imediatamente aplicando esta skill desde o passo 1 — sem aguardar instrução do usuário. Pause apenas se encontrar ambiguidade bloqueante não coberta pelo mandate.
+8. Atualizar `tasks.json` marcando a task como `done` via `updateTaskStatus`:
+
+   ```js
+   import { parseTasksJson, updateTaskStatus, writeTasksJson, getReadyTasks } from '../../../src/lib/tasks/tasks-json-parser.js';
+   const data = await parseTasksJson(tasksPath);
+   updateTaskStatus(data, task.id, 'done');
+   await writeTasksJson(tasksPath, data);
+   ```
+
+9. Quando invocada por `morph-apply`, retornar o controle à skill orquestradora — ela decide qual task vem em seguida via `getReadyTasks(data)`. Quando invocada manualmente, verificar se há próxima task ready e iniciá-la imediatamente aplicando esta skill desde o passo 1 (auto-advance). Pause apenas se encontrar ambiguidade bloqueante não coberta pelo mandate.
 
 ## Output esperado
 - Código implementado conforme o standard consultado (direto ou via sub-agent)
-- `.morph/features/{feature}/3-implement/recap.md` atualizado com entrada da tarefa concluída
+- `.morph/features/{feature}/3-implement/recap.md` atualizado com entrada da task concluída
+- `.morph/features/{feature}/2-plan/tasks.json` com status da task atualizado para `done`
 - `.morph/features/{feature}/2-plan/decisions.md` atualizado se houver decisão não trivial
 
 ## Referências
-- `framework/standards/STANDARDS.json` — índice de standards (não carregue todos — filtre por tarefa)
-- `framework/agents.json` — personas dos agentes por domínio
-- `framework/MORPH.md` seção 6 — critérios de dispatch e contrato de retorno do sub-agent
+- `.morph/framework/standards/STANDARDS.json` — índice de standards (não carregue todos — filtre por task)
+- `.morph/framework/agents.json` — personas dos agentes por domínio
+- `.morph/framework/MORPH.md` seção 6 — critérios de dispatch e contrato de retorno do sub-agent
 - `.morph/features/{feature}/2-plan/mandate.md` — contrato da feature
+- `src/lib/tasks/tasks-json-parser.js` — `parseTasksJson`, `updateTaskStatus`, `writeTasksJson`

package/framework/skills/core/morph-plan/SKILL.md

@@ -1,64 +1,132 @@
 ---
 name: morph-plan
-description: Guia a produção dos três artefatos de planejamento de uma feature
+description: Guia a produção dos três artefatos de planejamento de uma feature (spec.md, mandate.md, tasks.json) e apresenta o Gate 2 trust-aware.
 version: core
-when-to-invoke: ao iniciar a fase plan de uma feature, após o gate 1 (proposal aprovado)
+when-to-invoke: ao iniciar a fase plan de uma feature, após o Gate 1 (proposal aprovado)
 user-invokable: true
 ---
 
 # morph-plan
 
 ## Objetivo
-Produzir spec.md, mandate.md e tasks.md com qualidade suficiente para abrir o Gate 2.
+
+Produzir `spec.md`, `mandate.md` e `tasks.json` com qualidade suficiente para abrir o Gate 2.
 Os três artefatos juntos definem o quê, o como e o quanto da feature.
 
 ## Quando invocar
-Ao iniciar a fase plan — após o proposal.md ser aprovado e antes de qualquer implementação.
+
+Ao iniciar a fase plan — após o `proposal.md` ser aprovado e antes de qualquer implementação. Normalmente invocada pela skill orquestradora `morph-proposal`.
 
 ## O que fazer
 
 1. Leia o `proposal.md` em `.morph/features/{feature}/0-proposal/` para entender escopo e critérios de aceite.
+
 2. Produza `spec.md` em `.morph/features/{feature}/2-plan/`:
    - Arquitetura da solução: quais componentes, como se conectam, fluxos de dados principais.
    - Edge cases identificados e como serão tratados.
    - Integrações externas e contratos esperados.
+
 3. Produza `mandate.md` em `.morph/features/{feature}/2-plan/`:
-   - Stack exata do projeto (leia do CLAUDE.md → campo Stack).
-   - Standards obrigatórios: liste os IDs relevantes de `framework/standards/STANDARDS.json`.
+   - Stack exata do projeto (leia de `.morph/config/config.json` → `project.stack` ou do CLAUDE.md).
+   - Standards obrigatórios: liste os IDs relevantes de `.morph/framework/standards/STANDARDS.json`.
    - Patterns proibidos — inclua sempre os defaults abaixo mais qualquer específico da feature:
      - `Guid.NewGuid()` → usar `Guid.CreateVersion7()`
      - Classes não-sealed sem justificativa documentada
      - Exceptions como fluxo de controle → usar result pattern com `result.Match()`
      - Repository pattern / `IRepository<T>` → handlers VSA acessam DbContext diretamente
    - Checklist de done com critérios verificáveis por tarefa.
-4. Produza `tasks.md` em `.morph/features/{feature}/2-plan/`:
-   - Liste cada tarefa com ID único (T1, T2...).
-   - Para cada tarefa: descrição, dependências, estimativa de esforço, critério de done.
-   - Ordene por dependências — tarefas sem dependências primeiro.
-5. Apresente o Gate 2 ao usuário usando exatamente este formato:
 
+4. Produza `tasks.json` em `.morph/features/{feature}/2-plan/` seguindo o schema em `.morph/framework/schemas/tasks.schema.json`.
+
+   **Formato obrigatório** (validado pelo parser em `src/lib/tasks/tasks-json-parser.js`):
+
+   ```json
+   {
+     "version": "1.0",
+     "feature": "{feature-name}",
+     "tasks": [
+       {
+         "id": "T1",
+         "title": "Título curto",
+         "description": "Detalhes — o que esta task realiza e por quê",
+         "dependencies": [],
+         "effort": "S",
+         "doneCriteria": "Critério verificável em 1 frase",
+         "status": "pending",
+         "outputs": [],
+         "group": "backend"
+       }
+     ]
+   }
    ```
-   ## Gate 2 — Plano pronto para revisão
 
-   **Spec:** {1 frase do problema} → {1 frase da solução técnica}
-   **Mandate:** Stack: {stack} | Standards: {N obrigatórios} | Proibido: {padrões proibidos listados}
-   **Tasks:** {N tarefas} | Estimativa: {X horas/dias} | Caminho crítico: {IDs das tarefas sem dependências paralelas}
+   Regras:
+   - `id` segue padrão `T\d+` (T1, T2, T10...).
+   - `dependencies` lista outros IDs Tn. Tasks sem deps tem `[]`.
+   - `effort`: S (≤30min), M (≤1h), L (≤2h), XL (>2h).
+   - `status` inicia sempre como `pending`.
+   - `group` (opcional): backend, frontend, tests, infra, docs. Default backend.
+   - `outputs` (opcional): array de paths que serão criados/modificados.
 
-   Decisões de arquitetura:
-   - {decisão 1} — alternativa descartada: {alternativa}
-   {adicione apenas se houver decisões não triviais}
+   Antes de retornar, validar com:
+   ```js
+   import { validateTasksJson, writeTasksJson } from '../../../src/lib/tasks/tasks-json-parser.js';
+   const { valid, errors } = validateTasksJson(data);
+   if (!valid) throw new Error(errors.join('\n'));
+   await writeTasksJson(tasksPath, data);
+   ```
+
+5. Apresente o Gate 2 segundo trust mode.
+
+   Ler `.morph/config/config.json → trust` (default `"auto"`). Calcular sinais de risco:
 
-   Aprovado? Responda "pode implementar" para avançar.
+   ```js
+   import { shouldPauseGate, getRiskSignals } from '../../../src/lib/risk-detector.js';
+   const signals = {
+     taskCount: data.tasks.length,
+     designSystemDivergence: /* herdado do brainstorming */,
+     standardsViolations: /* detectado em mandate */,
+   };
+   const { pause, reason } = shouldPauseGate(config, signals);
    ```
 
-   Aguarde resposta explícita. Se o usuário pedir ajustes, aplique e reapresente o gate completo antes de avançar.
+   **Se `pause === true`**, use `AskUserQuestion`:
+
+   ```
+   question: "Gate 2 — Plano de {feature} aprovado?{ reason ? ' Sinal: ' + reason : '' }"
+   header: "Gate 2"
+   options:
+     - { label: "aprovado, prosseguir", description: "Aceitar spec/mandate/tasks e habilitar /morph-apply" }
+     - { label: "preciso ajustar", description: "Apontar mudanças no plano antes de prosseguir" }
+     - { label: "cancelar feature", description: "Abortar" }
+   ```
+
+   Aguardar resposta. Se "preciso ajustar", aplicar e reapresentar.
+
+   **Se `pause === false`** (auto-aprovação), exibir summary curto:
+
+   ```
+   ## Gate 2 (auto-aprovado)
+
+   **Spec:** {1 frase} → {1 frase da solução}
+   **Mandate:** Stack: {stack} | Standards: {N obrigatórios} | Proibido: {N padrões}
+   **Tasks:** {N} | Esforço total: {soma} | Caminho crítico: {IDs sem deps paralelas}
+   ```
+
+   O hook state-sync registra a aprovação automaticamente em answers de AskUserQuestion. Em auto sem AskUserQuestion, a skill edita `state.json` diretamente.
 
 ## Output esperado
+
 - `.morph/features/{feature}/2-plan/spec.md` — especificação técnica completa
 - `.morph/features/{feature}/2-plan/mandate.md` — contrato de implementação
-- `.morph/features/{feature}/2-plan/tasks.md` — lista de tarefas ordenada
+- `.morph/features/{feature}/2-plan/tasks.json` — task list estruturada válida contra schema
+- Gate 2 marcado aprovado em `state.json`
 
 ## Referências
-- `framework/MORPH.md` — seções 2 (Fases), 3 (Contratos de Output), 5 (Gates)
-- `framework/standards/STANDARDS.json` — para identificar standards relevantes ao mandate
+
+- `.morph/framework/MORPH.md` — seções 2 (Fases), 3 (Contratos de Output), 5 (Gates), Trust Mode
+- `.morph/framework/standards/STANDARDS.json` — para identificar standards relevantes ao mandate
+- `.morph/framework/schemas/tasks.schema.json` — schema obrigatório de tasks.json
 - `.morph/features/{feature}/0-proposal/proposal.md` — escopo da feature
+- `src/lib/tasks/tasks-json-parser.js` — `validateTasksJson`, `writeTasksJson`
+- `src/lib/risk-detector.js` — `shouldPauseGate`, `getRiskSignals`