@polymorphism-tech/morph-spec 7.6.0 → 7.7.0

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

@@ -4,7 +4,7 @@ description: Guia a produção dos três artefatos de planejamento de uma featur
 version: core
 when-to-invoke: ao iniciar a fase plan de uma feature, após o Gate 1 (proposal aprovado)
 user-invokable: true
-cliVersion: "7.6.0"
+cliVersion: "7.7.0"
 ---
 
 # morph-plan
@@ -42,7 +42,7 @@ Ao iniciar a fase plan — após o `proposal.md` ser aprovado e antes de qualque
 
 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`):
+   **Formato obrigatório** (schema em `.morph/framework/schemas/tasks.schema.json` — o hook `tasks-json-guard` valida cada write):
 
    ```json
    {
@@ -72,27 +72,17 @@ Ao iniciar a fase plan — após o `proposal.md` ser aprovado e antes de qualque
    - `group` (opcional): backend, frontend, tests, infra, docs. Default backend.
    - `outputs` (opcional): array de paths que serão criados/modificados.
 
-   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);
-   ```
+   Antes de retornar, valide rodando `morph-spec dag {feature}` — o comando parseia e valida o schema do tasks.json (ids únicos `T\d+`, enums de `status`/`effort`, `dependencies` válidas) e já imprime a análise de DAG que a `/morph-apply` vai usar. Erros de schema abortam com a lista do que corrigir.
 
 5. Apresente o Gate 2 segundo trust mode.
 
-   Ler `.morph/config/config.json → trust` (default `"auto"`). Calcular sinais de risco:
+   Ler `.morph/config/config.json → trust` (default `"auto"`). Calcular os sinais de risco em linguagem natural — sem scripts:
 
-   ```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);
-   ```
+   - `taskCount` = número de tasks do tasks.json.
+   - `designSystemDivergence` = herdado do brainstorming.
+   - `standardsViolations` = violações detectadas no mandate.
+
+   **Decisão de pausa** (regras da tabela do MORPH.md §5): `trust: manual` → pausa sempre; `designSystemDivergence` → pausa; `standardsViolations` não-vazio → pausa; `taskCount > 20` → pausa; caso contrário → auto-passa (`pause: false`).
 
    **Persista a decisão no `feature.json` autoritativo da feature ANTES de apresentar ou auto-aprovar** — grave
    `gateDecisions.plan = { pause, reason, signals, trust, decidedAt: <ISO> }` em `.morph/features/{feature}/feature.json`
@@ -137,5 +127,6 @@ Ao iniciar a fase plan — após o `proposal.md` ser aprovado e antes de qualque
 - `.morph/framework/schemas/tasks.schema.json` — schema obrigatório de tasks.json
 - `.morph/features/{feature}/0-proposal/proposal.md` — escopo da feature
 - `.morph/features/{feature}/0-proposal/stack-scan.md` — contexto técnico detectado
-- `src/lib/tasks/tasks-json-parser.js` — `validateTasksJson`, `writeTasksJson`
-- `src/lib/risk-detector.js` — `shouldPauseGate`, `getRiskSignals`
+- `.morph/framework/schemas/tasks.schema.json` — schema e enums de tasks.json
+- `morph-spec dag {feature}` — valida o tasks.json e imprime a análise de DAG
+- `.morph/framework/MORPH.md` §5 — regras de pausa de gate (trust mode)

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

@@ -4,7 +4,7 @@ description: Orquestra a fase de proposta+plano de uma feature morph-spec. Encad
 version: core
 when-to-invoke: ao receber instrução "use /morph-proposal" do usuário, ou ao iniciar uma nova feature
 user-invokable: true
-cliVersion: "7.6.0"
+cliVersion: "7.7.0"
 ---
 
 # morph-proposal
@@ -52,12 +52,7 @@ Ler `.morph/config/config.json → trust` (default `"auto"`). Calcular sinais de
 - `designSystemDivergence` — detectado pela morph-brainstorming.
 - `standardsViolations` — violações de mandate listadas na proposal (não deveria, mas verifica).
 
-Usar `src/lib/risk-detector.js`:
-
-```js
-import { shouldPauseGate } from '../../../src/lib/risk-detector.js';
-const { pause, reason } = shouldPauseGate(config, signals);
-```
+**Decisão de pausa** (regras da tabela do MORPH.md §5, aplicadas em linguagem natural — sem scripts): `trust: manual` → `pause: true` sempre; `designSystemDivergence` → pausa; `standardsViolations` não-vazio → pausa; caso contrário → `pause: false` (auto-passa). Monte `reason` com o sinal que disparou.
 
 **Se `pause === true`**, apresentar via `AskUserQuestion`:
 
@@ -136,4 +131,4 @@ Lógica idêntica ao passo 3 (`shouldPauseGate` + AskUserQuestion ou auto-aprova
 - `.morph/framework/MORPH.md` — charter NLH completo
 - `framework/skills/core/morph-brainstorming/SKILL.md`
 - `framework/skills/core/morph-plan/SKILL.md`
-- `src/lib/risk-detector.js` — `shouldPauseGate`, `getRiskSignals`
+- `.morph/framework/MORPH.md` §5 — regras de pausa de gate (trust mode)

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

@@ -4,7 +4,7 @@ description: Conduz a fase de revisão e produz o review-report.md para o Gate 3
 version: core
 when-to-invoke: ao iniciar a fase review, após todas as tasks de tasks.json estarem com status `done`
 user-invokable: true
-cliVersion: "7.6.0"
+cliVersion: "7.7.0"
 ---
 
 # morph-review
@@ -33,7 +33,27 @@ e o `recap.md` estar atualizado. Normalmente invocada pela skill orquestradora `
    - Se não atendido: registre como "bloqueante" com descrição do gap.
    - Se parcialmente atendido: registre como "pendência" com o que falta.
 
-4. Execute morph-eval na implementação completa (fase, não tarefa) para obter scores por dimensão.
+4. **Despache o avaliador independente** — o score do Gate 3 nunca é auto-atribuído por quem implementou:
+   - Rode a suíte de testes do projeto e capture a **saída real** (não um resumo seu).
+   - Gere o **diff da implementação** (`git diff` do range da feature, ou a lista de arquivos do recap.md com seus conteúdos atuais).
+   - Despache o subagent registrado `morph-evaluator` (gerado de `agents.json` — a persona do avaliador é o system prompt dele, com tools read-only), com contexto fresco:
+     ```
+     dispatch Agent (subagent_type: "morph-evaluator") with prompt:
+       contexto: mandate.md + spec.md + diff da implementação + saída real dos testes
+       instrução: |
+         Você NÃO participou da implementação — avalie apenas o que está no diff,
+         contra o mandate. Aplique as rubricas em .morph/framework/evals/rubrics/
+         (architecture 30%, contracts 25%, code-quality 25%, test-coverage 20%)
+         seguindo as bandas 0-10 de cada uma.
+         NÃO reescreva código. NÃO toque em tasks.json, feature.json nem no board
+         de sessão. Ao concluir, ENTREGUE o relatório final — terminar idle sem
+         reportar é falha de protocolo.
+         Retorne: score 0-10 por dimensão, score composto (arch×0.30 + contracts×0.25
+         + quality×0.25 + tests×0.20), e feedback priorizado (bloqueantes primeiro)
+         para qualquer dimensão < 9.
+     ```
+   - **Fallback (tipo não registrado):** se `morph-evaluator` não estiver na sua lista de subagent types, despache `general-purpose` colando o campo `persona` do agente `evaluator` (Read em `.morph/framework/agents.json`) no topo do prompt — e **registre o fallback no review-report** (seção de método).
+   - Os scores por dimensão e o composto do review-report vêm **desse retorno**, não da sua auto-avaliação. Se o avaliador ficar idle sem reportar, cobre via SendMessage antes de prosseguir.
 
 5. Produza `review-report.md` em `.morph/features/{feature}/4-review/` com:
    - Scores por dimensão (arquitetura, contratos, qualidade, cobertura)
@@ -55,16 +75,12 @@ e o `recap.md` estar atualizado. Normalmente invocada pela skill orquestradora `
 
 8. Apresente o Gate 3 segundo trust mode.
 
-   Ler `.morph/config/config.json → trust` (default `"auto"`). Calcular sinais de risco:
+   Ler `.morph/config/config.json → trust` (default `"auto"`). Calcular os sinais de risco em linguagem natural — sem scripts:
 
-   ```js
-   import { shouldPauseGate } from '../../../src/lib/risk-detector.js';
-   const signals = {
-     evalScore: phaseScores.composite,
-     standardsViolations: blockingItems.filter(b => b.kind === 'standard').map(b => b.id),
-   };
-   const { pause, reason } = shouldPauseGate(config, signals);
-   ```
+   - `evalScore` = score composto retornado pelo **avaliador independente** (passo 4).
+   - `standardsViolations` = ids dos itens bloqueantes de standard encontrados no passo 3.
+
+   **Decisão de pausa** (mesmas regras da tabela do MORPH.md §5): `trust: manual` → `pause: true` sempre; `standardsViolations` não-vazio → `pause: true`; `evalScore < 9` → `pause: true`; caso contrário → `pause: false` (auto-passa).
 
    **Se `pause === true`**, use `AskUserQuestion`:
 
@@ -96,11 +112,11 @@ e o `recap.md` estar atualizado. Normalmente invocada pela skill orquestradora `
 - Gate 3 registrado aprovado em `.morph/features/{feature}/feature.json` (autoritativo), na forma canônica `{ approved, timestamp, approvedBy }` — via `morph-spec approve` em auto, ou pelo hook state-sync no caminho manual
 
 ## Referências
-- `.morph/framework/MORPH.md` — seção 5 (Gate 3), seção 1 (papel Evaluator), Trust Mode
-- `framework/skills/core/morph-eval/SKILL.md` — para calcular scores por dimensão
+- `.morph/framework/MORPH.md` — seção 5 (Gate 3 + regras de pausa), seção 1 (papel Evaluator), Trust Mode
+- `.claude/agents/morph-evaluator.md` — subagent do avaliador (gerado de `.morph/framework/agents.json`), despachado no passo 4
+- `framework/skills/core/morph-eval/SKILL.md` — rubricas e bandas que o avaliador aplica
 - `.morph/framework/evals/trace-schema.md` — formato canônico do trace
 - `.morph/features/{feature}/2-plan/mandate.md` — critérios de done da feature
 - `.morph/features/{feature}/2-plan/spec.md` — arquitetura e contratos
 - `.morph/features/{feature}/2-plan/decisions.md` — ADRs registrados (se existir)
 - `.morph/features/{feature}/3-implement/recap.md` — registro de execução
-- `src/lib/risk-detector.js` — `shouldPauseGate` para Gate 3

package/framework/skills/core/morph-stack-scan/SKILL.md

@@ -4,7 +4,7 @@ description: Varre o codebase existente, detecta stack atual, compara com o stac
 version: core
 when-to-invoke: ao iniciar uma feature em projeto brownfield (codebase já existente)
 user-invokable: true
-cliVersion: "7.6.0"
+cliVersion: "7.7.0"
 ---
 
 # morph-stack-scan

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

@@ -4,7 +4,7 @@ description: Localiza e carrega um standard específico do STANDARDS.json sob de
 version: core
 when-to-invoke: quando precisar consultar um standard específico durante a implementação
 user-invokable: true
-cliVersion: "7.6.0"
+cliVersion: "7.7.0"
 ---
 
 # morph-standards

package/framework/standards/integration/mcp/mcp-tools.md

@@ -5,7 +5,7 @@
 > **Keywords:** mcp, model-context-protocol, mcp-tools, context7, playwright, mcp-client
 > **Load When:** an MCP tool is used in any morph-spec phase
 
-**Verified against:** Claude Code MCP tooling — context7, Playwright, GitHub, Neon CLI. Last-verified: 2026-05-20.
+**Verified against:** Claude Code MCP tooling — context7, Playwright; GitHub via `gh` CLI; Neon via `neonctl`. Last-verified: 2026-07-08.
 
 ---
 
@@ -19,8 +19,8 @@ Before using any MCP tool, check if it's available in the current session:
 // Pattern: Attempt the call — if the tool doesn't exist, Claude Code will report it
 // There is no "list MCPs" command; just try the most common operation
 
-// GitHub MCP
-await mcp__github__get_repo();
+// GitHub — o morph-spec NÃO usa MCP do GitHub: use o `gh` CLI via Bash
+// gh repo view --json name,defaultBranchRef,languages
 
 // Context7 (library docs)
 await mcp__context7__resolve_library_id({ libraryName: "react" });
@@ -41,18 +41,19 @@ await mcp__playwright__browser_navigate({ url: "https://example.com" });
 
 ### Phase 1 (Setup) — Project Discovery
 
-| MCP | Use Case | Example |
-|-----|----------|---------|
-| **GitHub** | Repo info, recent PRs, issues | `mcp__github__get_repo()` |
+| Tool | Use Case | Example |
+|------|----------|---------|
+| **GitHub CLI (`gh`)** | Repo info, recent PRs, issues | `gh repo view --json ...` (Bash) |
 | **Filesystem** | Scan project structure | Native Glob/Read preferred |
 
-```javascript
-// Detect project type from repo metadata
-const repo = await mcp__github__get_repo();
-// → language, default_branch, topics
+```bash
+# Detect project type from repo metadata (gh CLI via Bash — sem MCP)
+gh repo view --json name,defaultBranchRef,languages,repositoryTopics
+gh pr list --limit 10 --json title,state,updatedAt
+gh issue list --limit 10 --json title,labels
 
-// Fallback: use Glob to detect stack
-// Glob: "**/{package.json,*.csproj,*.sln,go.mod,Cargo.toml}"
+# Fallback: use Glob to detect stack
+# Glob: "**/{package.json,*.csproj,*.sln,go.mod,Cargo.toml}"
 ```
 
 ### Phase 2 (UI/UX) — Design References
@@ -143,7 +144,7 @@ await mcp__gemini_image_mcp__continue_editing({
 |------|----------|---------|
 | **Neon CLI (`neonctl`) / psql** | Database schema, tables, relationships, RLS | `psql <DB_URL> -c "SELECT ..."` |
 | **Context7** | Library docs for architecture decisions | `mcp__context7__query_docs()` |
-| **GitHub** | Check existing code patterns, PRs | `mcp__github__search_code()` |
+| **GitHub CLI (`gh`)** | Check existing code patterns, PRs | `gh search code` (Bash) |
 
 ```bash
 # === SCHEMA ANALYSIS (Critical for contracts.cs) ===
@@ -183,7 +184,7 @@ psql $(neonctl connection-string) -c "SELECT tablename, policyname, cmd, qual FR
 | MCP | Use Case | Example |
 |-----|----------|---------|
 | **Context7** | Verify library capabilities, API limits | `mcp__context7__query_docs()` |
-| **GitHub** | Check issue discussions, known limitations | `mcp__github__search_issues()` |
+| **GitHub CLI (`gh`)** | Check issue discussions, known limitations | `gh search issues` (Bash) |
 
 ```javascript
 // Verify if library supports a required feature
@@ -198,24 +199,17 @@ const docs = await mcp__context7__query_docs({
 
 ### Phase 6 (Tasks) — Planning & Organization
 
-| MCP | Use Case | Example |
-|-----|----------|---------|
-| **GitHub** | Create issues from tasks, link to milestone | `mcp__github__create_issue()` |
+| Tool | Use Case | Example |
+|------|----------|---------|
+| **GitHub CLI (`gh`)** | Create issues from tasks, link to milestone | `gh issue create` (Bash) |
 | **Context7** | Estimate complexity based on library docs | `mcp__context7__query_docs()` |
 
-```javascript
-// Create GitHub issues from tasks.json (if team uses GitHub Projects)
-for (const task of tasks) {
-  await mcp__github__create_issue({
-    title: task.title,
-    body: task.description,
-    labels: [task.category],
-    milestone: featureMilestone
-  });
-}
-
-// Fallback: Bash with gh CLI
-// gh issue create --title "T001: Create Entity Lead" --label "domain"
+```bash
+# Create GitHub issues from tasks.json (if team uses GitHub Projects)
+# — one `gh issue create` per task, iterating tasks.json:
+gh issue create --title "T001: Create Entity Lead" \
+  --body "description + doneCriteria da task" \
+  --label "backend" --milestone "feature-x"
 ```
 
 ### Phase 7 (Implement) — Build & Deploy
@@ -223,7 +217,7 @@ for (const task of tasks) {
 | Tool | Use Case | Example |
 |------|----------|---------|
 | **Neon CLI (`neonctl`) / psql** | Run migrations, create RLS policies | `dotnet ef database update` |
-| **GitHub** | Create PR, push branches | `mcp__github__create_pull_request()` |
+| **GitHub CLI (`gh`)** | Create PR, push branches | `gh pr create` (Bash) |
 | **Context7** | Look up API usage during coding | `mcp__context7__query_docs()` |
 | **Playwright** | Smoke test deployed features, verify UI | `mcp__playwright__browser_navigate()` |
 | **Vercel** | Deploy, check logs, manage env vars | `mcp__vercel__list_projects()` |
@@ -283,7 +277,7 @@ await mcp__vercel__manage_env_vars({
   target: ['production', 'preview']
 });
 
-// Fallback: Bash for gh CLI for PRs, vercel CLI for deployments
+// PRs/issues: sempre `gh` CLI (Bash). Deployments fallback: vercel CLI
 ```
 
 ---
@@ -293,7 +287,7 @@ await mcp__vercel__manage_env_vars({
 | Need | MCP Tool | Native Alternative |
 |------|----------|--------------------|
 | Database schema | Neon CLI (`neonctl`) / psql | Grep queries + Read types |
-| Repo metadata | GitHub MCP | Bash `gh` CLI |
+| Repo metadata / issues / PRs | Bash `gh` CLI | WebFetch `api.github.com` (read-only) |
 | Library docs | Context7 | WebSearch + WebFetch |
 | Live page preview | Playwright MCP | WebFetch URL |
 | Page interaction (click, type, navigate) | Playwright MCP | Manual testing |
@@ -304,7 +298,7 @@ await mcp__vercel__manage_env_vars({
 | Vercel deployments | Vercel MCP | Bash `vercel` CLI |
 | AI image generation | Gemini Image MCP | Manual creation or stock photos |
 
-**Rule:** MCP tools provide structured data (JSON responses). Native tools require manual parsing. **Always prefer MCP when available** — fall back to native when not. **Exceptions:** Neon, Docker, and Azure always use their respective CLIs directly — never MCP.
+**Rule:** MCP tools provide structured data (JSON responses). Native tools require manual parsing. **Always prefer MCP when available** — fall back to native when not. **Exceptions:** Neon, Docker, Azure **and GitHub** always use their respective CLIs directly — never MCP (`gh` já retorna JSON estruturado via `--json`, sem Docker nem PAT em env var).
 
 ---
 
@@ -445,16 +439,17 @@ const docs = await mcp__context7__query_docs({
 });
 ```
 
-### GitHub: Code Search Across Repo
+### GitHub: Code Search Across Repo (`gh` CLI — sem MCP)
 
-> **v4 config:** Docker — `{ "command": "docker", "args": ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"] }`. Requires Docker Desktop.
+O morph-spec **não instala nem usa MCP do GitHub**. O `gh` CLI (autenticado uma vez via `gh auth login`) cobre a mesma superfície com JSON estruturado, sem Docker e sem PAT em variável de ambiente:
 
-```javascript
-// Find patterns in large codebase during Phase 2
-const results = await mcp__github__search_code({
-  query: "DbSet leads repo:myorg/myrepo",
-});
-// → Find all places that query the leads table
+```bash
+# Find patterns in large codebase during Phase 2
+gh search code "DbSet leads" --repo myorg/myrepo --json path,textMatches
+# → Find all places that query the leads table
+
+# Qualquer endpoint REST sem subcomando dedicado:
+gh api repos/{owner}/{repo}/branches --jq '.[].name'
 ```
 
 ---
@@ -463,7 +458,7 @@ const results = await mcp__github__search_code({
 
 - **Never pass secrets** in MCP tool parameters (API keys, tokens, passwords)
 - **Neon** uses neonctl/psql — use database branches for development, not production
-- **GitHub MCP** inherits the configured token's permissions
+- **GitHub via `gh` CLI** herda as permissões do login do `gh auth login` (keyring) — sem PAT em env var, sem Docker
 - **Always validate tool responses** before using in contracts or code generation
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polymorphism-tech/morph-spec",
-  "version": "7.6.0",
+  "version": "7.7.0",
   "description": "MORPH-SPEC: NLH (Natural Language Harness) for spec-driven development with Claude Code",
   "keywords": [
     "claude-code",

package/src/commands/project/doctor.js

@@ -12,7 +12,7 @@ import {
   getInstalledCLIVersion
 } from '../../utils/version-checker.js';
 import { resetMorphSettings } from '../../utils/claude-settings-manager.js';
-import { checkMissingAgents } from '../../utils/agents-installer.js';
+import { checkMissingAgents, checkAgentsDrift } from '../../utils/agents-installer.js';
 import { getProjectTags } from '../../lib/stack-filter.js';
 
 const isWindows = platform() === 'win32';
@@ -186,6 +186,41 @@ async function doctorFullCommand(frameworkRoot) {
     } catch { /* ignore parse errors — already caught above */ }
   }
 
+  // ── 6b. Generated personas drift (.claude/agents ↔ agents.json) ─────────
+  // agents.json is the single source of truth; the .claude/agents/morph-*.md
+  // files are derived artifacts (ADR-001). Missing = broken dispatch (error);
+  // stale/hand-edited or orphan = drift (warning).
+  if (await pathExists(agentsPath)) {
+    console.log(chalk.cyan('\n  .claude/agents/ — Generated personas (drift vs agents.json)'));
+    try {
+      let projectTags = [];
+      const cfgPath = join(frameworkRoot, '.morph/config/config.json');
+      if (await pathExists(cfgPath)) {
+        try { projectTags = getProjectTags(JSON.parse(await fs.readFile(cfgPath, 'utf8'))); } catch { /* no tags */ }
+      }
+      const drift = checkAgentsDrift(frameworkRoot, join(frameworkRoot, '.morph/framework'), projectTags);
+      check(`Personas installed (${drift.expected - drift.missing.length}/${drift.expected})`,
+        drift.missing.length === 0, false,
+        drift.missing.length > 0 ? `missing: ${drift.missing.join(', ')} — run 'morph-spec setup-infra --reinstall'` : '');
+      check('Personas up-to-date (no drift)', drift.stale.length === 0, true,
+        drift.stale.length > 0 ? `stale/hand-edited: ${drift.stale.join(', ')} — regenerate via 'morph-spec setup-infra --reinstall'` : '');
+      check('No orphan morph-* agents', drift.orphans.length === 0, true,
+        drift.orphans.length > 0 ? `orphans: ${drift.orphans.join(', ')}` : '');
+    } catch {
+      check('personas drift check', false, true, 'failed to compute');
+    }
+  }
+
+  // ── 6c. GitHub tooling — gh CLI (canonical; morph-spec does not use a GitHub MCP) ──
+  console.log(chalk.cyan('\n  Tooling — GitHub via gh CLI'));
+  try {
+    execSync('gh --version', { stdio: 'pipe', timeout: 5000 });
+    check('gh CLI available', true);
+  } catch {
+    check('gh CLI available', false, true,
+      "GitHub ops (issues/PRs/releases) usam o gh CLI — instale https://cli.github.com e rode 'gh auth login'");
+  }
+
   // ── 7. state.json schema version ────────────────────────────────────────
   console.log(chalk.cyan('\n  .morph/state.json — Schema Version'));
   const statePath = join(frameworkRoot, '.morph/state.json');

package/src/commands/state/approve.js

@@ -1,6 +1,8 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { getFeature, setApprovalGate, getApprovalGate, getApprovalHistory } from '../../core/state/state-manager.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getFeature, setApprovalGate, getApprovalGate, getApprovalHistory, derivePhase } from '../../core/state/state-manager.js';
 
 /**
  * Unapprove action function - Revoke a previously approved gate
@@ -158,12 +160,23 @@ export async function approvalStatusCommand(featureName, options = {}) {
       process.exit(1);
     }
 
+    // v5 removed the stored feature.phase — derive it from the filesystem +
+    // approved gates (same as `morph-spec status`), never print "unknown".
+    const featurePath = join(process.cwd(), '.morph', 'features', featureName);
+    const phase = feature.phase || derivePhase(featurePath);
+
+    // The uiux branch is optional: a feature that never took it has no
+    // 1-design/ folder and no uiux approval — that is "n/a", not "rejected".
+    const uiuxGate = getApprovalGate(featureName, 'uiux');
+    const uiuxTaken = uiuxGate?.approved === true || existsSync(join(featurePath, '1-design'));
+
     // JSON output
     if (options.json) {
       const status = {
         feature: featureName,
-        phase: feature.phase,
+        phase,
         status: feature.status,
+        uiuxTaken,
         gates: {}
       };
 
@@ -179,7 +192,7 @@ export async function approvalStatusCommand(featureName, options = {}) {
     console.log('━'.repeat(60));
 
     // Show current phase
-    console.log(chalk.cyan(`\nCurrent Phase: ${feature.phase || 'unknown'}`));
+    console.log(chalk.cyan(`\nCurrent Phase: ${phase}`));
     console.log(chalk.gray(`Feature Status: ${feature.status || 'unknown'}\n`));
 
     // Show each gate
@@ -193,6 +206,11 @@ export async function approvalStatusCommand(featureName, options = {}) {
         continue;
       }
 
+      if (gateName === 'uiux' && !uiuxTaken) {
+        console.log(`  ${chalk.gray('—')} ${gateName}: ${chalk.gray('n/a (ramo de design não tomado)')}`);
+        continue;
+      }
+
       if (gateStatus.approved) {
         console.log(`  ${chalk.green('✓')} ${gateName}: ${chalk.green('Approved')}`);
         if (gateStatus.timestamp) {
@@ -202,7 +220,14 @@ export async function approvalStatusCommand(featureName, options = {}) {
           console.log(chalk.gray(`      Approved by: ${gateStatus.approvedBy}`));
         }
       } else {
-        console.log(`  ${chalk.red('✗')} ${gateName}: ${chalk.red('Rejected / Not Approved')}`);
+        // Distinguish "never evaluated" (initialized approved:false, no
+        // timestamp) from an explicit rejection/revocation (has timestamp).
+        const neverEvaluated = !gateStatus.timestamp && !gateStatus.rejectedAt && !gateStatus.revokedAt;
+        if (neverEvaluated) {
+          console.log(`  ${chalk.gray('○')} ${gateName}: ${chalk.gray('Pending (not yet evaluated)')}`);
+          continue;
+        }
+        console.log(`  ${chalk.red('✗')} ${gateName}: ${chalk.red('Rejected / Revoked')}`);
         if (gateStatus.reason) {
           console.log(chalk.gray(`      Reason: ${gateStatus.reason}`));
         }

package/src/commands/state/score.js

@@ -0,0 +1,88 @@
+import chalk from 'chalk';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getFeature, updateFeature } from '../../core/state/state-manager.js';
+
+/** Fixed --dims order: a,c,q,t (mirrors the morph-eval dimension weights). */
+const DIM_KEYS = ['architecture', 'contracts', 'codeQuality', 'testCoverage'];
+
+function parseScoreValue(raw, label) {
+  const value = Number(raw);
+  if (!Number.isFinite(value) || value < 0 || value > 10) {
+    console.error(chalk.red(`\n❌ Invalid ${label}: "${raw}" — expected a number between 0 and 10\n`));
+    process.exit(1);
+  }
+  return value;
+}
+
+/**
+ * `morph-spec score <feature> <task> <score> [--dims a,c,q,t]` — record a
+ * task eval score under `taskScores` in the authoritative feature.json.
+ *
+ * The timestamp is stamped server-side (`updatedAt`), the write is atomic
+ * (state-manager), attempts auto-increment and bestScore is kept — this
+ * replaces the fragile manual Edit of feature.json from the skills.
+ */
+export async function scoreCommand(featureName, taskId, scoreArg, options = {}) {
+  try {
+    const score = parseScoreValue(scoreArg, 'score');
+
+    const feature = getFeature(featureName);
+    if (!feature) {
+      console.error(chalk.red(`\n❌ Feature not found: ${featureName}\n`));
+      process.exit(1);
+    }
+
+    let dimensions;
+    if (options.dims) {
+      const parts = String(options.dims).split(',').map(s => s.trim());
+      if (parts.length !== DIM_KEYS.length) {
+        console.error(chalk.red(`\n❌ --dims expects ${DIM_KEYS.length} comma-separated values in order a,c,q,t (architecture,contracts,code-quality,test-coverage)\n`));
+        process.exit(1);
+      }
+      dimensions = {};
+      DIM_KEYS.forEach((key, i) => {
+        dimensions[key] = parseScoreValue(parts[i], `--dims ${key}`);
+      });
+    }
+
+    // Non-fatal sanity check: warn when the task id is unknown to tasks.json.
+    const tasksPath = join(process.cwd(), '.morph', 'features', featureName, '2-plan', 'tasks.json');
+    if (existsSync(tasksPath)) {
+      try {
+        const tasks = JSON.parse(readFileSync(tasksPath, 'utf8')).tasks || [];
+        if (!tasks.some(t => t.id === taskId)) {
+          console.error(chalk.yellow(`⚠️  Task "${taskId}" not found in tasks.json — recording anyway`));
+        }
+      } catch {
+        // unreadable tasks.json — the score is still worth recording
+      }
+    }
+
+    const prev = feature.taskScores?.[taskId];
+    const entry = {
+      lastScore: score,
+      bestScore: prev?.bestScore != null ? Math.max(prev.bestScore, score) : score,
+      attempts: (prev?.attempts ?? 0) + 1,
+      ...(dimensions ? { dimensions } : {}),
+      updatedAt: new Date().toISOString(),
+    };
+
+    await updateFeature(featureName, `taskScores.${taskId}`, entry);
+
+    if (options.json) {
+      console.log(JSON.stringify({ feature: featureName, task: taskId, ...entry }, null, 2));
+      return;
+    }
+
+    console.log(chalk.green(`\n✅ Score recorded: ${featureName}/${taskId} → ${entry.lastScore}`));
+    console.log(chalk.gray(`   best: ${entry.bestScore} | attempts: ${entry.attempts} | updatedAt: ${entry.updatedAt}`));
+    if (dimensions) {
+      console.log(chalk.gray(`   dims: arch=${dimensions.architecture} contracts=${dimensions.contracts} quality=${dimensions.codeQuality} tests=${dimensions.testCoverage}`));
+    }
+    console.log('');
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error recording score: ${error.message}\n`));
+    process.exit(1);
+  }
+}

package/src/commands/tasks/dag.js

@@ -0,0 +1,68 @@
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { parseTasksJson } from '../../lib/tasks/tasks-json-parser.js';
+import { planDispatch } from '../../lib/tasks/dispatch-planner.js';
+
+/**
+ * `morph-spec dag <feature>` — analyze the tasks.json DAG and print the
+ * sequential vs parallel dispatch decision, weighted by effort.
+ *
+ * This is the command morph-apply §2 runs instead of re-deriving the rules
+ * (and instead of the old inline JS snippets the LLM could not execute).
+ */
+export async function dagCommand(featureName, options = {}) {
+  try {
+    const tasksPath = join(process.cwd(), '.morph', 'features', featureName, '2-plan', 'tasks.json');
+    if (!existsSync(tasksPath)) {
+      console.error(chalk.red(`\n❌ tasks.json not found for feature "${featureName}"`));
+      console.error(chalk.gray(`Expected at: .morph/features/${featureName}/2-plan/tasks.json\n`));
+      process.exit(1);
+    }
+
+    // parseTasksJson validates the schema and throws with the error list.
+    const data = await parseTasksJson(tasksPath);
+    const plan = planDispatch(data);
+
+    if (options.json) {
+      console.log(JSON.stringify(plan, null, 2));
+      return;
+    }
+
+    console.log(chalk.bold(`\n📊 DAG — ${featureName}`));
+    console.log('━'.repeat(60));
+
+    const { stats } = plan;
+    console.log(`\nTasks: ${stats.total} total, ${stats.pending} pendente(s)`);
+    const groupLine = Object.keys(stats.groups)
+      .map(g => `${g}:${stats.groups[g]} (peso ${stats.weights[g]})`)
+      .join(' | ');
+    if (groupLine) console.log(chalk.gray(`Grupos pendentes: ${groupLine}`));
+
+    const modeLabel = {
+      'sequential': 'SEQUENCIAL (auto-advance)',
+      'parallel-flows': 'PARALELO por fluxo de domínio',
+      'parallel-roots': 'PARALELO por raízes independentes',
+    }[plan.mode];
+    console.log(chalk.cyan(`\nDecisão: ${modeLabel}`));
+    console.log(`  → ${plan.reason}`);
+
+    for (const flow of plan.flows) {
+      console.log(`  ${chalk.green('▶')} Fluxo ${chalk.bold(flow.group)} (peso ${flow.weight}): ${flow.taskIds.join(', ')}`);
+    }
+    if (plan.batch.length > 0) {
+      console.log(`  ${chalk.green('▶')} Batch paralelo: ${plan.batch.join(', ')}`);
+    }
+    if (plan.inline.length > 0) {
+      console.log(`  ${chalk.yellow('○')} Inline (sem dispatch próprio): ${plan.inline.join(', ')}`);
+    }
+    if (plan.sequentialRemainder.length > 0) {
+      console.log(`  ${chalk.gray('→')} Sequencial: ${plan.sequentialRemainder.join(', ')}`);
+    }
+
+    console.log('\n' + '━'.repeat(60) + '\n');
+  } catch (error) {
+    console.error(chalk.red(`\n❌ Error analyzing DAG: ${error.message}\n`));
+    process.exit(1);
+  }
+}