@polymorphism-tech/morph-spec 8.34.2 → 8.35.1

package/src/commands/project/checkpoint.js

@@ -1,209 +1,209 @@
-/**
- * MORPH-SPEC Checkpoint Save/Restore Command
- *
- * Save and restore full context at phase boundaries.
- *
- * Usage:
- *   morph-spec checkpoint save <feature-name>
- *   morph-spec checkpoint restore <feature-name>
- *   morph-spec checkpoint list <feature-name>
- */
-
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { loadState, saveState, getFeature } from '../../core/state/state-manager.js';
-
-/**
- * Get checkpoints directory for a feature
- */
-function getCheckpointsDir(featureName) {
-  return path.join(process.cwd(), '.morph/checkpoints', featureName);
-}
-
-/**
- * Save checkpoint command
- */
-export async function checkpointSaveCommand(featureName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    process.exit(1);
-  }
-
-  const feature = getFeature(featureName);
-  if (!feature) {
-    console.error(chalk.red(`Error: Feature '${featureName}' not found`));
-    process.exit(1);
-  }
-
-  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
-  if (!fs.existsSync(outputDir)) {
-    console.error(chalk.red(`Error: No outputs found for '${featureName}'`));
-    process.exit(1);
-  }
-
-  // Create checkpoint directory with timestamp
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const label = options.label || feature.phase;
-  const checkpointName = `${label}_${timestamp}`;
-  const checkpointDir = path.join(getCheckpointsDir(featureName), checkpointName);
-  fs.mkdirSync(checkpointDir, { recursive: true });
-
-  // Copy all output files
-  const files = fs.readdirSync(outputDir);
-  let fileCount = 0;
-  for (const file of files) {
-    const src = path.join(outputDir, file);
-    const stat = fs.statSync(src);
-    if (stat.isFile()) {
-      fs.copyFileSync(src, path.join(checkpointDir, file));
-      fileCount++;
-    }
-  }
-
-  // Save state snapshot
-  const stateSnapshot = {
-    feature: { ...feature },
-    timestamp: new Date().toISOString(),
-    phase: feature.phase,
-    label,
-    files: files.filter(f => fs.statSync(path.join(outputDir, f)).isFile())
-  };
-  fs.writeFileSync(
-    path.join(checkpointDir, '_checkpoint.json'),
-    JSON.stringify(stateSnapshot, null, 2)
-  );
-
-  console.log(chalk.green(`\n✓ Checkpoint saved: ${checkpointName}`));
-  console.log(chalk.gray(`  Phase: ${feature.phase}`));
-  console.log(chalk.gray(`  Files: ${fileCount}`));
-  console.log(chalk.gray(`  Path: ${checkpointDir}\n`));
-}
-
-/**
- * Restore checkpoint command
- */
-export async function checkpointRestoreCommand(featureName, checkpointName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    process.exit(1);
-  }
-
-  const checkpointsDir = getCheckpointsDir(featureName);
-  if (!fs.existsSync(checkpointsDir)) {
-    console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
-    process.exit(1);
-  }
-
-  // Find checkpoint to restore
-  let targetDir;
-  if (checkpointName) {
-    targetDir = path.join(checkpointsDir, checkpointName);
-    if (!fs.existsSync(targetDir)) {
-      console.error(chalk.red(`Error: Checkpoint '${checkpointName}' not found`));
-      process.exit(1);
-    }
-  } else {
-    // Restore latest
-    const checkpoints = fs.readdirSync(checkpointsDir)
-      .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
-      .sort()
-      .reverse();
-
-    if (checkpoints.length === 0) {
-      console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
-      process.exit(1);
-    }
-
-    targetDir = path.join(checkpointsDir, checkpoints[0]);
-    checkpointName = checkpoints[0];
-  }
-
-  // Read checkpoint metadata
-  const metaPath = path.join(targetDir, '_checkpoint.json');
-  if (!fs.existsSync(metaPath)) {
-    console.error(chalk.red('Error: Checkpoint metadata not found'));
-    process.exit(1);
-  }
-
-  const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
-
-  // Restore output files
-  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
-  fs.mkdirSync(outputDir, { recursive: true });
-
-  const files = fs.readdirSync(targetDir).filter(f => f !== '_checkpoint.json');
-  for (const file of files) {
-    fs.copyFileSync(path.join(targetDir, file), path.join(outputDir, file));
-  }
-
-  // Restore state
-  const state = loadState();
-  if (state.features[featureName] && meta.feature) {
-    // Preserve some current fields, restore phase and outputs
-    state.features[featureName].phase = meta.feature.phase;
-    state.features[featureName].outputs = meta.feature.outputs;
-    state.features[featureName].tasks = meta.feature.tasks;
-    state.features[featureName].approvalGates = meta.feature.approvalGates;
-    state.features[featureName].updatedAt = new Date().toISOString();
-    saveState(state);
-  }
-
-  console.log(chalk.green(`\n✓ Checkpoint restored: ${checkpointName}`));
-  console.log(chalk.gray(`  Phase: ${meta.phase}`));
-  console.log(chalk.gray(`  Files restored: ${files.length}`));
-  console.log(chalk.gray(`  Original date: ${meta.timestamp}\n`));
-}
-
-/**
- * List checkpoints command
- */
-export async function checkpointListCommand(featureName, options = {}) {
-  if (!featureName) {
-    console.error(chalk.red('Error: Feature name required'));
-    process.exit(1);
-  }
-
-  const checkpointsDir = getCheckpointsDir(featureName);
-  if (!fs.existsSync(checkpointsDir)) {
-    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
-    return;
-  }
-
-  const checkpoints = fs.readdirSync(checkpointsDir)
-    .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
-    .sort()
-    .reverse();
-
-  if (checkpoints.length === 0) {
-    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
-    return;
-  }
-
-  // JSON output
-  if (options.json) {
-    const list = checkpoints.map(cp => {
-      const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
-      const meta = fs.existsSync(metaPath) ? JSON.parse(fs.readFileSync(metaPath, 'utf8')) : {};
-      return { name: cp, phase: meta.phase, timestamp: meta.timestamp, files: meta.files?.length || 0 };
-    });
-    console.log(JSON.stringify({ feature: featureName, checkpoints: list }, null, 2));
-    return;
-  }
-
-  // Visual output
-  console.log(chalk.cyan(`\nCheckpoints for '${featureName}':\n`));
-
-  for (const cp of checkpoints) {
-    const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
-    let meta = {};
-    if (fs.existsSync(metaPath)) {
-      meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
-    }
-
-    const date = meta.timestamp ? new Date(meta.timestamp).toLocaleString() : 'unknown';
-    console.log(chalk.white(`  ${cp}`));
-    console.log(chalk.gray(`    Phase: ${meta.phase || 'unknown'} | Files: ${meta.files?.length || '?'} | ${date}`));
-  }
-  console.log('');
-}
+/**
+ * MORPH-SPEC Checkpoint Save/Restore Command
+ *
+ * Save and restore full context at phase boundaries.
+ *
+ * Usage:
+ *   morph-spec checkpoint save <feature-name>
+ *   morph-spec checkpoint restore <feature-name>
+ *   morph-spec checkpoint list <feature-name>
+ */
+
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { loadState, saveState, getFeature } from '../../core/state/state-manager.js';
+
+/**
+ * Get checkpoints directory for a feature
+ */
+function getCheckpointsDir(featureName) {
+  return path.join(process.cwd(), '.morph/checkpoints', featureName);
+}
+
+/**
+ * Save checkpoint command
+ */
+export async function checkpointSaveCommand(featureName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    process.exit(1);
+  }
+
+  const feature = getFeature(featureName);
+  if (!feature) {
+    console.error(chalk.red(`Error: Feature '${featureName}' not found`));
+    process.exit(1);
+  }
+
+  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
+  if (!fs.existsSync(outputDir)) {
+    console.error(chalk.red(`Error: No outputs found for '${featureName}'`));
+    process.exit(1);
+  }
+
+  // Create checkpoint directory with timestamp
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const label = options.label || feature.phase;
+  const checkpointName = `${label}_${timestamp}`;
+  const checkpointDir = path.join(getCheckpointsDir(featureName), checkpointName);
+  fs.mkdirSync(checkpointDir, { recursive: true });
+
+  // Copy all output files
+  const files = fs.readdirSync(outputDir);
+  let fileCount = 0;
+  for (const file of files) {
+    const src = path.join(outputDir, file);
+    const stat = fs.statSync(src);
+    if (stat.isFile()) {
+      fs.copyFileSync(src, path.join(checkpointDir, file));
+      fileCount++;
+    }
+  }
+
+  // Save state snapshot
+  const stateSnapshot = {
+    feature: { ...feature },
+    timestamp: new Date().toISOString(),
+    phase: feature.phase,
+    label,
+    files: files.filter(f => fs.statSync(path.join(outputDir, f)).isFile())
+  };
+  fs.writeFileSync(
+    path.join(checkpointDir, '_checkpoint.json'),
+    JSON.stringify(stateSnapshot, null, 2)
+  );
+
+  console.log(chalk.green(`\n✓ Checkpoint saved: ${checkpointName}`));
+  console.log(chalk.gray(`  Phase: ${feature.phase}`));
+  console.log(chalk.gray(`  Files: ${fileCount}`));
+  console.log(chalk.gray(`  Path: ${checkpointDir}\n`));
+}
+
+/**
+ * Restore checkpoint command
+ */
+export async function checkpointRestoreCommand(featureName, checkpointName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    process.exit(1);
+  }
+
+  const checkpointsDir = getCheckpointsDir(featureName);
+  if (!fs.existsSync(checkpointsDir)) {
+    console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
+    process.exit(1);
+  }
+
+  // Find checkpoint to restore
+  let targetDir;
+  if (checkpointName) {
+    targetDir = path.join(checkpointsDir, checkpointName);
+    if (!fs.existsSync(targetDir)) {
+      console.error(chalk.red(`Error: Checkpoint '${checkpointName}' not found`));
+      process.exit(1);
+    }
+  } else {
+    // Restore latest
+    const checkpoints = fs.readdirSync(checkpointsDir)
+      .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
+      .sort()
+      .reverse();
+
+    if (checkpoints.length === 0) {
+      console.error(chalk.red(`Error: No checkpoints found for '${featureName}'`));
+      process.exit(1);
+    }
+
+    targetDir = path.join(checkpointsDir, checkpoints[0]);
+    checkpointName = checkpoints[0];
+  }
+
+  // Read checkpoint metadata
+  const metaPath = path.join(targetDir, '_checkpoint.json');
+  if (!fs.existsSync(metaPath)) {
+    console.error(chalk.red('Error: Checkpoint metadata not found'));
+    process.exit(1);
+  }
+
+  const meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+
+  // Restore output files
+  const outputDir = path.join(process.cwd(), '.morph/features', featureName);
+  fs.mkdirSync(outputDir, { recursive: true });
+
+  const files = fs.readdirSync(targetDir).filter(f => f !== '_checkpoint.json');
+  for (const file of files) {
+    fs.copyFileSync(path.join(targetDir, file), path.join(outputDir, file));
+  }
+
+  // Restore state
+  const state = loadState();
+  if (state.features[featureName] && meta.feature) {
+    // Preserve some current fields, restore phase and outputs
+    state.features[featureName].phase = meta.feature.phase;
+    state.features[featureName].outputs = meta.feature.outputs;
+    state.features[featureName].tasks = meta.feature.tasks;
+    state.features[featureName].approvalGates = meta.feature.approvalGates;
+    state.features[featureName].updatedAt = new Date().toISOString();
+    saveState(state);
+  }
+
+  console.log(chalk.green(`\n✓ Checkpoint restored: ${checkpointName}`));
+  console.log(chalk.gray(`  Phase: ${meta.phase}`));
+  console.log(chalk.gray(`  Files restored: ${files.length}`));
+  console.log(chalk.gray(`  Original date: ${meta.timestamp}\n`));
+}
+
+/**
+ * List checkpoints command
+ */
+export async function checkpointListCommand(featureName, options = {}) {
+  if (!featureName) {
+    console.error(chalk.red('Error: Feature name required'));
+    process.exit(1);
+  }
+
+  const checkpointsDir = getCheckpointsDir(featureName);
+  if (!fs.existsSync(checkpointsDir)) {
+    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
+    return;
+  }
+
+  const checkpoints = fs.readdirSync(checkpointsDir)
+    .filter(d => fs.statSync(path.join(checkpointsDir, d)).isDirectory())
+    .sort()
+    .reverse();
+
+  if (checkpoints.length === 0) {
+    console.log(chalk.gray(`No checkpoints found for '${featureName}'.\n`));
+    return;
+  }
+
+  // JSON output
+  if (options.json) {
+    const list = checkpoints.map(cp => {
+      const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
+      const meta = fs.existsSync(metaPath) ? JSON.parse(fs.readFileSync(metaPath, 'utf8')) : {};
+      return { name: cp, phase: meta.phase, timestamp: meta.timestamp, files: meta.files?.length || 0 };
+    });
+    console.log(JSON.stringify({ feature: featureName, checkpoints: list }, null, 2));
+    return;
+  }
+
+  // Visual output
+  console.log(chalk.cyan(`\nCheckpoints for '${featureName}':\n`));
+
+  for (const cp of checkpoints) {
+    const metaPath = path.join(checkpointsDir, cp, '_checkpoint.json');
+    let meta = {};
+    if (fs.existsSync(metaPath)) {
+      meta = JSON.parse(fs.readFileSync(metaPath, 'utf8'));
+    }
+
+    const date = meta.timestamp ? new Date(meta.timestamp).toLocaleString() : 'unknown';
+    console.log(chalk.white(`  ${cp}`));
+    console.log(chalk.gray(`    Phase: ${meta.phase || 'unknown'} | Files: ${meta.files?.length || '?'} | ${date}`));
+  }
+  console.log('');
+}

package/src/commands/project/doctor.js

@@ -9,6 +9,7 @@ import { pathExists, readJson } from '../../utils/file-copier.js';
 import { checkClaudeMdImport } from '../../utils/claude-md-injector.js';
 import { buildPrIndex } from '../../lib/git/pr-index.js';
 import { pendingPrFeatures, MORPH_BRANCH_RE } from '../../lib/git/pending-prs.js';
+import { prCarriesFeature } from '../../lib/git/pr-files.js';
 import {
   checkCLIOutdated,
   checkProjectOutdated,
@@ -19,6 +20,7 @@ import { checkMissingAgents, checkAgentsDrift } from '../../utils/agents-install
 import { getProjectTags } from '../../lib/stack-filter.js';
 import { auditGraph } from '../../lib/graph/graph-health.js';
 import { auditFeatureLifecycle } from '../../core/state/lifecycle-audit.js';
+import { validateTestNodes, morphConfigPath } from '../../lib/tasks/test-nodes.js';
 
 const isWindows = platform() === 'win32';
 /**
@@ -367,6 +369,43 @@ async function doctorFullCommand(frameworkRoot) {
     check('state.json', false, true, 'not found (run: morph-spec init)');
   }
 
+  // ── 8. project.tests[] — o contrato do config, camada 3 ─────────────────
+  //
+  // As outras duas camadas são o `config.schema.json` (declarativa) e
+  // `validateTestNodes()` chamada pelo `verify` (fail-closed, em uso). Esta
+  // aqui existe para o defeito chegar ANTES do gate: um `id` com typo em
+  // `tests[]` só se manifesta quando alguém roda `morph-spec verify` e lê um
+  // nó vermelho — o doctor o mostra na checagem de saúde, que é onde se olha
+  // primeiro. Reusa `validateTestNodes` (a MESMA autoridade que o verify
+  // consulta): uma segunda leitura do mesmo campo aqui seria uma segunda
+  // opinião sobre o que é um nó válido, e as duas divergiriam.
+  //
+  // PULA de verdade — sem check e sem cabeçalho — quando não há `config.json`
+  // ou quando `project.tests` não foi declarado. Um projeto sem declaração usa
+  // o fallback de quatro passos e não tem contrato a violar; este repositório
+  // é exatamente esse caso, e um check que não pode passar aqui é ruído, não
+  // achado (`test/commands/doctor.test.js`: `doctor --full` sem nenhum `✗`).
+  // WARN e nunca ERROR: a barreira fail-closed é o `verify`; o doctor informa.
+  const testsConfigPath = morphConfigPath(frameworkRoot);
+  if (await pathExists(testsConfigPath)) {
+    let testsConfig = null;
+    try {
+      testsConfig = JSON.parse((await fs.readFile(testsConfigPath, 'utf8')).replace(/^\uFEFF/, ''));
+    } catch {
+      testsConfig = null; // config ilegível já é reportado pelo doctor base
+    }
+    if (testsConfig?.project?.tests !== undefined) {
+      console.log(chalk.cyan('\n  .morph/config/config.json — project.tests[]'));
+      const declared = validateTestNodes(testsConfig, frameworkRoot);
+      const broken = declared.filter((n) => n.status === 'fail');
+      check(`config tests[] (${declared.length - broken.length}/${declared.length})`,
+        broken.length === 0, true,
+        broken.length > 0
+          ? broken.map((n) => n.reason ?? `invalid-test-node: ${n.id}`).join('; ')
+          : '');
+    }
+  }
+
   // ── Display ──────────────────────────────────────────────────────────────
   console.log('\n' + '─'.repeat(60));
   console.log(chalk.bold('\nResults:\n'));
@@ -587,11 +626,12 @@ export async function doctorWorktreesCommand(targetPath, options = {}) {
 
   const issues = auditWorktrees(targetPath);
   // `severity: 'info'` entries (a worktree carrying unintegrated work) and
-  // `severity: 'warn'` entries (a worktree created outside morph's container)
-  // are REPORTED but are not failures — a `doctor --worktrees || ...` in CI must
-  // not go red because somebody has an open PR or a hand-made tree. The human
-  // path below splits the same way; both surfaces must agree on what counts as
-  // broken.
+  // `severity: 'warn'` entries (a worktree created outside morph's container,
+  // and the docker findings from `docker-audit.js`: an orphan stack, a port
+  // held by another compose project) are REPORTED but are not failures — a
+  // `doctor --worktrees || ...` in CI must not go red because somebody has an
+  // open PR, a hand-made tree, or a container still up. The human path below
+  // splits the same way; both surfaces must agree on what counts as broken.
   const isProblem = (i) => !['info', 'warn'].includes(i.severity);
 
   if (options.json) {
@@ -649,7 +689,10 @@ const PR_STALE_DAYS = 7;
  *                         revisão que nenhuma superfície local reivindica.
  *   pr-merged-not-landed — o PR mergeou mas `archive/{f}` não está aqui. O
  *                         archive viaja no diff do PR, então ou falta um
- *                         `git pull`, ou ele não estava no diff.
+ *                         `git pull`, ou ele não estava no diff. Branch
+ *                         `morph/*` cujo diff nunca tocou
+ *                         `.morph/{features,archive}/{f}/` não conta: o nome
+ *                         não prova feature (ver pr-files.js).
  *
  * Offline-safe: índice `null` devolve `null`, NUNCA lista vazia — lista vazia
  * afirmaria "perguntei e não achei nada", que é diferente de "não pude
@@ -679,6 +722,9 @@ function auditPullRequests(root) {
     if (!m || pr.state !== 'MERGED') continue;
     const feature = m[1];
     if (existsSync(join(root, '.morph', 'archive', feature))) continue;
+    // Só `false` (diff lido, sem a feature) cala o aviso; `null` — não pude
+    // ler o diff — o mantém, ou um `git pull` realmente faltando ficaria mudo.
+    if (prCarriesFeature(root, pr.number, feature) === false) continue;
     issues.push({
       feature,
       type: 'pr-merged-not-landed',
@@ -689,6 +735,86 @@ function auditPullRequests(root) {
   return issues;
 }
 
+/**
+ * `morph-spec doctor --ai` — as cinco checagens de projeto .NET com agentes.
+ *
+ * **Superfície própria, no molde do `--mcp`, e é decisão, não acidente.** O
+ * `--ai` NÃO entra no `--full` nem no `doctor` default:
+ *
+ * - o renderer do `--full` é `ok → ✓`, `warn → ⚠`, **`else → ✗`** — não tem o
+ *   ramo `skip → ○`. Uma checagem de IA lá seria VERMELHA neste repositório
+ *   mesmo dizendo "não verificado", e `test/commands/doctor.test.js` exige
+ *   `doesNotMatch(out, /✗/)` para `doctor --full` aqui, com a justificativa
+ *   escrita no próprio teste: *"every check must be satisfiable here — a
+ *   permanently red one teaches nothing"*;
+ * - o `doctor` default é o comando mais rodado do dia, e cinco linhas `○`
+ *   permanentes em todo projeto sem .NET é ruído com custo e sem informação.
+ *
+ * Exit code: 1 se houver ao menos um `error`; 0 caso contrário. `warn` e `skip`
+ * nunca mudam o código de saída.
+ *
+ * @param {string} targetPath
+ * @param {object} [options] - repassado a `collectAiChecks` (`config`, `deps`)
+ * @returns {Promise<Array>} as checagens, para o canário assere-las sem parsear texto
+ */
+export async function doctorAiCommand(targetPath, options = {}) {
+  const { collectAiChecks, aiExitCode, allSkipped } = await import('../../lib/ai/ai-checks.js');
+  const { readMorphConfig } = await import('../../lib/tasks/test-runner.js');
+
+  logger.header('AI Health Check (.NET + agentes)');
+  logger.blank();
+
+  const config = options.config !== undefined ? options.config : readMorphConfig(targetPath);
+  const checks = collectAiChecks(targetPath, { config, deps: options.deps ?? {} });
+
+  if (allSkipped(checks)) {
+    // Condição 4 do silêncio: nenhuma checagem teve insumo. Uma linha, não
+    // cinco `○` vazios — listar cinco vezes "não verificado" é o ruído que
+    // esta superfície existe para não produzir.
+    const reasons = [...new Set(checks.map((c) => c.reason))];
+    for (const reason of reasons) {
+      console.log(chalk.gray(`  ○ Nenhuma das ${checks.length} checagens teve insumo — ${reason}.`));
+    }
+    logger.blank();
+    process.exitCode = 0;
+    return checks;
+  }
+
+  for (const c of checks) {
+    if (c.status === 'ok') {
+      console.log(chalk.green(`  ✓ ${c.name}`));
+    } else if (c.status === 'skip') {
+      console.log(chalk.gray(`  ○ ${c.name}`) + chalk.gray(` — não verificado: ${c.reason}`));
+    } else if (c.status === 'warn') {
+      console.log(chalk.yellow(`  ⚠ ${c.name}`));
+    } else {
+      console.log(chalk.red(`  ✗ ${c.name}`));
+    }
+    for (const f of c.findings) {
+      const mark = f.severity === 'error' ? chalk.red('    ✗') : chalk.yellow('    →');
+      console.log(`${mark} ${chalk.gray(f.message)}`);
+    }
+    for (const file of c.unverified ?? []) {
+      console.log(chalk.gray(`    ○ não verificado: ${relative(targetPath, file) || file} (ilegível)`));
+    }
+  }
+
+  logger.blank();
+  const errors = checks.filter((c) => c.status === 'error').length;
+  const warns = checks.filter((c) => c.status === 'warn').length;
+  const skips = checks.filter((c) => c.status === 'skip').length;
+  const oks = checks.filter((c) => c.status === 'ok').length;
+
+  const summary = `${oks} ok · ${warns} aviso(s) · ${errors} erro(s) · ${skips} não verificada(s)`;
+  if (errors > 0) console.log(chalk.red(`  ❌ ${summary}`));
+  else if (warns > 0) console.log(chalk.yellow(`  ⚠️  ${summary}`));
+  else console.log(chalk.green(`  ✅ ${summary}`));
+  logger.blank();
+
+  process.exitCode = aiExitCode(checks);
+  return checks;
+}
+
 export async function doctorCommand(options = {}) {
   // `--json` and `--prune` only mean something under `--worktrees`. Falling
   // through to the human health check would hand a script a banner and a table
@@ -703,6 +829,22 @@ export async function doctorCommand(options = {}) {
     return false;
   }
 
+  // `--ai` é superfície própria (D1). Combiná-la com outra superfície pediria
+  // dois relatórios com dois códigos de saída no mesmo processo — o segundo
+  // apagaria o primeiro em silêncio. Mesmo molde da guarda acima: recusa em
+  // vez de fingir.
+  if (options.ai) {
+    const conflicts = ['full', 'mcp', 'worktrees'].filter((f) => options[f]);
+    if (conflicts.length) {
+      const flags = conflicts.map((f) => `--${f}`).join(' e ');
+      logger.error(`--ai não se combina com ${flags} — cada superfície tem o seu relatório e o seu código de saída.`);
+      logger.dim('  Rode: morph-spec doctor --ai');
+      process.exitCode = 1;
+      return false;
+    }
+    return doctorAiCommand(process.cwd(), options);
+  }
+
   // Reset mode: remove morph-managed settings entries
   if (options.reset) {
     const targetPath = process.cwd();