@polymorphism-tech/morph-spec 9.8.0 → 10.0.0

package/src/lib/installers/rules-installer.js

@@ -0,0 +1,57 @@
+import { readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { parseStacks, shouldInstall } from '../stack-filter.js';
+import { realEffects } from './effects.js';
+
+export const MAF_TAG = 'maf';
+export const MAF_RULE = 'ai-agents-standards.md';
+const MAF_PATHS = ['**/*.cs'];
+
+/** The text a rule is installed with: in a MAF project the agents rule covers every `.cs`, not only `Agents/` folders. */
+export function ruleContentFor(file, content, projectTags) {
+  if (file !== MAF_RULE || !projectTags.includes(MAF_TAG)) return content;
+  const fm = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fm) return content;
+  const eol = content.includes('\r\n') ? '\r\n' : '\n';
+  const list = MAF_PATHS.map((p) => `  - "${p}"`).join(eol);
+  const rewritten = fm[1].replace(
+    /^paths:[ \t]*(?:\r?\n[ \t]+-[^\r\n]*)*(\r?\n)?/m,
+    (_, tail) => `paths:${eol}${list}${tail ? eol : ''}`,
+  );
+  const start = fm[0].indexOf(fm[1]);
+  return content.slice(0, start) + rewritten + content.slice(start + fm[1].length);
+}
+
+export function installRuleFile(rulesSrc, rulesDest, file, projectTags, fx = realEffects()) {
+  const from = join(rulesSrc, file);
+  const to = join(rulesDest, file);
+  const content = readFileSync(from, 'utf-8');
+  const desired = ruleContentFor(file, content, projectTags);
+  if (desired === content) fx.copyFile(from, to);
+  else fx.writeFile(to, desired);
+}
+
+/** Also removes orphan rules in rulesDest that are no longer in the install set. */
+export function installRulesForStack(rulesSrc, rulesDest, projectTags, fx = realEffects()) {
+  const sourceFiles = readdirSync(rulesSrc).filter(f => f.endsWith('.md'));
+  const installed = new Set();
+
+  for (const file of sourceFiles) {
+    const content = readFileSync(join(rulesSrc, file), 'utf-8');
+    if (shouldInstall(parseStacks(content), projectTags)) {
+      installRuleFile(rulesSrc, rulesDest, file, projectTags, fx);
+      installed.add(file);
+    }
+  }
+
+  // Calado em `dryRun`: `cleanFrameworkDirs()` já apagou `.claude/rules/` inteiro antes da execução real.
+  if (!fx.dryRun) {
+    for (const file of readdirSync(rulesDest).filter(f => f.endsWith('.md'))) {
+      if (!installed.has(file)) {
+        fx.remove(join(rulesDest, file));
+      }
+    }
+  }
+
+  return { installed: installed.size };
+}

package/src/lib/installers/stack-assets.js

@@ -0,0 +1,17 @@
+import { join } from 'path';
+import { installRulesForStack } from './rules-installer.js';
+import { installCommandsForStack } from '../../scripts/setup-infra.js';
+import { installSkills } from '../../utils/skills-installer.js';
+import { installAgents } from '../../utils/agents-installer.js';
+
+const FRAMEWORK_SRC = join(import.meta.dirname, '..', '..', '..', 'framework');
+
+/** Everything filtered by `stacks:` — rules, commands, skills, agents — for the project's tags. The one path init and stack-set share. */
+export async function installStackAssets(targetPath, stackTags, { frameworkSrc = FRAMEWORK_SRC } = {}) {
+  if (stackTags.length === 0) return false;
+  installRulesForStack(join(frameworkSrc, 'rules'), join(targetPath, '.claude', 'rules'), stackTags);
+  installCommandsForStack(join(frameworkSrc, 'commands'), join(targetPath, '.claude', 'commands'), stackTags);
+  await installSkills(targetPath, { projectTags: stackTags });
+  await installAgents(targetPath, frameworkSrc, { projectTags: stackTags });
+  return true;
+}

package/src/lib/installers/stack-sync.js

@@ -0,0 +1,219 @@
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { detectProject } from '../detectors/index.js';
+import { getProjectTags, parseStacks, shouldInstall } from '../stack-filter.js';
+import { WORKTREE_DIR_NAMES } from '../worktree/dirs.js';
+import { resolveComposeFile } from '../../../framework/hooks/shared/e2e-check.js';
+import { createEffects } from './effects.js';
+import { MAF_RULE, MAF_TAG, installRuleFile, ruleContentFor } from './rules-installer.js';
+
+const RULES_SRC = join(import.meta.dirname, '..', '..', '..', 'framework', 'rules');
+const STACK_TAGS = new Set(['nextjs', 'dotnet']);
+const SKIP_DIRS = new Set(['node_modules', 'bin', 'obj', ...WORKTREE_DIR_NAMES]);
+const MAX_DEPTH = 5;
+const MAX_ENTRIES = 20000;
+const NEXT_CONFIG = /^next\.config\.(js|mjs|cjs|ts|mts)$/;
+const DOCKER_FILE = /^(Dockerfile.*|docker-compose\..*|compose\.ya?ml)$/;
+const MAF_PACKAGE =/Include="Microsoft\.Agents\.AI(\.[^"]*)?"/;
+
+function ruleFiles(rulesSrc) {
+  return readdirSync(rulesSrc).filter((f) => f.endsWith('.md'))
+    .map((file) => ({ file, stacks: parseStacks(readFileSync(join(rulesSrc, file), 'utf-8')) }));
+}
+
+/** The tags some rule's `stacks:` names: the only detected tags worth persisting. */
+export function ruleTags(rulesSrc = RULES_SRC) {
+  return new Set(ruleFiles(rulesSrc).flatMap(({ stacks }) => stacks).filter((s) => s !== '*'));
+}
+
+function walk(root, visit) {
+  let seen = 0;
+  const stack = [[root, 0]];
+  while (stack.length) {
+    const [dir, depth] = stack.pop();
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const e of entries) {
+      if (++seen > MAX_ENTRIES) return;
+      if (e.isDirectory()) {
+        if (depth < MAX_DEPTH && !e.name.startsWith('.') && !SKIP_DIRS.has(e.name)) stack.push([join(dir, e.name), depth + 1]);
+      } else if (e.isFile()) {
+        visit(e.name, join(dir, e.name));
+      }
+    }
+  }
+}
+
+/**
+ * `tags`: what the files show, for picking rules. `persist`: the subset safe to write into config.json —
+ * `docker` only with a compose file, since a declared `docker` without one turns the e2e node red.
+ */
+export function detectStackTags(projectDir, { config = null, rulesSrc = RULES_SRC } = {}) {
+  const found = new Set();
+  const { structure } = detectProject(projectDir);
+  for (const t of String(structure.stack).split('+')) found.add(t);
+  for (const t of structure.integrations) found.add(t);
+
+  walk(projectDir, (name, path) => {
+    if (name.endsWith('.csproj') || name.endsWith('.sln') || name.endsWith('.slnx')) found.add('dotnet');
+    if (NEXT_CONFIG.test(name)) found.add('nextjs');
+    if (DOCKER_FILE.test(name)) found.add('docker');
+    if (name.endsWith('.csproj') || name === 'Directory.Packages.props') {
+      try { if (MAF_PACKAGE.test(readFileSync(path, 'utf-8'))) found.add(MAF_TAG); } catch { /* unreadable: not MAF */ }
+    }
+  });
+
+  const wanted = ruleTags(rulesSrc);
+  wanted.add(MAF_TAG);
+  const tags = [...found].filter((t) => wanted.has(t));
+  const hasCompose = Boolean(resolveComposeFile(projectDir, config ?? {}));
+  const persist = tags.filter((t) => t !== 'docker' || hasCompose);
+  return { tags, persist };
+}
+
+/** Adds the tags the config lacks; never removes one. `unknown` is a placeholder, not a tag. */
+export function mergeDetectedTags(config, tags) {
+  const have = new Set(getProjectTags(config));
+  const added = tags.filter((t) => !have.has(t));
+  if (added.length === 0) return { config, added, changed: false };
+
+  const project = { ...(config.project ?? {}) };
+  const stackParts = typeof project.stack === 'string'
+    ? project.stack.split('+').filter((s) => s && s !== 'unknown')
+    : [];
+  const integrations = Array.isArray(project.integrations) ? [...project.integrations] : [];
+  for (const t of added) (STACK_TAGS.has(t) ? stackParts : integrations).push(t);
+  if (stackParts.length) project.stack = stackParts.join('+');
+  if (integrations.length) project.integrations = integrations;
+  return { config: { ...config, project }, added, changed: true };
+}
+
+const configPathOf = (projectDir) => join(projectDir, '.morph', 'config', 'config.json');
+
+function readConfig(path) {
+  return JSON.parse(readFileSync(path, 'utf-8').replace(/^/, ''));
+}
+
+function missingRules(projectDir, tags, rulesSrc) {
+  const rulesDest = join(projectDir, '.claude', 'rules');
+  const missing = [];
+  const stale = [];
+  for (const { file, stacks } of ruleFiles(rulesSrc)) {
+    if (stacks.includes('*') || !shouldInstall(stacks, tags)) continue;
+    const dest = join(rulesDest, file);
+    if (!existsSync(dest)) { missing.push(file); continue; }
+    if (file !== MAF_RULE || !tags.includes(MAF_TAG)) continue;
+    const desired = ruleContentFor(file, readFileSync(join(rulesSrc, file), 'utf-8'), tags);
+    if (readFileSync(dest, 'utf-8') !== desired) stale.push(file);
+  }
+  return { missing, stale };
+}
+
+let warned = false;
+function warnOnce(log, message) {
+  if (warned) return;
+  warned = true;
+  log(`⚠ stack-sync: ${message}`);
+}
+
+const NOOP = Object.freeze({ added: [], updated: [], tags: [], configChanged: false });
+
+/**
+ * Installs every stack rule (a `stacks:` other than `*`) the project needs and lacks, after adding to
+ * config.json the stack tags its files show. Only an installed project (with config.json) is touched. Never throws.
+ * `persistTags: false` leaves config.json alone: a check (`verify`) may write gitignored harness files, never a tracked one.
+ */
+export function syncStackRules(projectDir, {
+  dryRun = false, fx = createEffects({ dryRun }), log = (line) => console.log(line), rulesSrc = RULES_SRC,
+  persistTags = true,
+} = {}) {
+  try {
+    const configPath = configPathOf(projectDir);
+    if (!existsSync(configPath)) return { ...NOOP };
+    let config;
+    try { config = readConfig(configPath); } catch {
+      warnOnce(log, `${configPath} ilegível — regras de stack não sincronizadas`);
+      return { ...NOOP };
+    }
+
+    const detected = detectStackTags(projectDir, { config, rulesSrc });
+    const merged = persistTags
+      ? mergeDetectedTags(config, detected.persist)
+      : { config, added: [], changed: false };
+    if (merged.changed) {
+      fx.writeJson(configPath, merged.config);
+      log(`  + config.json: ${merged.added.join(', ')} (detectado nos arquivos)`);
+    }
+
+    const tags = [...new Set([...getProjectTags(merged.config), ...detected.tags])];
+    const { missing, stale } = missingRules(projectDir, tags, rulesSrc);
+    const rulesDest = join(projectDir, '.claude', 'rules');
+    for (const file of [...missing, ...stale]) {
+      installRuleFile(rulesSrc, rulesDest, file, tags, fx);
+      log(`  + .claude/rules/${file} (stack: ${tags.join('+')})`);
+    }
+    return { added: missing, updated: stale, tags, configChanged: merged.changed };
+  } catch (err) {
+    warnOnce(log, err?.message ?? String(err));
+    return { ...NOOP };
+  }
+}
+
+/** What `stack-set` accepts: the stack tags, and the integrations some rule (or the MAF rewrite) reacts to. */
+export function knownStackTags(rulesSrc = RULES_SRC) {
+  const integrations = [...ruleTags(rulesSrc), MAF_TAG].filter((t) => !STACK_TAGS.has(t));
+  return { stacks: [...STACK_TAGS].sort(), integrations: [...new Set(integrations)].sort() };
+}
+
+/**
+ * The user's choice of stack, written into config.json (`project.stack` replaced, `integrations` added to),
+ * then the rules it needs installed. `{ error }` names what was refused; nothing is written then.
+ */
+export function setProjectStack(projectDir, stack, {
+  integrations = [], dryRun = false, fx = createEffects({ dryRun }), log = (line) => console.log(line), rulesSrc = RULES_SRC,
+} = {}) {
+  const configPath = configPathOf(projectDir);
+  if (!existsSync(configPath)) return { error: `${configPath} ausente — rode morph-spec init antes` };
+  const known = knownStackTags(rulesSrc);
+  const stackTags = String(stack ?? '').split('+').map((t) => t.trim()).filter(Boolean);
+  const unknown = [
+    ...stackTags.filter((t) => !known.stacks.includes(t)),
+    ...integrations.filter((t) => !known.integrations.includes(t)),
+  ];
+  if (stackTags.length === 0 || unknown.length > 0) {
+    return { error: `tag desconhecida: ${unknown.join(', ') || '(stack vazia)'}. Stack: ${known.stacks.join(' | ')} (unidas por +); --with: ${known.integrations.join(', ')}` };
+  }
+  let config;
+  try { config = readConfig(configPath); } catch { return { error: `${configPath} ilegível` }; }
+  if (integrations.includes('docker') && !resolveComposeFile(projectDir, config)) {
+    return { error: 'docker sem compose deixa o nó e2e vermelho: crie o compose primeiro (o plan-check e o update declaram docker quando ele existir)' };
+  }
+
+  const project = { ...(config.project ?? {}), stack: stackTags.join('+') };
+  const merged = [...new Set([...(Array.isArray(project.integrations) ? project.integrations : []), ...integrations])];
+  if (merged.length) project.integrations = merged;
+  fx.writeJson(configPath, { ...config, project });
+  log(`  + config.json: project.stack = ${project.stack}${merged.length ? `, integrations = ${merged.join(', ')}` : ''}`);
+  return { stack: project.stack, integrations: merged, sync: syncStackRules(projectDir, { dryRun, fx, log, rulesSrc }) };
+}
+
+/** Read-only, for `doctor`: what `syncStackRules` would add. `null` when the config is absent or unreadable. */
+export function stackRuleGaps(projectDir, { rulesSrc = RULES_SRC } = {}) {
+  try {
+    const configPath = configPathOf(projectDir);
+    if (!existsSync(configPath)) return null;
+    const config = readConfig(configPath);
+    const stack = config?.project?.stack;
+    const detected = detectStackTags(projectDir, { config, rulesSrc });
+    const tags = [...new Set([...getProjectTags(config), ...detected.tags])];
+    const { missing, stale } = missingRules(projectDir, tags, rulesSrc);
+    return {
+      stackMissing: !stack || stack === 'unknown',
+      undeclared: detected.persist.filter((t) => !getProjectTags(config).includes(t)),
+      missing: [...missing, ...stale],
+      tags,
+    };
+  } catch {
+    return null;
+  }
+}

package/src/lib/plan/checks.js

@@ -2,88 +2,18 @@ import { createHash } from 'crypto';
 import { existsSync, readFileSync } from 'fs';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
 import { frozenBody } from '../../../framework/hooks/shared/errata.js';
-import { readAgentsJson } from '../specs/screen-checklist.js';
 import { getFeature } from '../../../framework/hooks/shared/state-reader.js';
 import { findArtifactTerms } from './artifact-vocabulary.js';
-import { PROOF_KINDS, RISK_KINDS, REUSE_VERDICTS, ADR_SCOPES, SECTIONS, CONFLICTS_HEADING } from './plan-parser.js';
+import { mediaCitationError } from './media.js';
+import { PROOF_KINDS, RISK_KINDS, REWORK_RUNGS, REUSE_VERDICTS, ADR_SCOPES, SECTIONS, CONFLICTS_HEADING } from './plan-parser.js';
 
 export const CHECKS_VERSION = 1;
-export const MAX_SLICE_FILES = 8;
-export const MAX_SLICES = 12;
-export const MAX_PARALLEL = 4;
 
 /** sha256 of the plan without its errata: appending a correction never invalidates the extracted checks. */
 export function planHash(text) {
   return createHash('sha256').update(frozenBody(text), 'utf8').digest('hex');
 }
 
-/** The installed agents.json, else the package's; null when unreadable (personas then go unchecked). */
-export function knownPersonas(cwd) {
-  const agents = readAgentsJson(cwd)?.agents;
-  return agents && typeof agents === 'object' ? Object.keys(agents) : null;
-}
-
-/** The ids on a dependency cycle, or null. */
-export function dependencyCycle(slices) {
-  const deps = new Map(slices.map((s) => [s.id, s.depends ?? []]));
-  const state = new Map();
-  const stack = [];
-  const visit = (id) => {
-    if (state.get(id) === 'done' || !deps.has(id)) return null;
-    if (state.get(id) === 'open') return stack.slice(stack.indexOf(id)).concat(id);
-    state.set(id, 'open');
-    stack.push(id);
-    for (const dep of deps.get(id)) {
-      const cycle = visit(dep);
-      if (cycle) return cycle;
-    }
-    stack.pop();
-    state.set(id, 'done');
-    return null;
-  };
-  for (const id of deps.keys()) {
-    const cycle = visit(id);
-    if (cycle) return cycle;
-  }
-  return null;
-}
-
-const fileKey = (f) => f.replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase();
-
-// A slice joins a wave only after its dependencies ran, never with one touching its files, and at most
-// MAX_PARALLEL per wave. Empty on a dependency cycle.
-export function parallelGroups(slices) {
-  if (dependencyCycle(slices)) return [];
-  const ids = new Set(slices.map((s) => s.id));
-  const depth = new Map();
-  const depthOf = (slice) => {
-    if (depth.has(slice.id)) return depth.get(slice.id);
-    const parents = (slice.depends ?? []).filter((d) => ids.has(d)).map((d) => slices.find((s) => s.id === d));
-    const value = parents.length === 0 ? 0 : 1 + Math.max(...parents.map(depthOf));
-    depth.set(slice.id, value);
-    return value;
-  };
-  const layers = [];
-  for (const slice of slices) (layers[depthOf(slice)] ??= []).push(slice);
-
-  const groups = [];
-  for (const layer of layers.filter(Boolean)) {
-    const open = [];
-    for (const slice of layer) {
-      const files = new Set((slice.files ?? []).map(fileKey));
-      const group = open.find((g) => g.ids.length < MAX_PARALLEL && ![...files].some((f) => g.files.has(f)));
-      if (group) {
-        group.ids.push(slice.id);
-        files.forEach((f) => group.files.add(f));
-      } else {
-        open.push({ ids: [slice.id], files });
-      }
-    }
-    groups.push(...open.map((g) => g.ids));
-  }
-  return groups;
-}
-
 // A frozen body already extracted under older rules cannot gain a `risco:` line, so it is not demanded.
 export function planRuleOptions(cwd, featureName) {
   return {
@@ -94,14 +24,53 @@ export function planRuleOptions(cwd, featureName) {
 
 const foldRisk = (s) => s.normalize('NFD').replace(/\p{M}/gu, '').replace(/`/g, '').toLowerCase().trim();
 const RISK_BY_FOLD = new Map(RISK_KINDS.map((r) => [foldRisk(r), r]));
+const RUNG_BY_FOLD = new Map(REWORK_RUNGS.map((r) => [foldRisk(r), r]));
+const canonicalRung = (rung) => (rung === null ? null : RUNG_BY_FOLD.get(foldRisk(rung)) ?? false);
 const REGRESSION_WORK_TYPES = ['bug', 'hotfix'];
+const POLICY_PLAN_WORK_TYPES = ['chore', 'hotfix'];
+// Vetar por número só vale para o que custa pouco errar: o resto é pergunta. Aviso, não erro: o vocabulário
+// é comum em plano por outros motivos, e um erro só ensinaria a reescrever a linha.
+const NEVER_DEFAULT_RE = /\b(autentica\w*|senha|password|credencia\w*|segredo|secret|api key|chave de api|permiss\w*|pagamento|cobranc\w*|billing|drop (table|column)|(apaga\w*|delet\w*|exclu\w*) (o |os |a |as )?(dado|registro|lead|conta|cliente)s?)\b/;
+
+function defaultsWarnings(plan, at) {
+  return plan.defaults.items.flatMap((d) => {
+    const hit = NEVER_DEFAULT_RE.exec(foldRisk(d.text));
+    return hit ? [`padrão ${d.n} toca "${hit[1]}"${at(d.line)} — credencial, permissão, pagamento e apagar dado viram pergunta, nunca padrão`] : [];
+  });
+}
+
+// Optional: absent is fine; present, every line is a transition the plan view can draw.
+function statesErrors(plan, at) {
+  if (!plan.present.states) return [];
+  const { transitions, invalid } = plan.states;
+  const errors = invalid.map((l) => `## ${SECTIONS.states}: "${l.raw}" não é transição — use "- origem → destino: gatilho"${at(l.line)}`);
+  if (transitions.length === 0 && invalid.length === 0) errors.push(`## ${SECTIONS.states} vazia — liste as transições ou apague a seção`);
+  return errors;
+}
 
-export function validatePlan(plan, { personas = null, surfaces = null, workType = null, riskRules = true } = {}) {
+function defaultsErrors(plan, { workType, riskRules }, at) {
+  const { items, none } = plan.defaults;
+  if (!plan.present.defaults) {
+    return riskRules && !POLICY_PLAN_WORK_TYPES.includes(workType)
+      ? [`seção obrigatória ausente: ## ${SECTIONS.defaults} — numere o que você decidiu sem perguntar, ou escreva "nenhum"`]
+      : [];
+  }
+  if (items.length === 0) {
+    return none ? [] : [`## ${SECTIONS.defaults} sem item numerado ("1. …") nem "nenhum"`];
+  }
+  return items.some((d, i) => d.n !== i + 1)
+    ? [`## ${SECTIONS.defaults} numerada fora de 1..${items.length} — o usuário veta pelo número`]
+    : [];
+}
+
+export function validatePlan(plan, { workType = null, riskRules = true, text = null } = {}) {
   const errors = [];
   const warnings = [];
+  const media = riskRules ? mediaCitationError(text) : null;
+  if (media) errors.push(media);
   const at = (line) => (line ? ` (linha ${line})` : '');
 
-  for (const key of ['problem', 'scenarios', 'decisions', 'slices']) {
+  for (const key of ['problem', 'scenarios', 'decisions']) {
     if (!plan.present[key]) errors.push(`seção obrigatória ausente: ## ${SECTIONS[key]}`);
   }
   if (plan.present.decisions && !plan.conflicts) {
@@ -114,7 +83,7 @@ export function validatePlan(plan, { personas = null, surfaces = null, workType
   }
 
   const duplicated = (items) => items.map((i) => i.id).filter((id, i, all) => all.indexOf(id) !== i);
-  for (const [label, items] of [['cenário', plan.scenarios], ['fatia', plan.slices], ['ADR', plan.adrs]]) {
+  for (const [label, items] of [['cenário', plan.scenarios], ['ADR', plan.adrs]]) {
     for (const id of new Set(duplicated(items))) errors.push(`${label} duplicado: ${id}`);
   }
 
@@ -136,6 +105,9 @@ export function validatePlan(plan, { personas = null, surfaces = null, workType
     } else if (risk && proof === 'leitura') {
       warnings.push(`${c.id}: risco "${risk}" provado só por leitura${at(c.line)}`);
     }
+    if (canonicalRung(c.rung) === false) {
+      errors.push(`${c.id}: degrau "${c.rung}" fora de ${REWORK_RUNGS.join(' | ')}${at(c.line)}`);
+    }
     const terms = findArtifactTerms(c.text);
     if (terms.length > 0 && !c.artifactWhy) {
       errors.push(`${c.id} descreve artefato ("${terms.join(', ')}") sem "> Por que artefato:" — reescreva como efeito observável ou justifique${at(c.line)}`);
@@ -147,37 +119,13 @@ export function validatePlan(plan, { personas = null, surfaces = null, workType
     errors.push(`${workType} sem cenário de regressão — o sintoma do bug real vira um Cn com "prova: teste" e "risco: regressão"`);
   }
 
-  const scenarioIds = new Set(plan.scenarios.map((c) => c.id));
-  const sliceIds = new Set(plan.slices.map((s) => s.id));
-  const covered = new Set();
-  for (const s of plan.slices) {
-    if (!s.persona) {
-      errors.push(`${s.id} sem "- persona:"${at(s.line)}`);
-    } else if (personas && !personas.includes(s.persona)) {
-      errors.push(`${s.id}: persona "${s.persona}" não existe em agents.json (${personas.join(', ')})${at(s.line)}`);
-    }
-    if (s.files.length > MAX_SLICE_FILES) {
-      errors.push(`${s.id} toca ${s.files.length} arquivos — o teto é ${MAX_SLICE_FILES}; divida a fatia${at(s.line)}`);
-    }
-    for (const c of s.covers) {
-      if (scenarioIds.has(c)) covered.add(c);
-      else errors.push(`${s.id} cobre ${c}, que não existe em ## ${SECTIONS.scenarios}${at(s.line)}`);
-    }
-    for (const d of s.depends) {
-      if (!sliceIds.has(d)) errors.push(`${s.id} depende de ${d}, que não existe${at(s.line)}`);
-    }
-    if (s.covers.length === 0) warnings.push(`${s.id} não cobre nenhum cenário${at(s.line)}`);
-    if (s.unknownKeys.length > 0) warnings.push(`${s.id}: chave desconhecida ${s.unknownKeys.join(', ')}${at(s.line)}`);
-    if (s.surface && surfaces && !surfaces.includes(s.surface)) {
-      warnings.push(`${s.id}: superfície "${s.surface}" não é uma de ${surfaces.join(', ')}${at(s.line)}`);
-    }
-  }
-  for (const c of plan.scenarios) {
-    if (!covered.has(c.id)) errors.push(`${c.id} não é coberto por nenhuma fatia ("- cobre: ${c.id}")`);
+  errors.push(...defaultsErrors(plan, { workType, riskRules }, at));
+  errors.push(...statesErrors(plan, at));
+  warnings.push(...defaultsWarnings(plan, at));
+
+  if (plan.sections.some((s) => !s.key && /^fatias$/i.test(s.name.trim()))) {
+    warnings.push('## Fatias não é lida desde a 10.0: o plano inteiro se implementa numa sessão, e os cenários definem o pronto');
   }
-  const cycle = dependencyCycle(plan.slices);
-  if (cycle) errors.push(`ciclo em "depende": ${cycle.join(' → ')}`);
-  if (plan.slices.length > MAX_SLICES) warnings.push(`${plan.slices.length} fatias — acima de ${MAX_SLICES}, considere dividir a feature`);
 
   for (const r of plan.reuse) {
     if (!REUSE_VERDICTS.includes(r.verdict)) {
@@ -200,10 +148,7 @@ export function buildChecks(feature, text, plan) {
     planHash: planHash(text),
     checks: plan.scenarios.map((c) => ({
       id: c.id, text: c.text, proof: c.proof ? c.proof.toLowerCase() : null, artifactWhy: c.artifactWhy || null,
-    })),
-    slices: plan.slices.map((s) => ({
-      id: s.id, title: s.title, persona: s.persona, surface: s.surface,
-      standards: s.standards, files: s.files, depends: s.depends, covers: s.covers,
+      rung: canonicalRung(c.rung) || null,
     })),
     reuse: plan.reuse.map(({ concept, verdict, target, why }) => ({ concept, verdict, target, why })),
     adrs: plan.adrs.map((a) => ({ id: a.id, title: a.title, scope: ADR_SCOPES.includes(a.scope) ? a.scope : null })),
@@ -222,7 +167,7 @@ export function readPlanChecks(cwd, featureName) {
   } catch {
     return { status: 'unreadable', checks: null };
   }
-  if (checks?.version !== CHECKS_VERSION || !Array.isArray(checks.slices) || !Array.isArray(checks.checks)) {
+  if (checks?.version !== CHECKS_VERSION || !Array.isArray(checks.checks)) {
     return { status: 'unreadable', checks: null };
   }
   let plan;

package/src/lib/plan/critique.js

@@ -0,0 +1,28 @@
+import { existsSync, readFileSync } from 'fs';
+import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+
+export const CRITIQUE_EXEMPT_WORK_TYPES = ['chore', 'hotfix'];
+
+const PLAN_HASH_RE = /^\*\*Plan-Hash:\*\*\s*`?([0-9a-f]{64})`?\s*$/m;
+const APPLIED_RE = /^\*\*Aplicado-em:\*\*\s*`?([0-9a-f]{64})`?\s*$/gm;
+
+// A critique counts for the plan it read or for the plan the session wrote after applying it:
+// otherwise every fix it asks for would demand a new critique.
+export function critiqueStatus(text, currentHash) {
+  if (typeof text !== 'string') return 'missing';
+  const read = PLAN_HASH_RE.exec(text)?.[1];
+  if (!read) return 'no-hash';
+  const applied = [...text.matchAll(APPLIED_RE)].map((m) => m[1]);
+  const valid = applied.length ? applied[applied.length - 1] : read;
+  return currentHash === read || currentHash === valid ? 'fresh' : 'stale';
+}
+
+export function readPlanCritique(cwd, featureName, { workType, planChecks }) {
+  if (CRITIQUE_EXEMPT_WORK_TYPES.includes(workType)) return 'exempt';
+  const currentHash = planChecks?.status === 'fresh' ? planChecks.checks?.planHash : null;
+  if (!currentHash) return null;
+  const path = getAbsoluteOutputPath(cwd, featureName, 'planCritique');
+  let text = null;
+  try { text = existsSync(path) ? readFileSync(path, 'utf8') : null; } catch { text = null; }
+  return critiqueStatus(text, currentHash);
+}

package/src/lib/plan/media.js

@@ -0,0 +1,42 @@
+export const MEDIA_STANDARD_IDS = [
+  'ai-agents-modalities-image-gen',
+  'ai-agents-media-video',
+  'ai-agents-media-pipeline',
+];
+
+// O plano escreve o standard pelo id ou pelo caminho (com ou sem `framework/`/`standards/`).
+export function standardIdOf(value) {
+  return String(value ?? '').trim().replace(/\\/g, '/')
+    .replace(/^(\.morph\/)?(framework\/)?(standards\/)?/, '')
+    .replace(/\.md$/, '')
+    .replace(/\//g, '-');
+}
+
+export function featureGeneratesMedia(planText) {
+  if (typeof planText !== 'string') return false;
+  const tokens = new Set(planText.split(/[\s`'",;:()[\]|]+/).map((t) => standardIdOf(t.replace(/[.!?]+$/, ''))));
+  return MEDIA_STANDARD_IDS.some((id) => tokens.has(id));
+}
+
+const fold = (s) => s.normalize('NFD').replace(/\p{M}/gu, '').toLowerCase();
+
+// Vocabulário estreito de propósito: "imagem" sozinha (upload, avatar) não é mídia gerada.
+const GENERATED_MEDIA_RE = new RegExp([
+  String.raw`\b(gera[rd]?[ao]?s?|geracao|generat\w*)\b[^.\n]{0,40}\b(imagem|imagens|images?|videos?|ilustrac\w*|thumbnails?)\b`,
+  String.raw`\b(imagem|imagens|videos?|ilustrac\w*|thumbnails?)\b[^.\n]{0,20}\bgerad[ao]s?\b`,
+  String.raw`\b(text|texto)[- ]?(to|para)[- ]?(image|imagem|video)\b`,
+  String.raw`\b(img2vid|image-gen|gpt-image|dall-?e|seedance|midjourney|stable diffusion|nano banana|sora|veo ?\d)\b`,
+].join('|'));
+
+const NO_MEDIA_RE = /^\s*[-*]?\s*\**midia gerada:?\**:?\s*nao\b/m;
+
+/** Plano que fala em gerar imagem ou vídeo e não cita o standard deixaria o guardrail desarmado em silêncio. */
+export function mediaCitationError(planText) {
+  if (typeof planText !== 'string' || featureGeneratesMedia(planText)) return null;
+  const text = fold(planText);
+  if (NO_MEDIA_RE.test(text)) return null;
+  const hit = GENERATED_MEDIA_RE.exec(text);
+  if (!hit) return null;
+  return `o plano fala em mídia gerada ("${hit[0].trim()}") sem citar o standard: cite ${MEDIA_STANDARD_IDS.map((id) => `\`${id}\``).join(', ')} `
+    + 'conforme o caso (é o que arma as provas de mídia do Gate 3), ou escreva a linha "Mídia gerada: não" se nada é gerado por IA';
+}