@polymorphism-tech/morph-spec 9.8.0 → 10.0.0

package/framework/hooks/statusline.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+// The payload is the source of truth: what Claude Code already computes (context, rate limits, worktree, PR) is
+// read, never recomputed. The feature line comes from the project's own installed rules, imported at runtime,
+// so this file carries no copy of them. Stateless: it never writes to disk.
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const R = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const BLUE = '\x1b[34m';
+const GRAY = '\x1b[90m';
+const WHITE = '\x1b[97m';
+const SEP = ` ${GRAY}│${R} `;
+
+const PHASE_INDEX = { plan: 0, uiux: 1, implement: 2, review: 3 };
+const PHASE_LABELS = { plan: 'planning', uiux: 'UI/UX', implement: 'implement', review: 'review' };
+const GATE_PHASES = new Set(['plan', 'uiux', 'review']);
+
+// Mirrors claude.exe: auto-compact fires at min(modelWindow, autoCompactWindow) − 20000 output reserve − 13000.
+// Reproducible only when `autoCompactWindow` is set in settings; any other source is server-driven.
+const COMPACT_OUTPUT_RESERVE = 20000;
+const COMPACT_HEADROOM = 13000;
+
+const int = (v, d = 0) => (Number.isFinite(Number(v)) && v !== null && v !== '' ? Math.trunc(Number(v)) : d);
+const num = (v, d = 0) => (Number.isFinite(Number(v)) && v !== null && v !== '' ? Number(v) : d);
+
+export function usageColor(pct) {
+  if (pct < 70) return GREEN;
+  return pct < 90 ? YELLOW : RED;
+}
+
+const EIGHTHS = '▏▎▍▌▋▊▉';
+
+// Eighth blocks keep a small nonzero value visible on a 5-wide gauge.
+export function progressBar(pct, width = 8) {
+  const exact = (Math.max(0, Math.min(100, pct)) / 100) * width;
+  const filled = Math.floor(exact);
+  let bar = '█'.repeat(filled);
+  if (filled < width) {
+    const remainder = Math.floor((exact - filled) * 8);
+    if (remainder) bar += EIGHTHS[remainder - 1];
+  }
+  return bar + '░'.repeat(width - [...bar].length);
+}
+
+export function formatTokens(n) {
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1).replace(/\.0$/, '')}M`;
+  if (n >= 1000) return `${Math.floor(n / 1000)}k`;
+  return String(n);
+}
+
+export function formatCountdown(epoch, now = Date.now() / 1000) {
+  const remaining = epoch - now;
+  if (remaining <= 0) return null;
+  const days = Math.floor(remaining / 86400);
+  const rest = Math.floor(remaining % 86400);
+  const hours = Math.floor(rest / 3600);
+  const minutes = Math.floor((rest % 3600) / 60);
+  if (days) return `${days}d${String(hours).padStart(2, '0')}`;
+  if (hours) return `${hours}h${String(minutes).padStart(2, '0')}`;
+  return `${minutes}m`;
+}
+
+// OSC included: an OSC 8 hyperlink carries its URL as an invisible payload.
+const ANSI_RE = /\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b\[[0-9;]*m/g;
+// ⏳ renders double (Emoji_Presentation) while the gauge glyphs render single.
+const WIDE_SINGLES = new Set([...'⚡⛔⬛⬜✅❌⏳']);
+
+export function visibleWidth(text) {
+  let width = 0;
+  for (const ch of text.replace(ANSI_RE, '')) {
+    const code = ch.codePointAt(0);
+    width += (code >= 0x1f300 && code <= 0x1faff) || WIDE_SINGLES.has(ch) ? 2 : 1;
+  }
+  return width;
+}
+
+/** Joins `[priority, text]` parts with SEP, dropping the highest priority number until it fits `columns`. */
+export function joinToWidth(parts, columns) {
+  const kept = parts.filter(([, text]) => text);
+  if (!kept.length) return '';
+  const sep = visibleWidth(SEP);
+  const total = () => kept.reduce((sum, [, text]) => sum + visibleWidth(text), 0) + sep * Math.max(0, kept.length - 1);
+  if (columns) {
+    while (kept.length > 1 && total() > columns) {
+      let worst = 0;
+      kept.forEach(([p], i) => { if (p > kept[worst][0]) worst = i; });
+      kept.splice(worst, 1);
+    }
+  }
+  return kept.map(([, text]) => text).join(SEP);
+}
+
+function readUserSettings(env = process.env) {
+  try {
+    const base = env.CLAUDE_CONFIG_DIR || join(homedir(), '.claude');
+    const data = JSON.parse(readFileSync(join(base, 'settings.json'), 'utf8'));
+    return data && typeof data === 'object' ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+function git(args, cwd) {
+  return execFileSync('git', args, { cwd, stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000, windowsHide: true }).toString('utf8').trim();
+}
+
+// `-uno`: porcelain v2 lists untracked entries by default, which would change what the file count means.
+function gitInfo(cwd) {
+  let out;
+  try { out = git(['status', '--porcelain=v2', '--branch', '-uno'], cwd); } catch { return ''; }
+  let branch = '';
+  let ahead = 0;
+  let behind = 0;
+  let files = 0;
+  for (const line of out.split(/\r?\n/)) {
+    if (line.startsWith('# branch.head ')) branch = line.slice(14).trim();
+    else if (line.startsWith('# branch.ab ')) {
+      const m = /# branch\.ab \+(\d+) -(\d+)/.exec(line);
+      if (m) { ahead = Number(m[1]); behind = Number(m[2]); }
+    } else if ('12u'.includes(line[0] ?? 'x')) files += 1;
+  }
+  if (!branch) return '';
+  let ins = 0;
+  let dels = 0;
+  if (files) {
+    try {
+      const stat = git(['diff', 'HEAD', '--shortstat'], cwd);
+      ins = Number(/(\d+) insertion/.exec(stat)?.[1] ?? 0);
+      dels = Number(/(\d+) deletion/.exec(stat)?.[1] ?? 0);
+    } catch { /* no diff stats */ }
+  }
+  const parts = [`${BLUE} ${branch}${R}`];
+  if (ahead || behind) parts.push(`${ahead ? `${GREEN}↑${ahead}${R}` : ''}${behind ? `${RED}↓${behind}${R}` : ''}`);
+  if (ins || dels) parts.push(`${GREEN}+${ins}${RED}-${dels}${R}`);
+  return parts.join(' ');
+}
+
+const samePath = (a, b) => {
+  try { return realpathSync(a).toLowerCase() === realpathSync(b).toLowerCase(); } catch { return false; }
+};
+
+/** Worktree name of this session, or null in the primary tree. */
+export function worktreeLabel(payload, cwd) {
+  if (payload.worktree?.name) return (payload.worktree.branch || '').replace('refs/heads/', '') || payload.worktree.name;
+  if (payload.workspace?.git_worktree) return payload.workspace.git_worktree;
+  if (!existsSync(join(cwd, '.morph', 'features'))) return null;
+  let out;
+  try { out = git(['worktree', 'list', '--porcelain'], cwd); } catch { return null; }
+  const entries = [];
+  let current = null;
+  for (const line of out.split(/\r?\n/)) {
+    if (line.startsWith('worktree ')) { current = { path: line.slice(9) }; entries.push(current); }
+    else if (line.startsWith('branch ') && current) current.branch = line.slice(7);
+  }
+  const mine = entries.slice(1).find((e) => samePath(e.path, cwd));
+  return mine ? (mine.branch || '').replace('refs/heads/', '') || null : null;
+}
+
+async function importShared(projectDir, name) {
+  const path = join(projectDir, '.morph', 'framework', 'hooks', 'shared', name);
+  return existsSync(path) ? import(pathToFileURL(path).href) : null;
+}
+
+/** In-progress features with phase, scenario progress and the open gate, read through the project's own rules. */
+export async function activeFeatures(projectDir) {
+  const base = join(projectDir, '.morph', 'features');
+  if (!existsSync(base)) return [];
+  let stateReader;
+  let progressRules;
+  try {
+    [stateReader, progressRules] = await Promise.all([importShared(projectDir, 'state-reader.js'), importShared(projectDir, 'report-progress.js')]);
+  } catch {
+    return [];
+  }
+  if (!stateReader?.derivePhaseForFeature) return [];
+  const out = [];
+  for (const name of readdirSync(base).sort()) {
+    let feature;
+    try { feature = JSON.parse(readFileSync(join(base, name, 'feature.json'), 'utf8').replace(/^/, '')); } catch { continue; }
+    if (feature?.status !== 'in_progress') continue;
+    let phase = 'plan';
+    try { phase = stateReader.derivePhaseForFeature(name, projectDir) || 'plan'; } catch { /* plan */ }
+    const progress = progressRules?.implementProgress?.(join(base, name)) ?? null;
+    const gates = feature.approvalGates || {};
+    out.push({
+      name,
+      phase,
+      done: progress?.done ?? 0,
+      total: progress?.total ?? 0,
+      pending: GATE_PHASES.has(phase) && gates[phase]?.approved !== true ? phase : null,
+    });
+  }
+  return out;
+}
+
+export function renderFeatureLine(feature, columns) {
+  const parts = [[0, `${CYAN}${BOLD}► ${feature.name}${R}`]];
+  const position = PHASE_INDEX[feature.phase];
+  const label = PHASE_LABELS[feature.phase] ?? feature.phase;
+  parts.push([1, position === undefined ? `${CYAN}${label}${R}` : `${CYAN}${label} ${position + 1}/4${R}`]);
+  if (feature.total > 0) {
+    parts.push([3, `${GREEN}${progressBar((feature.done / feature.total) * 100, 6)} ${feature.done}/${feature.total} cenários${R}`]);
+  }
+  if (feature.pending) parts.push([2, `${RED}⛔ gate: ${feature.pending}${R}`]);
+  return joinToWidth(parts, columns);
+}
+
+/** The window /context divides by — not the model window — or null when not reproducible. */
+export function effectiveWindow(payload, settings) {
+  const modelWindow = int(payload.context_window?.context_window_size);
+  if (modelWindow <= 0) return null;
+  if (settings.autoCompactEnabled === false) return modelWindow;
+  const configured = int(settings.autoCompactWindow);
+  return configured > 0 ? Math.min(modelWindow, configured) : null;
+}
+
+export function compactThreshold(payload, settings) {
+  if (settings.autoCompactEnabled === false || int(settings.autoCompactWindow) <= 0) return null;
+  const window = effectiveWindow(payload, settings);
+  if (!window) return null;
+  const threshold = window - COMPACT_OUTPUT_RESERVE - COMPACT_HEADROOM;
+  return threshold > 0 ? threshold : null;
+}
+
+export function renderStatusLine(payload, cwd, settings, columns, { gitLine = gitInfo, now } = {}) {
+  const parts = [];
+  const model = payload.model;
+  const modelName = model && typeof model === 'object' ? model.display_name || model.id || '' : String(model || '');
+  if (modelName) {
+    const short = modelName.replace('Claude ', '').replace('claude-', '').replace(' (1M context)', ' 1M').replace(' (claude.ai)', '');
+    const state = [];
+    if (payload.effort?.level) state.push(payload.effort.level);
+    if (payload.thinking?.enabled === false) state.push('no-think');
+    if (payload.fast_mode) state.push('fast');
+    parts.push([3, `${WHITE}${short}${R}${state.length ? `${GRAY}·${state.join('·')}${R}` : ''}`]);
+  }
+
+  const context = payload.context_window;
+  if (context && typeof context === 'object' && Object.keys(context).length) {
+    const modelWindow = int(context.context_window_size);
+    let tokens = int(context.total_input_tokens);
+    // Null right after /compact: the app's own input-only sum; output tokens are not part of it.
+    if (!tokens && context.current_usage && typeof context.current_usage === 'object') {
+      const u = context.current_usage;
+      tokens = int(u.input_tokens) + int(u.cache_creation_input_tokens) + int(u.cache_read_input_tokens);
+    }
+    const window = effectiveWindow(payload, settings);
+    let pct = null;
+    if (window && tokens) pct = (tokens / window) * 100;
+    else if (context.used_percentage !== undefined && context.used_percentage !== null) pct = num(context.used_percentage);
+    else if (modelWindow && tokens) pct = (tokens / modelWindow) * 100;
+    if (pct !== null) {
+      let chunk = `${usageColor(pct)}${progressBar(pct, 8)} ${pct.toFixed(0)}%${R}`;
+      const threshold = compactThreshold(payload, settings);
+      if (threshold && tokens) {
+        const left = threshold - tokens;
+        if (left <= 0) chunk += ` ${RED}⚠ compactando${R}`;
+        else {
+          const leftPct = (left / threshold) * 100;
+          chunk += ` ${leftPct > 25 ? GRAY : leftPct > 10 ? YELLOW : RED}↻ ${formatTokens(left)}${R}`;
+        }
+      }
+      parts.push([0, chunk]);
+    }
+  }
+
+  const limits = payload.rate_limits || {};
+  for (const [key, label, priority, countdown] of [['five_hour', '⏳', 2, true], ['seven_day', '📅', 5, false]]) {
+    const raw = limits[key]?.used_percentage;
+    if (raw === undefined || raw === null) continue;
+    const pct = num(raw);
+    let chunk = `${GRAY}${label}${R} ${usageColor(pct)}${pct.toFixed(0)}%${R}`;
+    const until = countdown && limits[key]?.resets_at ? formatCountdown(num(limits[key].resets_at), now) : null;
+    if (until) chunk += ` ${GRAY}↻ ${until}${R}`;
+    parts.push([priority, chunk]);
+  }
+
+  const branch = gitLine(cwd);
+  if (branch) parts.push([1, branch]);
+
+  const pr = payload.pr || {};
+  if (pr.number) {
+    const mark = { approved: '✓', changes_requested: '✗', draft: '·', pending: '…' }[pr.review_state] ?? '';
+    const color = { approved: GREEN, changes_requested: RED, draft: GRAY }[pr.review_state] ?? YELLOW;
+    let label = `PR #${pr.number} ${mark}`.trim();
+    if (pr.url) label = `\x1b]8;;${pr.url}\x1b\\${label}\x1b]8;;\x1b\\`;
+    parts.push([4, `${color}${label}${R}`]);
+  }
+  return joinToWidth(parts, columns);
+}
+
+async function readStdin() {
+  let raw = '';
+  for await (const chunk of process.stdin) raw += chunk;
+  return raw;
+}
+
+export async function main(raw, env = process.env, write = (s) => process.stdout.write(`${s}\n`)) {
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (!payload || typeof payload !== 'object') return;
+  try {
+    const cwd = payload.workspace?.current_dir || payload.cwd || process.cwd();
+    const projectDir = payload.workspace?.project_dir || cwd;
+    const columns = int(env.COLUMNS);
+    // Only in a secondary worktree: in the primary tree the line resurrects stale feature names.
+    if (worktreeLabel(payload, cwd)) {
+      for (const feature of await activeFeatures(projectDir)) write(renderFeatureLine(feature, columns));
+    }
+    const line = renderStatusLine(payload, cwd, readUserSettings(env), columns);
+    if (line) write(line);
+  } catch (err) {
+    write(`${RED}ERRO: ${err?.message ?? err}${R}`);
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main(await readStdin());
+}

package/framework/phases.json

@@ -11,10 +11,16 @@
         "Write plan.md — scenarios with proof, decisions, reuse and slices",
         "Run plan-check to produce checks.json and reach the plan gate"
       ],
-      "requiredOutputs": ["plan", "checks"],
+      "requiredOutputs": [
+        "plan",
+        "checks"
+      ],
       "optionalOutputs": [],
       "pausePoints": [
-        { "id": "plan", "label": "Gate do plano — Approve plan.md + checks.json" }
+        {
+          "id": "plan",
+          "label": "Gate do plano — Approve plan.md + checks.json"
+        }
       ],
       "skill": "morph-plan"
     },
@@ -28,10 +34,15 @@
         "Define design system tokens and components",
         "Produce mockups and user flows"
       ],
-      "requiredOutputs": ["uiDesignSystem"],
-      "optionalOutputs": ["uiMockups", "uiComponents", "uiFlows"],
+      "requiredOutputs": [],
+      "optionalOutputs": [
+        "uiMockups"
+      ],
       "pausePoints": [
-        { "id": "uiux", "label": "Approve UI/UX" }
+        {
+          "id": "uiux",
+          "label": "Approve UI/UX"
+        }
       ],
       "skill": "morph-uiux"
     },
@@ -46,7 +57,10 @@
         "One report per slice (3-implement/reports/F{n}.md, with **Arquivos:** and **Standards:**) — the implementation record"
       ],
       "requiredOutputs": [],
-      "optionalOutputs": ["evidencias"],
+      "optionalOutputs": [
+        "implementReport",
+        "evidencias"
+      ],
       "pausePoints": [],
       "skill": "morph-apply"
     },
@@ -59,12 +73,20 @@
         "Verifier proves every scenario; reviewer (and security, when required) judge the diff at a fixed SHA",
         "verifier.md + reviewer.md (+ security.md) with SHIP/FIX and evidence-typed blockers, then Gate 3"
       ],
-      "requiredOutputs": ["verifierReport", "reviewerReport"],
-      "optionalOutputs": ["securityReport"],
+      "requiredOutputs": [
+        "verifierReport",
+        "reviewerReport"
+      ],
+      "optionalOutputs": [
+        "securityReport"
+      ],
       "pausePoints": [
-        { "id": "review", "label": "Gate 3 — Approve the review reports" }
+        {
+          "id": "review",
+          "label": "Gate 3 — Approve the review reports"
+        }
       ],
-      "skill": "morph-review"
+      "skill": "morph-apply"
     }
   }
 }

package/framework/rules/ai-agents-standards.md

@@ -9,6 +9,14 @@ stacks:
 
 # Microsoft Agent Framework Standards
 
+**Ponto de vista:** especialista no Microsoft Agent Framework (MAF 1.0 GA).
+- Sweet-spot primeiro: single-agent + structured output + tools + RAG custom resolvem 95%. Semantic Kernel e Workflows só com fan-in/out genuíno.
+- Alias do Model Registry, nunca modelo cravado; providers diretos (OpenAI/Google/Anthropic/Ollama), nunca hosted agent service. Para OpenAI o padrão é a Responses API; alias sem `api` significa `responses`, Chat Completions é opt-in declarado.
+- Telemetria por `UseOpenTelemetry(sourceName, configure)` no builder, nos DOIS níveis (agente e chat client), `EnableSensitiveData` desligado fora de dev. `AgentOpenTelemetryConsts` e `agent.WithOpenTelemetry()` NÃO existem no pin; nomes de ActivitySource, span e métrica vêm de `ai-agents-observability-patterns`, nunca deduzidos.
+- Histórico de conversa: tabela/jsonb do projeto exposta por um `ChatHistoryProvider` seu (`store: false`), nunca o `AgentSession` — ele só serve quando o histórico é SÓ a lista de mensagens, sem campo de negócio nem leitura fora do agente.
+- Instruções e tools por fase: compositor determinístico em C# (um record Instructions + Tools escolhido por switch antes de montar `ChatOptions`), nem context provider nem tool — `AIContext.Tools` só ACRESCENTA tools.
+- A lista abaixo é o ponto de partida: antes de concluir que um assunto não tem standard, `morph-spec standards --find "<tema>" --category ai-agents`.
+
 > **Layer 0/1 — resumo injetado pela rule.** São os standards core: aplicam-se a praticamente todo
 > agente MAF. O resumo de cada um entra no contexto quando você toca código de agentes.
 
@@ -30,7 +38,7 @@ stacks:
 
 > **Layer 2 — sob demanda (sem resumo aqui).** São standards de modalidade, otimização e
 > MCP: relevantes apenas quando a feature usa especificamente esse recurso. Busque via
-> `morph-spec standards --find` (skill `morph-standards`) quando uma keyword corresponder — manter fora do resumo preserva o
+> `morph-spec standards --find` quando uma keyword corresponder — manter fora do resumo preserva o
 > context window para o trabalho que importa.
 
 | Standard | Carregue quando a feature envolve |

package/framework/rules/csharp-standards.md

@@ -8,6 +8,8 @@ stacks:
 
 # C# and .NET VSA Standards
 
+**Ponto de vista:** engenheiro .NET sênior em VSA. Handler direto com `ApplicationDbContext` injetado no slice (`DbSet<T>` já é repository, o `DbContext` já é unit of work); concorrência ou SQL específico → store dedicado escrito à mão, com ADR no `plan.md`. Nunca camada Service/Manager, nunca `IRepository<T>`/`IUnitOfWork`, nunca exceção como fluxo. Abra o standard antes de escrever cada slice.
+
 - **architecture-vertical-slice-vertical-slice** (`architecture/vertical-slice/vertical-slice.md`) — Uma slice por operação em `Features/{Entity}Feature/{Verb}{Entity}/`: Request/Response `record`, Handler, Validator e Endpoint `IApiEndpoint`. Decorators Scrutor: Logging → Validation → Handler. PROIBIDO: MediatR/`IRequest`, AggregateRoot, DomainEvent, CQRS formal, camada Application Service, DTO compartilhado entre features, `IRepository<T>`/`IUnitOfWork`.
 - **backend-dotnet-vsa-handler-patterns** (`backend/dotnet/vsa-handler-patterns.md`) — Handler implementando `IHandler<TRequest, TResponse>` (não MediatR): injeta `ApplicationDbContext` direto e devolve `Result<T>`. Erros em `{Feature}Errors.cs`. SQL cru ou store dedicado só com justificativa em `plan.md` (`## Decisões`).
 - **backend-dotnet-result-pattern** (`backend/dotnet/result-pattern.md`) — Falha esperada é `Result`/`Result<T>`, nunca exceção. Endpoint: `result.Match(value => Results.Ok(value), error => error.ToHttpResult())`; nunca leia `.Value` fora do `Match`. Status pelo `ErrorType` (Validation 400, NotFound 404, Conflict 409, Unauthorized 401, Forbidden 403, Unexpected 500), nunca BadRequest para tudo. PROIBIDO: try/catch no handler, retornar null, erro string sem código.
@@ -19,4 +21,6 @@ stacks:
 - **architecture-code-comments** (`architecture/code-comments.md`) — Padrão é nenhum comentário: renomeie, extraia, tipe ou teste antes. Só o porquê que o código não mostra (invariante, ordem, quirk externo com link), até ~3 linhas. PROIBIDO: história de processo (task, UC, ADR, Gate), repetir o código, XML doc/JSDoc que repete a assinatura, banner, `#region`, código comentado, TODO solto. O hook `comment-guard` bloqueia.
 - **architecture-engineering-lens** (`architecture/engineering-lens.md`) — Escreva para quem herda amanhã: convenção do projeto, o mais simples, causa raiz. PROIBIDO no que você adiciona: `catch` que engole, flag booleana que bifurca o método (são dois métodos), efeito colateral escondido, símbolo/flag/config sem consumidor, abstração ou camada sem segundo uso, literal repetido sem constante. Nomes de domínio buscáveis, funções pequenas, ≤ 3 parâmetros, condicional positiva. Commit em Conventional Commits (hook `conventional-commit`).
 
+- **backend-dotnet-testing** (`backend/dotnet/testing.md`) — Injete `TimeProvider` (nunca `DateTime.UtcNow` direto em handler ou validator) e use `FakeTimeProvider` no teste de integração. Teste por risco: um por cenário com `risco:`, a pós-condição no nome do teste.
+
 > Resumo injetado quando você lê ou edita um arquivo casado por `paths:`. Texto completo: `morph-spec standards --find "<id>"` e leia só a seção necessária de `.morph/framework/standards/<path>`.

package/framework/rules/ef-standards.md

@@ -0,0 +1,20 @@
+---
+paths:
+  - "**/Migrations/**"
+  - "**/*DbContext*.cs"
+  - "**/*Configuration.cs"
+  - "**/Entities/**"
+stacks:
+  - dotnet
+---
+
+# EF Core + Neon Standards
+
+**Ponto de vista:** especialista em EF Core sobre Neon (Postgres). Migrations explícitas, configuração fluente, navigation properties bem nomeadas, índice intencional. Nunca vaze o `DbContext` para fora do handler. Entidade duplicada vira migration divergente: confira a tabela `## Reuso` do plano antes de criar uma.
+
+- **backend-database-postgresql-database** (`backend/database/postgresql/database.md`) — Tabelas snake_case no plural, colunas snake_case, PK `id uuid primary key` sem default na coluna: a app gera com `Guid.CreateVersion7()` (linha inserida fora da app passa o id explícito).
+- **infrastructure-neon-setup** (`infrastructure/neon/neon-setup.md`) — Duas connection strings por `IConfiguration`: `DefaultConnection` no endpoint `-pooler` para o tráfego da app e `MigrationConnection` direta para as migrations.
+- **infrastructure-neon-pgvector** (`infrastructure/neon/neon-pgvector.md`) — Npgsql.EntityFrameworkCore.PostgreSQL + Pgvector.EntityFrameworkCore, colunas mapeadas por `HasColumnName`, `HasPostgresExtension("vector")` no `OnModelCreating`.
+- **backend-dotnet-testing** (`backend/dotnet/testing.md`) — `TimeProvider` injetado e `FakeTimeProvider` no teste; teste de integração contra o banco real do stack, um por cenário com `risco:`.
+
+> Resumo injetado quando você lê ou edita um arquivo casado por `paths:`. Texto completo: `morph-spec standards --find "<id>"` e leia só a seção necessária de `.morph/framework/standards/<path>`.

package/framework/rules/frontend-standards.md

@@ -10,6 +10,6 @@ stacks:
 # Frontend Standards
 
 - **frontend-design-system-animations** (`frontend/design-system/animations.md`) — Lista escalonada exige `animation-delay` E `animation-fill-mode: backwards` (senão pisca antes do atraso). Sempre o bloco `prefers-reduced-motion: reduce`. Além do CSS: Motion (`motion/react`) para enter/exit/layout; GSAP só para ScrollTrigger, SVG morph e timelines.
-- **frontend-design-system-art-direction** (`frontend/design-system/art-direction.md`) — Tela nova ou alterada segue a direção escrita em `1-design/direcao.md` e o protótipo de `1-design/prototipos/`: celular composto (folha inferior, alvos de 44px), movimento só em `transform`/`opacity` com versão estática em `prefers-reduced-motion`, nenhum número inventado em cena ilustrativa.
+- **frontend-design-system-art-direction** (`frontend/design-system/art-direction.md`) — Tela nova ou alterada segue a `**Direção escolhida:**` do `1-design/mockups.md` e o protótipo de `1-design/prototipos/`: celular composto (folha inferior, alvos de 44px), movimento só em `transform`/`opacity` com versão estática em `prefers-reduced-motion`, nenhum número inventado em cena ilustrativa.
 
 > Resumo injetado quando você lê ou edita um arquivo casado por `paths:`. Texto completo: `morph-spec standards --find "<id>"` e leia só a seção necessária de `.morph/framework/standards/<path>`.

package/framework/rules/implement-report.md

@@ -0,0 +1,25 @@
+---
+paths:
+  - ".morph/features/*/3-implement/report.md"
+---
+
+# Formato do report.md
+
+A memória da implementação depois de um `/compact` e o que o `next` lê para decidir o passo.
+
+```markdown
+| Cn | status | evidência |
+|----|--------|-----------|
+| C1 | feito | `OrdersTests.RecusaSemItens` |
+| C2 | feito | `src/Orders/List.cs:31` |
+| C3 | bloqueado | |
+
+## Notas
+- 2026-10-27 — C3: o plano não diz se pedido cancelado volta ao estoque. Pergunta: devolve?
+```
+
+- Status: `pendente` | `feito` | `bloqueado`. Uma linha por `Cn` do `checks.json`, sem inventar nem pular.
+- `feito` exige evidência: o teste que prova, o `arquivo:linha` (`prova: leitura`) ou `evidencias/{Cn}.md` (`eval`/`manual`). `feito` sem evidência é o que o hook de Stop aponta.
+- `bloqueado` só com a pergunta em `## Notas`: o `next` devolve `decide` e ela vira `AskUserQuestion`. Respondida, a resposta vai em `## Notas` e o `Cn` volta a `pendente`.
+- `## Notas` é append-only, uma linha datada por decisão ou fato novo. Fato errado do plano vai na `## Errata` do `plan.md`, não aqui.
+- Atualize ao fechar cada `Cn` e commite junto (`wip(<f>): Cn …`).

package/framework/rules/infrastructure-standards.md

@@ -10,6 +10,8 @@ stacks:
 
 # Infrastructure Standards
 
+**Ponto de vista:** jobs assíncronos (Hangfire só com razão real), deploy e observabilidade — retry, idempotência, dead-letter, métricas. Não invente infra: use o que o stack já oferece. GitHub (issues, PRs, releases, Actions) sempre pelo `gh` no Bash, nunca MCP. Coolify sempre por SSH + `curl` na API local — não há MCP nem CLI; o token é lido do lado do servidor e nunca impresso. Recurso pago acima de US$ 10/mês → ADR em `## Decisões` antes de criar.
+
 - **infrastructure-docker-coolify-deploy** (`infrastructure/docker/coolify-deploy.md`) — Acesso só por SSH na VPS, API do Coolify em `localhost:8000/api/v1` com token server-side (nunca impresso). Env vars no Coolify, nunca no Dockerfile. Endpoint `/health`. Redeploy por `POST /api/v1/deploy?uuid=` (GET não deploya); sem `deployment_uuid` na resposta, nada foi deployado.
 - **infrastructure-docker-local-compose-isolation** (`infrastructure/docker/local-compose-isolation.md`) — Cada worktree roda o próprio stack compose; portas do bloco da worktree (`PORT`, `API_PORT`, `POSTGRES_PORT`, `REDIS_PORT`) publicadas como `${VAR:-default}:container`. PROIBIDO: porta fixa no host, `container_name`. Healthcheck em todo serviço. Compose que lê a porta por outro nome: declare em `e2e.portEnvNames`.
 

package/framework/rules/nextjs-standards.md

@@ -8,6 +8,8 @@ stacks:
 
 # Next.js Standards
 
+**Ponto de vista:** Next.js App Router idiomático — Server Component por padrão, Client Component só com interação real; Tailwind + shadcn + Motion; tipos por Zod. Tipo local redeclarado em cada arquivo é o defeito mais comum aqui: confira a tabela `## Reuso` do plano antes de criar um tipo.
+
 - **frontend-nextjs-lint** (`frontend/nextjs/lint.md`) — O lint cobra o mecânico: `framer-motion`, Zustand/Redux, driver de banco, Form legado, deep import de feature, fronteiras `components`/`features`/`app`/`hooks`, fetch em `useEffect`, `'use client'` no layout raiz, `export default` fora de rota, `any`. O `verify` roda o eslint nos arquivos da feature quando há `eslint.config.*`; sem `eslint.config.mjs`: `morph-spec standards --show frontend-nextjs-lint#files`. Regra mecânica nova vira linha nele, nunca prosa.
 - **frontend-nextjs-naming-conventions** (`frontend/nextjs/naming-conventions.md`) — Arquivo SEMPRE kebab-case (`user-card.tsx`); componente PascalCase. Zod em `.schemas.ts`, tipos em `.types.ts` via `z.infer`. Nunca misture casos na mesma categoria.
 - **frontend-nextjs-project-structure** (`frontend/nextjs/project-structure.md`) — `src/app/` só roteia; a lógica da tela mora em `src/features/{f}/` (`components/`, `hooks/`, `types/`, `index.ts` como API pública). NUNCA uma feature importa outra (extraia para `components/` ou `lib/`); `components/ui/` é shadcn e não se edita.
@@ -22,4 +24,9 @@ stacks:
 - **architecture-code-comments** (`architecture/code-comments.md`) — Padrão é nenhum comentário: renomeie, extraia, tipe ou teste antes. Só o porquê que o código não mostra (invariante, ordem, quirk externo com link), até ~3 linhas. PROIBIDO: história de processo (task, UC, ADR, Gate), repetir o código, XML doc/JSDoc que repete a assinatura, banner, `#region`, código comentado, TODO solto. O hook `comment-guard` bloqueia.
 - **architecture-engineering-lens** (`architecture/engineering-lens.md`) — Escreva para quem herda amanhã: convenção do projeto, o mais simples, causa raiz. PROIBIDO no que você adiciona: `catch` que engole, flag booleana que bifurca o método (são dois métodos), efeito colateral escondido, símbolo/flag/config sem consumidor, abstração ou camada sem segundo uso, literal repetido sem constante. Nomes de domínio buscáveis, funções pequenas, ≤ 3 parâmetros, condicional positiva. Commit em Conventional Commits (hook `conventional-commit`).
 
+- **frontend-admin-app-data-table** (`frontend/admin-app/data-table.md`) — Toda lista do admin pagina, ordena e filtra no servidor, com `page/pageSize/sort/dir/filters` na URL (Zod com `.catch`) e a API devolvendo `{ items, totalCount }` sobre um `OrderBy` com desempate único.
+- **frontend-admin-app-forms** (`frontend/admin-app/forms.md`) — O padrão de `nextjs/forms.md` mais os deltas de CRUD: `ValidationProblemDetails` do .NET mapeado para cada campo por `setError`.
+- **frontend-admin-app-feedback** (`frontend/admin-app/feedback.md`) — Um `ConfirmDialog` (AlertDialog controlado) só para ação destrutiva irreversível, em lote ou que descarta mudança; ação reversível usa toast com desfazer.
+- **frontend-admin-app-page-structure** (`frontend/admin-app/page-structure.md`) — Decida por tela e registre no checklist do mockup: abas para 3+ seções independentes, página longa com navegação fixa quando lidas juntas, wizard quando um campo depende do anterior.
+
 > Resumo injetado quando você lê ou edita um arquivo casado por `paths:`. Texto completo: `morph-spec standards --find "<id>"` e leia só a seção necessária de `.morph/framework/standards/<path>`.

package/framework/rules/plan-grammar.md

@@ -0,0 +1,53 @@
+---
+paths:
+  - ".morph/features/*/2-plan/plan.md"
+---
+
+# Gramática do plan.md
+
+`plan-check` é o único leitor: o que ele não reconhece, ninguém lê. Referência completa: `morph-spec plan-check --help`.
+
+## Cenários
+
+`- **Cn** — Dado …, quando …, então …`, com `prova:` **na linha seguinte, sem linha em branco** (linha vazia encerra o cenário).
+
+- **Teste é por risco, não por código novo.** `prova: teste` exige `risco:` (`regra` | `dinheiro` | `contrato` | `concorrência` | `dado` | `regressão`): ramo de regra de negócio, valor, contrato externo, corrida, integridade de dado ou o bug real. Sem risco (CRUD, DTO, mapping, wiring, constante, texto, layout) a prova é `leitura` — o verificador fecha por `arquivo:linha` — ou `e2e` quando o fluxo é o que importa.
+- **Degrau de retrabalho** (opcional, junto de `prova:`): `degrau:` `refazer` | `desfazer` | `migrar` | `irreversível`; sem a linha, `refazer`. `migrar` é toda migration, aditiva ou não (drop, rename, backfill, coluna nova); `irreversível` apaga dado que alguém lê ou quebra contrato externo. Os dois pausam o gate do plano para o usuário, e o Gate 3 pausa quando a feature toca `migrations/` sem nenhum dos dois, ou um arquivo de contrato (`openapi.yaml`, `swagger.json`, `.proto`) sem `irreversível`; o revisor do Gate 3 caça o resto (webhook, dado apagado fora de migration, envio a terceiro).
+- **Observável**: que asserção, ou que passo no navegador, prova? Sem resposta, reescreva ou descarte.
+- **Artefato não é comportamento.** Cenário que cita `grep`, "contém a string", "o binário", "nenhum arquivo", "arquivo/pasta/diretório em" ou glob `**/` descreve o repositório. Tente o efeito em runtime; se o artefato É o entregável, justifique em `> Por que artefato:` logo abaixo (nunca na mesma linha, nunca `> [!note]`, que o parser não lê).
+- **Saída de LLM** prova-se por `eval` de runtime, nunca pelo texto do prompt: evidência em `3-implement/evidencias/{Cn}.md`; com nó `runner: "evals"` (standard `ai-agents-evals-with-cache`) o cenário mora no dataset.
+- **"A suíte roda de ponta a ponta"** prova-se pelo `verify {feature}`; nunca uma execução avulsa.
+- **Orçamento de teste:** um teste por cenário de risco; variantes são linhas de tabela (`[Theory]`/`it.each`); nenhum teste que só fixa texto, prompt, constante, DTO ou mapping; o mesmo comportamento numa camada só. Além disso é escopo para o revisor.
+
+```markdown
+## Cenários
+- **C1** — Dado um tenant com `criterion_overrides`, quando ele é publicado, então a publicação é recusada nomeando a chave.
+  prova: teste
+  risco: contrato
+- **C2** — Dado um admin logado, quando ele abre /tenants e filtra por "ativo", então a lista mostra só os ativos, paginada no servidor.
+  prova: e2e
+- **C3** — Dado um lead com `sla_desde` preenchido, quando a migration roda, então a coluna some e o motor segue lendo o SLA do perfil.
+  prova: teste
+  risco: dado
+  degrau: migrar
+```
+
+## Padrões assumidos
+
+Todo valor de baixo risco que você decidiu sem perguntar (limite, intervalo, retry, retenção, texto, ordenação), numerado `1.`…`N.`, um por linha, com o valor escolhido. O usuário veta por número ("veta 2") e o resto está aceito; "nenhum" vale. **Nunca padrão:** auth, credencial, permissão, pagamento ou apagar dado; isso é pergunta, e o `plan-check` avisa. Obrigatória em plano novo de `feature`/`bug`.
+
+## Estados (opcional)
+
+Só quando a feature tem algo que muda de estado (pedido, aprovação, assinatura): uma transição por linha, `- origem → destino: gatilho` (`->` também vale). O `plan-check` desenha a máquina no `2-plan/plan.html`; linha que não é transição, ou seção vazia, é erro. Sem estado, não escreva a seção.
+
+## Reuso
+
+`| conceito | veredito | alvo | why |`, veredito `REUSAR` | `ESTENDER` | `CRIAR`. **`CRIAR` exige `why`** (`graph explain X → not-found; grep -rn X → 0`). Abstração nova (interface, base, factory, camada) soma ao `why` o segundo uso que ela barateia; sem isso é excesso (`architecture-engineering-lens#excess`). Conceito de duas features vai a um módulo comum, nunca import cruzado. O validador `reuse` do `verify` cobra: símbolo novo homônimo de um existente reprova na mesma feature.
+
+## Decisões
+
+`### ADR-001 — título` por decisão não trivial (alternativa descartada, motivo, quem decidiu) com `**Alcance:** feature` ou `projeto`. Greenfield: decisão que fixa stack, layout, infraestrutura ou test runner é `projeto`. `### Conflitos com o acervo` sempre (`nenhum` vale). Proibição além das do standard `architecture-stack-baseline` é ADR.
+
+## O que o plan-check recusa
+
+Veredito de reuso fora do enum, id `C`/`ADR` duplicado, `## Errata` fora do fim, `## Cenários` vazio, `teste` sem `risco:`, bug sem cenário de regressão, `## Padrões assumidos` ausente ou fora de `1..N`, `## Estados` com linha que não é `origem → destino: gatilho`. Avisa: padrão que toca credencial, permissão, pagamento ou apagar dado, chave desconhecida (inclusive o `## Fatias` de planos antigos), ADR sem **Alcance**.

package/framework/rules/ui-design.md

@@ -0,0 +1,27 @@
+---
+paths:
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/*.vue"
+  - "**/*.svelte"
+  - "**/*.css"
+  - "**/*.scss"
+  - ".morph/features/*/1-design/**"
+---
+
+# Régua de design
+
+Vale para o desenho na fase uiux e para todo código de UI na implementação.
+
+**Duas réguas ao mesmo tempo.** O sistema — tokens de cor, espaço e tipografia, componentes reutilizáveis, estados default/hover/focus/disabled/loading/error, WCAG AA — e a estética, que separa um design correto de um design aprovado. Régua estética: o standard `frontend-design-system-art-direction`.
+
+- **Direção antes de componente.** Conceito em uma frase, metáfora visual, o que torna a tela memorável, o que ela não pode parecer (template shadcn cru, card branco centralizado, lista de ícones genérica). Escolhida, vai em `**Direção escolhida:**` no `1-design/mockups.md`.
+- **Skills de design:** `frontend-design:frontend-design` sempre; `high-end-visual-design` em momento de marca; `redesign-existing-projects` em tela existente — cada uma só se a sessão a tiver; ausente, o standard de direção de arte é a régua.
+- **Celular primeiro e nativo:** folha inferior, zona do polegar, alvos de 44px, navegação que o polegar alcança. O celular é desenhado, nunca o desktop empilhado.
+- **Movimento com intenção:** a ferramenta mais leve que entrega o efeito (CSS transition/`@keyframes` → animação por scroll em CSS → Motion → GSAP com ScrollTrigger). 60 fps, só `transform` e `opacity`. `prefers-reduced-motion` tem versão estática digna, composta, não só a animação desligada.
+- **Acabamento:** camadas, luz (gradiente radial, trama discreta), vidro com moderação, sombra com a cor do tema, ritmo tipográfico (escala modular, tracking negativo no display), microinteração em foco, hover e envio.
+- **Tela de dados:** lista pagina, ordena e filtra no servidor e tem os três estados (vazio, carregando, erro). Uma ação primária por tela; erro diz o que fazer a seguir; conteúdo gerado por IA marcado como tal.
+- **Reuso:** componente se busca antes de se escrever, também em `.morph/context/design-system.md`. Token novo precisa de justificativa.
+- **Proibido:** número ou dado inventado em tela real, cópia de marca de terceiros, efeito que quebra contraste AA.
+
+Standards: `frontend-design-system-art-direction`, `frontend-design-system-premium-finish`, `frontend-design-system-animations`, `frontend-nextjs-motion-patterns`, `frontend-nextjs-testing`. Por superfície (`marketing-site`, `admin-app`, `brand-moment`): `.claude/skills/morph-uiux/surfaces.json`. Texto inteiro: `morph-spec standards --show <id>`.