@polymorphism-tech/morph-spec 8.35.1 → 8.37.0

package/src/commands/tasks/dag.js

@@ -5,6 +5,7 @@ import { parseTasksJsonLenient } from '../../lib/tasks/tasks-json-parser.js';
 import { planDispatch } from '../../lib/tasks/dispatch-planner.js';
 import { renderMermaidFlowchart } from '../../lib/tasks/mermaid-renderer.js';
 import { checkUseCases } from '../../lib/specs/usecase-check.js';
+import { checkArtifactCriteria } from '../../lib/specs/done-criteria-check.js';
 
 /**
  * `morph-spec dag <feature>` — analyze the tasks.json DAG and print the
@@ -51,10 +52,16 @@ export async function dagCommand(featureName, options = {}) {
     // against a plan that points at a use case nobody can read.
     const ucCheck = checkUseCases(data, join(planDir, 'usecases'));
 
+    // Artifact-postcondition warning (issue #87). Lexical, not wiring — it
+    // runs over ALL tasks even when the feature has no use cases at all
+    // (checkUseCases short-circuits above in that case), because a task's
+    // own doneCriteria can describe an artifact with no use case in sight.
+    const artifactCriteria = checkArtifactCriteria(data, join(planDir, 'usecases'));
+
     const plan = planDispatch(data);
 
     if (options.json) {
-      console.log(JSON.stringify({ ...plan, useCases: ucCheck }, null, 2));
+      console.log(JSON.stringify({ ...plan, useCases: ucCheck, artifactCriteria }, null, 2));
       if (ucCheck.errors.length) process.exit(1);
       return;
     }
@@ -71,6 +78,11 @@ export async function dagCommand(featureName, options = {}) {
       console.error(chalk.yellow(`\n⚠ Use cases — ${plural(ucCheck.warnings.length, 'aviso', 'avisos')}`));
       for (const w of ucCheck.warnings) console.error(chalk.yellow(`  ${w}`));
     }
+    if (artifactCriteria.warnings.length) {
+      console.error(chalk.yellow(`\n⚠ Critérios de artefato — ${plural(artifactCriteria.warnings.length, 'aviso', 'avisos')}`));
+      for (const w of artifactCriteria.warnings) console.error(chalk.yellow(`  ${w}`));
+      console.error(chalk.gray('  Teste que lê texto de arquivo não prova comportamento (morph-plan §2, "Por que artefato").'));
+    }
 
     console.log(chalk.bold(`\n📊 DAG — ${featureName}`));
     console.log('━'.repeat(60));

package/src/commands/validation/verify.js

@@ -1,9 +1,8 @@
 import chalk from 'chalk';
-import { existsSync, readFileSync } from 'fs';
+import { readFileSync } from 'fs';
 import { resolve, join } from 'path';
 import { getFeature, updateFeature } from '../../core/state/state-manager.js';
-import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
-import { runVerify, VerifyUsageError } from '../../lib/validators/verify-runner.js';
+import { runVerify, readTask, VerifyUsageError } from '../../lib/validators/verify-runner.js';
 import { resolvePrimaryRoot } from '../project/worktree.js';
 import { getHeadSha } from '../../lib/git/default-branch.js';
 import { EVAL_RUNNER } from '../../lib/tasks/eval-node.js';
@@ -15,6 +14,28 @@ function statusIcon(status) {
   return chalk.gray('–');
 }
 
+/**
+ * One line per test run naming what the task-scope recorte did to it (#87):
+ * narrowed (how many selectors, from how many test files), whole, out of scope
+ * or full, each with its reason. A green `tests` line alone cannot say that the
+ * task ran 12 tests instead of 3.082. Feature-scope runs carry no selection and
+ * print nothing extra; `feedback[]` is untouched either way.
+ *
+ * @param {Array<{id: string, selection: object|null}>} [runs]
+ * @returns {string[]}
+ */
+function selectionLines(runs = []) {
+  return runs
+    .filter((run) => run.selection)
+    .map((run) => {
+      const { mode, reason, selectors = [], files = [] } = run.selection;
+      const detail = mode === 'narrowed'
+        ? `${selectors.length} selector(s) from ${files.length} test file(s)`
+        : (reason ?? '');
+      return chalk.gray(`      ↳ ${run.id.padEnd(10)} ${mode.padEnd(12)} ${detail}`);
+    });
+}
+
 /**
  * Human-readable rendering of a runVerify() result — mirrors the
  * ✓/✗-per-node + feedback-list style of formatScoreBreakdown() in
@@ -51,6 +72,7 @@ function formatVerifyResult(result) {
       detail = `${node.durationMs}ms`;
     }
     lines.push(`  ${icon} ${name.padEnd(11)} ${node.status.padEnd(5)} ${chalk.gray(detail)}`);
+    if (name === 'tests') lines.push(...selectionLines(node.runs));
   }
 
   if (result.feedback.length > 0) {
@@ -166,16 +188,11 @@ function evalsStatusOf(result) {
   return 'skip';
 }
 
-/** Read tasks.json's task list for a feature; [] if missing/corrupt. */
-function readTasks(featureName) {
-  try {
-    const tasksPath = getAbsoluteOutputPath(process.cwd(), featureName, 'tasks');
-    if (!existsSync(tasksPath)) return [];
-    return JSON.parse(readFileSync(tasksPath, 'utf8')).tasks || [];
-  } catch {
-    return [];
-  }
-}
+/**
+ * The options that make a FEATURE-scope run partial, each with the `reason` it
+ * reports when it keeps the stamp from being written — first match wins.
+ */
+const PARTIAL_RUN_FLAGS = [['filter', 'filtered'], ['skipTests', 'skip-tests'], ['skipBuild', 'skip-build']];
 
 /**
  * `morph-spec verify <feature> [task]` — the deterministic code-before-judge
@@ -194,7 +211,8 @@ function readTasks(featureName) {
  *     `morph-spec score` gives for the same situation);
  *   - `--filter` that matches no declared node (a filtered-to-empty run is
  *     green and proves nothing);
- *   - `--record-baseline` with nowhere to write (no `config.json`);
+ *   - `--record-baseline` with nowhere to write (no `config.json`), or with a
+ *     task id (a recorte de task is never a fleet baseline, #87);
  *   - `--linux` without Docker.
  * The last three arrive as `VerifyUsageError` from the runner.
  */
@@ -210,9 +228,10 @@ export async function verifyCommand(featureName, taskId, options = {}) {
     process.exit(2);
   }
 
+  // The runner's own reader (one reader of tasks.json for verify, #87): null
+  // means tasks.json or the task is missing, and both are this usage error.
   if (taskId) {
-    const tasks = readTasks(featureName);
-    if (!tasks.some((t) => t.id === taskId)) {
+    if (!readTask(process.cwd(), featureName, taskId)) {
       console.error(chalk.red(`\n❌ Task "${taskId}" not found in tasks.json for feature "${featureName}"\n`));
       process.exit(2);
     }
@@ -232,6 +251,9 @@ export async function verifyCommand(featureName, taskId, options = {}) {
       refreshCache: options.refreshCache,
       linux: options.linux,
       linuxImage: options.linuxImage,
+      // Task scope: switch the recorte off (#87). At feature scope nothing is
+      // ever narrowed, so the flag is a documented no-op there, not an error.
+      full: options.full,
     });
   } catch (err) {
     // A wrong invocation is exit 2, like an unknown feature or task — never a
@@ -249,9 +271,29 @@ export async function verifyCommand(featureName, taskId, options = {}) {
   // the suite in order to write `expectedCount`. Persisting a `verification`
   // stamp from it would let a maintenance run stand in for the proof a gate
   // asks for — the same class of confusion as a hand-typed baseline.
+  //
+  // `--filter` at FEATURE scope is the other side of the same hole (#87): the
+  // run is narrowed to a subset of nodes, but the stamp it would write carries
+  // `scope: 'feature'` — the one scope risk-detector.js trusts unconditionally.
+  // A partial run must not stand in for the proof a gate asks for, same as
+  // `--record-baseline` above. `--skip-tests` and `--skip-build` are the same
+  // partial run through another door (#113): a skipped node never reddens the
+  // rollup, so the stamp said `pass` over a suite (or a build) that never ran,
+  // and no gate rule reads a skipped `tests`/`build`. Task scope is unaffected:
+  // that stamp already says `scope: 'task:{id}'` (which pauses the ship gate on
+  // its own), and `taskVerifications` never claimed to cover more than the
+  // task. Checked AFTER `--no-persist` (via the `!options.noPersist` guard) so
+  // an explicit `--no-persist` keeps its own reason instead of being reported
+  // as one of these — the flags are all "don't write", but decidePersistence()
+  // already owns the former's reason.
+  const partialFeatureRun = (!options.noPersist && !taskId)
+    ? PARTIAL_RUN_FLAGS.find(([flag]) => options[flag])?.[1] ?? null
+    : null;
   const { persist, reason } = options.recordBaseline
     ? { persist: false, reason: 'record-baseline' }
-    : decidePersistence({ cwd: process.cwd(), featureName, noPersist: options.noPersist });
+    : partialFeatureRun
+      ? { persist: false, reason: partialFeatureRun }
+      : decidePersistence({ cwd: process.cwd(), featureName, noPersist: options.noPersist });
 
   let compact = null;
   if (persist) {

package/src/core/paths/output-schema.js

@@ -72,6 +72,13 @@ export const OUTPUT_SCHEMA = {
 
   // 3-implement/
   recap:          { filename: 'recap.md',              phaseDir: '3-implement', phase: 'implement', protected: false },
+  // N files, one per task whose doneCriteria judges what a MODEL answers
+  // (morph-plan §5). Runtime evidence: input, model, output, verdict — pointing
+  // at the `runner: "evals"` node when the stack declares one. CONDITIONAL by
+  // construction: never in phases.json requiredOutputs. Readers: morph-review
+  // dispatch prompt, proof rubric eval-de-modelo, test-coverage Q7.
+  evidencias:     { dirname: 'evidencias', filenamePattern: '^T\\d+\\.md$', displayFilename: '{taskId}.md',
+                    phaseDir: '3-implement', phase: 'implement', protected: false, multi: true },
 
   // 4-review/
   reviewReport:   { filename: 'review-report.md',      phaseDir: '4-review',    phase: 'review',    protected: false },

package/src/lib/detectors/index.js

@@ -1,217 +1,225 @@
-/**
- * @fileoverview Project Detector
- *
- * Scans a project directory for stack, architecture, UI library, and integrations.
- * Used by mcp-setup, morph-init, and session-start hooks.
- *
- * @module detectors/index
- */
-
-import { existsSync, readFileSync, readdirSync } from 'fs';
-import { join } from 'path';
-
-/**
- * Detect project structure from filesystem evidence.
- *
- * @param {string} targetPath - Root path of the project
- * @param {Object} [opts] - Options
- * @param {boolean} [opts.generateStandards=false] - Whether to generate inferred markdown
- * @returns {{ structure: { stack: string, architecture: string|null, uiLibrary: string|null, integrations: string[], hasVercel: boolean }, inferred: { markdown: string } }}
- */
-export function detectProject(targetPath, opts = {}) {
-  const structure = {
-    stack: 'unknown',
-    architecture: null,
-    uiLibrary: null,
-    integrations: [],
-    hasVercel: false,
-  };
-
-  try {
-    // ── Package.json analysis ──────────────────────────────────────────────
-    // Collect deps from root and common monorepo subfolders
-    const pkgLocations = ['.', 'src/frontend', 'src/web', 'frontend', 'apps/web', 'packages/app'];
-    const allDeps = {};
-    let rootPkg = null;
-    let scripts = [];
-    for (const loc of pkgLocations) {
-      const pkgPath = join(targetPath, loc, 'package.json');
-      if (!existsSync(pkgPath)) continue;
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
-        if (loc === '.') rootPkg = pkg;
-        Object.assign(allDeps, pkg.dependencies, pkg.devDependencies);
-        scripts.push(...Object.keys(pkg.scripts || {}));
-        // Track frontend path for config
-        if (loc !== '.' && (pkg.dependencies?.next || pkg.dependencies?.react || pkg.dependencies?.vue)) {
-          structure.frontendPath = loc;
-        }
-      } catch { /* invalid JSON */ }
-    }
-    const depNames = Object.keys(allDeps);
-
-    if (depNames.length > 0) {
-
-      // Stack detection from deps
-      if (depNames.includes('next')) {
-        structure.stack = 'nextjs';
-      } else if (depNames.includes('react')) {
-        structure.stack = 'react';
-      } else if (depNames.includes('vue')) {
-        structure.stack = 'vue';
-      } else if (depNames.includes('express') || depNames.includes('fastify') || depNames.includes('hono')) {
-        structure.stack = 'nodejs';
-      } else if (rootPkg?.name) {
-        structure.stack = 'nodejs';
-      }
-
-      // UI library detection
-      if (existsSync(join(targetPath, 'components.json')) || existsSync(join(targetPath, structure.frontendPath || '.', 'components.json')) || depNames.includes('@shadcn/ui')) {
-        structure.uiLibrary = 'shadcn';
-      }
-
-      // Integrations
-      if (depNames.includes('@neondatabase/serverless') || depNames.includes('postgres') || depNames.includes('pg')) {
-        structure.integrations.push('neon');
-      }
-      if (depNames.includes('@neondatabase/auth')) {
-        structure.integrations.push('neon-auth');
-      }
-      if (depNames.includes('stripe')) {
-        structure.integrations.push('stripe');
-      }
-
-      // Vercel detection
-      if (depNames.includes('vercel') || scripts.includes('vercel')) {
-        structure.hasVercel = true;
-      }
-    }
-
-    // ── .csproj detection ──────────────────────────────────────────────────
-    let hasDotnet = false;
-    const csprojLocations = ['.', 'src', 'src/Api', 'src/Web', 'src/backend'];
-
-    function checkCsproj(filePath) {
-      hasDotnet = true;
-      try {
-        const content = readFileSync(filePath, 'utf8');
-        if (content.includes('Hangfire')) {
-          if (!structure.integrations.includes('hangfire')) structure.integrations.push('hangfire');
-        }
-      } catch { /* ignore */ }
-    }
-
-    for (const loc of csprojLocations) {
-      try {
-        const dir = join(targetPath, loc);
-        if (!existsSync(dir)) continue;
-        const entries = readdirSyncSafe(dir);
-        // Direct .csproj files
-        for (const e of entries.filter(f => f.endsWith('.csproj'))) {
-          checkCsproj(join(dir, e));
-        }
-        // One level deeper (e.g., src/backend/MyProject/*.csproj)
-        for (const sub of entries) {
-          const subDir = join(dir, sub);
-          for (const e of readdirSyncSafe(subDir).filter(f => f.endsWith('.csproj'))) {
-            checkCsproj(join(subDir, e));
-          }
-        }
-      } catch { /* ignore */ }
-    }
-
-    // Determine stack: monorepo (nextjs+dotnet), dotnet, or keep frontend stack
-    if (hasDotnet) {
-      if (structure.stack === 'nextjs' || structure.stack === 'react' || structure.stack === 'vue') {
-        // Monorepo: frontend + .NET backend
-        structure.stack = `${structure.stack}+dotnet`;
-      } else if (structure.stack === 'unknown') {
-        structure.stack = 'dotnet';
-      }
-    }
-
-    // ── vercel.json detection ──────────────────────────────────────────────
-    if (existsSync(join(targetPath, 'vercel.json'))) {
-      structure.hasVercel = true;
-    }
-
-    // ── tsconfig.json detection (fallback for stack) ────────────────────────
-    if (structure.stack === 'unknown' && existsSync(join(targetPath, 'tsconfig.json'))) {
-      structure.stack = 'nodejs';
-    }
-
-    // ── Architecture detection ─────────────────────────────────────────────
-    try {
-      const configPath = join(targetPath, '.morph/config/config.json');
-      if (existsSync(configPath)) {
-        const config = JSON.parse(readFileSync(configPath, 'utf8'));
-        if (config.architecture?.style) {
-          structure.architecture = config.architecture.style;
-        }
-      }
-    } catch { /* ignore */ }
-
-    // ── Docker detection ───────────────────────────────────────────────────
-    if (existsSync(join(targetPath, 'docker-compose.yml')) ||
-        existsSync(join(targetPath, 'docker-compose.yaml')) ||
-        existsSync(join(targetPath, 'Dockerfile'))) {
-      if (!structure.integrations.includes('docker')) structure.integrations.push('docker');
-    }
-
-    // ── Azure detection ────────────────────────────────────────────────────
-    const azureSignals = [
-      '.azure',
-      'azure-pipelines.yml',
-      'infra/main.bicep',
-      'infra',
-    ];
-    const hasAzure = azureSignals.some(signal => {
-      const p = join(targetPath, signal);
-      if (!existsSync(p)) return false;
-      if (signal === 'infra') {
-        // Check for .bicep files inside infra/
-        return readdirSyncSafe(p).some(f => f.endsWith('.bicep'));
-      }
-      return true;
-    });
-    if (hasAzure && !structure.integrations.includes('azure')) {
-      structure.integrations.push('azure');
-    }
-  } catch {
-    // Fail-safe — return defaults
-  }
-
-  return {
-    structure,
-    inferred: {
-      markdown: opts.generateStandards ? generateInferredMarkdown(structure) : '',
-    },
-  };
-}
-
-/**
- * Safe readdir that returns [] on error.
- * @param {string} dir
- * @returns {string[]}
- */
-function readdirSyncSafe(dir) {
-  try {
-    return readdirSync(dir);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Generate a markdown summary from detected structure.
- * @param {Object} structure
- * @returns {string}
- */
-function generateInferredMarkdown(structure) {
-  const lines = [`## Detected Stack: ${structure.stack}`];
-  if (structure.architecture) lines.push(`Architecture: ${structure.architecture}`);
-  if (structure.uiLibrary) lines.push(`UI Library: ${structure.uiLibrary}`);
-  if (structure.integrations.length > 0) lines.push(`Integrations: ${structure.integrations.join(', ')}`);
-  if (structure.hasVercel) lines.push(`Vercel: detected`);
-  return lines.join('\n');
-}
+/**
+ * @fileoverview Project Detector
+ *
+ * Scans a project directory for stack, architecture, UI library, and integrations.
+ * Used by mcp-setup, morph-init, and session-start hooks.
+ *
+ * @module detectors/index
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Common monorepo locations for a frontend `package.json`, root included.
+ *
+ * Exported so `discoverFrontendPackages()` (src/lib/tasks/test-nodes.js, #87
+ * PR B) scans the SAME candidate list this detector already uses — one
+ * spelling of "where a frontend package might live", not two that drift.
+ */
+export const PACKAGE_LOCATIONS = ['.', 'src/frontend', 'src/web', 'frontend', 'apps/web', 'packages/app'];
+
+/**
+ * Detect project structure from filesystem evidence.
+ *
+ * @param {string} targetPath - Root path of the project
+ * @param {Object} [opts] - Options
+ * @param {boolean} [opts.generateStandards=false] - Whether to generate inferred markdown
+ * @returns {{ structure: { stack: string, architecture: string|null, uiLibrary: string|null, integrations: string[], hasVercel: boolean }, inferred: { markdown: string } }}
+ */
+export function detectProject(targetPath, opts = {}) {
+  const structure = {
+    stack: 'unknown',
+    architecture: null,
+    uiLibrary: null,
+    integrations: [],
+    hasVercel: false,
+  };
+
+  try {
+    // ── Package.json analysis ──────────────────────────────────────────────
+    // Collect deps from root and common monorepo subfolders
+    const allDeps = {};
+    let rootPkg = null;
+    let scripts = [];
+    for (const loc of PACKAGE_LOCATIONS) {
+      const pkgPath = join(targetPath, loc, 'package.json');
+      if (!existsSync(pkgPath)) continue;
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+        if (loc === '.') rootPkg = pkg;
+        Object.assign(allDeps, pkg.dependencies, pkg.devDependencies);
+        scripts.push(...Object.keys(pkg.scripts || {}));
+        // Track frontend path for config
+        if (loc !== '.' && (pkg.dependencies?.next || pkg.dependencies?.react || pkg.dependencies?.vue)) {
+          structure.frontendPath = loc;
+        }
+      } catch { /* invalid JSON */ }
+    }
+    const depNames = Object.keys(allDeps);
+
+    if (depNames.length > 0) {
+
+      // Stack detection from deps
+      if (depNames.includes('next')) {
+        structure.stack = 'nextjs';
+      } else if (depNames.includes('react')) {
+        structure.stack = 'react';
+      } else if (depNames.includes('vue')) {
+        structure.stack = 'vue';
+      } else if (depNames.includes('express') || depNames.includes('fastify') || depNames.includes('hono')) {
+        structure.stack = 'nodejs';
+      } else if (rootPkg?.name) {
+        structure.stack = 'nodejs';
+      }
+
+      // UI library detection
+      if (existsSync(join(targetPath, 'components.json')) || existsSync(join(targetPath, structure.frontendPath || '.', 'components.json')) || depNames.includes('@shadcn/ui')) {
+        structure.uiLibrary = 'shadcn';
+      }
+
+      // Integrations
+      if (depNames.includes('@neondatabase/serverless') || depNames.includes('postgres') || depNames.includes('pg')) {
+        structure.integrations.push('neon');
+      }
+      if (depNames.includes('@neondatabase/auth')) {
+        structure.integrations.push('neon-auth');
+      }
+      if (depNames.includes('stripe')) {
+        structure.integrations.push('stripe');
+      }
+
+      // Vercel detection
+      if (depNames.includes('vercel') || scripts.includes('vercel')) {
+        structure.hasVercel = true;
+      }
+    }
+
+    // ── .csproj detection ──────────────────────────────────────────────────
+    let hasDotnet = false;
+    const csprojLocations = ['.', 'src', 'src/Api', 'src/Web', 'src/backend'];
+
+    function checkCsproj(filePath) {
+      hasDotnet = true;
+      try {
+        const content = readFileSync(filePath, 'utf8');
+        if (content.includes('Hangfire')) {
+          if (!structure.integrations.includes('hangfire')) structure.integrations.push('hangfire');
+        }
+      } catch { /* ignore */ }
+    }
+
+    for (const loc of csprojLocations) {
+      try {
+        const dir = join(targetPath, loc);
+        if (!existsSync(dir)) continue;
+        const entries = readdirSyncSafe(dir);
+        // Direct .csproj files
+        for (const e of entries.filter(f => f.endsWith('.csproj'))) {
+          checkCsproj(join(dir, e));
+        }
+        // One level deeper (e.g., src/backend/MyProject/*.csproj)
+        for (const sub of entries) {
+          const subDir = join(dir, sub);
+          for (const e of readdirSyncSafe(subDir).filter(f => f.endsWith('.csproj'))) {
+            checkCsproj(join(subDir, e));
+          }
+        }
+      } catch { /* ignore */ }
+    }
+
+    // Determine stack: monorepo (nextjs+dotnet), dotnet, or keep frontend stack
+    if (hasDotnet) {
+      if (structure.stack === 'nextjs' || structure.stack === 'react' || structure.stack === 'vue') {
+        // Monorepo: frontend + .NET backend
+        structure.stack = `${structure.stack}+dotnet`;
+      } else if (structure.stack === 'unknown') {
+        structure.stack = 'dotnet';
+      }
+    }
+
+    // ── vercel.json detection ──────────────────────────────────────────────
+    if (existsSync(join(targetPath, 'vercel.json'))) {
+      structure.hasVercel = true;
+    }
+
+    // ── tsconfig.json detection (fallback for stack) ────────────────────────
+    if (structure.stack === 'unknown' && existsSync(join(targetPath, 'tsconfig.json'))) {
+      structure.stack = 'nodejs';
+    }
+
+    // ── Architecture detection ─────────────────────────────────────────────
+    try {
+      const configPath = join(targetPath, '.morph/config/config.json');
+      if (existsSync(configPath)) {
+        const config = JSON.parse(readFileSync(configPath, 'utf8'));
+        if (config.architecture?.style) {
+          structure.architecture = config.architecture.style;
+        }
+      }
+    } catch { /* ignore */ }
+
+    // ── Docker detection ───────────────────────────────────────────────────
+    if (existsSync(join(targetPath, 'docker-compose.yml')) ||
+        existsSync(join(targetPath, 'docker-compose.yaml')) ||
+        existsSync(join(targetPath, 'Dockerfile'))) {
+      if (!structure.integrations.includes('docker')) structure.integrations.push('docker');
+    }
+
+    // ── Azure detection ────────────────────────────────────────────────────
+    const azureSignals = [
+      '.azure',
+      'azure-pipelines.yml',
+      'infra/main.bicep',
+      'infra',
+    ];
+    const hasAzure = azureSignals.some(signal => {
+      const p = join(targetPath, signal);
+      if (!existsSync(p)) return false;
+      if (signal === 'infra') {
+        // Check for .bicep files inside infra/
+        return readdirSyncSafe(p).some(f => f.endsWith('.bicep'));
+      }
+      return true;
+    });
+    if (hasAzure && !structure.integrations.includes('azure')) {
+      structure.integrations.push('azure');
+    }
+  } catch {
+    // Fail-safe — return defaults
+  }
+
+  return {
+    structure,
+    inferred: {
+      markdown: opts.generateStandards ? generateInferredMarkdown(structure) : '',
+    },
+  };
+}
+
+/**
+ * Safe readdir that returns [] on error.
+ * @param {string} dir
+ * @returns {string[]}
+ */
+function readdirSyncSafe(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Generate a markdown summary from detected structure.
+ * @param {Object} structure
+ * @returns {string}
+ */
+function generateInferredMarkdown(structure) {
+  const lines = [`## Detected Stack: ${structure.stack}`];
+  if (structure.architecture) lines.push(`Architecture: ${structure.architecture}`);
+  if (structure.uiLibrary) lines.push(`UI Library: ${structure.uiLibrary}`);
+  if (structure.integrations.length > 0) lines.push(`Integrations: ${structure.integrations.join(', ')}`);
+  if (structure.hasVercel) lines.push(`Vercel: detected`);
+  return lines.join('\n');
+}