@polymorphism-tech/morph-spec 8.47.0 → 9.0.0

package/src/lib/specs/design-seed.js

@@ -0,0 +1,18 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { templateSourcePath, writeIfAbsent } from '../../core/templates/template-seed.js';
+import { renderTemplateString } from '../../core/templates/template-renderer.js';
+import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
+
+export function seedDesignArtifacts(featureName, cwd = process.cwd()) {
+  const mockupsTemplate = readFileSync(templateSourcePath('ui-mockups', cwd), 'utf8');
+  const mockups = writeIfAbsent(
+    getAbsoluteOutputPath(cwd, featureName, 'uiMockups'),
+    renderTemplateString(mockupsTemplate, { FEATURE_NAME: featureName, DATE: new Date().toISOString().slice(0, 10) }),
+  );
+  const designSystem = writeIfAbsent(
+    join(cwd, '.morph', 'context', 'design-system.md'),
+    readFileSync(templateSourcePath('context-design-system', cwd), 'utf8'),
+  );
+  return { mockups, designSystem };
+}

package/src/lib/specs/frontmatter.js

@@ -0,0 +1,44 @@
+const FRONTMATTER_RE = /^(?---\r?\n)([\s\S]*?)(\r?\n---(?:\r?\n|$))/;
+
+/**
+ * Set (or replace) a single top-level frontmatter field, preserving every
+ * other line, the original EOL style, and anything after the closing `---`.
+ * A document with no frontmatter block is returned unchanged.
+ *
+ * @param {string} content
+ * @param {string} key
+ * @param {string} value - written as-is; quote it first when it is free text
+ * @returns {string}
+ */
+export function setFrontmatterField(content, key, value) {
+  const m = FRONTMATTER_RE.exec(content);
+  if (!m || m.index !== 0) return content;
+
+  const [full, open, body, close] = m;
+  const eol = full.includes('\r\n') ? '\r\n' : '\n';
+  const fieldLine = new RegExp(`^${key}:[ \\t]*.*$`, 'm');
+  // Function replacer: a value carrying `$&` or `$1` is text, not a pattern.
+  const next = fieldLine.test(body)
+    ? body.replace(fieldLine, () => `${key}: ${value}`)
+    : `${body}${eol}${key}: ${value}`;
+
+  return open + next + close + content.slice(full.length);
+}
+
+/**
+ * Read a single top-level frontmatter field; `null` when absent or there is no
+ * frontmatter block. A double-quoted value is read as the JSON string it is
+ * written as; a single-quoted one as YAML reads it (`''` is a quote).
+ */
+export function readFrontmatterField(content, key) {
+  const m = FRONTMATTER_RE.exec(content);
+  if (!m || m.index !== 0) return null;
+  const line = new RegExp(`^${key}:[ \\t]*(.+?)[ \\t]*$`, 'm').exec(m[2]);
+  if (!line) return null;
+  const raw = line[1].trim();
+  if (raw.length >= 2 && raw.startsWith('"') && raw.endsWith('"')) {
+    try { return JSON.parse(raw); } catch { return raw; }
+  }
+  if (raw.length >= 2 && raw.startsWith("'") && raw.endsWith("'")) return raw.slice(1, -1).replace(/''/g, "'");
+  return raw;
+}

package/src/lib/specs/gfm-table.js

@@ -0,0 +1,17 @@
+/** A markdown table separator row: `|---|:--:|`, with or without the outer pipes. */
+export const SEPARATOR_ROW_RE = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)*\|?\s*$/;
+
+/** A line that belongs to a table: it carries an unescaped pipe (GFM does not require the leading one). */
+export const isTableLine = (line) => /(?<!\\)\|/.test(line);
+
+/**
+ * Split a table row on unescaped pipes, outer pipes optional; `\|` inside a
+ * cell is a literal pipe.
+ *
+ * @param {string} row
+ * @returns {string[]} trimmed cells
+ */
+export function tableCells(row) {
+  const inner = row.trim().replace(/^\|/, '').replace(/(?<!\\)\|$/, '');
+  return inner.split(/(?<!\\)\|/).map((c) => c.replace(/\\\|/g, '|').trim());
+}

package/src/lib/specs/old-format.js

@@ -0,0 +1,68 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { OUTPUT_SCHEMA } from '../../core/paths/output-schema.js';
+import { parseWorktreeList } from '../../commands/project/worktree.js';
+
+const FINISHED = new Set(['completed', 'abandoned']);
+const PREVIOUS_LINE = '8.47';
+
+export function isOldFormatFeature(featureDir) {
+  const plan = join(featureDir, OUTPUT_SCHEMA.plan.phaseDir, OUTPUT_SCHEMA.plan.filename);
+  if (existsSync(plan)) return false;
+  return existsSync(join(featureDir, '2-plan', 'tasks.json')) || existsSync(join(featureDir, '0-proposal'));
+}
+
+function featureStatus(featureDir) {
+  try {
+    return JSON.parse(readFileSync(join(featureDir, 'feature.json'), 'utf8'))?.status ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function featureDirs(tree) {
+  const base = join(tree, '.morph', 'features');
+  try {
+    return readdirSync(base, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => [e.name, join(base, e.name)]);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Features still in flight, in the root and in every git worktree, written in
+ * the layout this CLI no longer drives. Archived ones live outside `.morph/features/`.
+ *
+ * @param {string} root
+ * @param {{ listTrees?: (cwd: string) => Array<{ path: string }> }} [deps]
+ * @returns {Array<{ feature: string, trees: string[] }>}
+ */
+export function findOldFormatFeatures(root, { listTrees = parseWorktreeList } = {}) {
+  const trees = [resolve(root)];
+  for (const wt of listTrees(root)) {
+    const p = resolve(wt.path);
+    if (!trees.some((t) => t.toLowerCase() === p.toLowerCase())) trees.push(p);
+  }
+  const found = new Map();
+  for (const tree of trees) {
+    for (const [name, dir] of featureDirs(tree)) {
+      if (FINISHED.has(featureStatus(dir)) || !isOldFormatFeature(dir)) continue;
+      if (!found.has(name)) found.set(name, []);
+      found.get(name).push(tree);
+    }
+  }
+  return [...found.entries()].map(([feature, where]) => ({ feature, trees: where }));
+}
+
+export function oldFormatGuardLines(found, root) {
+  const lines = [
+    `Recusado: ${found.length} feature(s) em voo no formato anterior ao plan.md (proposal/spec/tasks.json), que esta versão não conduz:`,
+  ];
+  for (const { feature, trees } of found) {
+    const where = trees.map((t) => (resolve(t) === resolve(root) ? 'raiz' : t)).join(', ');
+    lines.push(`  - ${feature} (${where})`);
+  }
+  lines.push(`  Termine cada uma na ${PREVIOUS_LINE}: \`npx @polymorphism-tech/morph-spec@${PREVIOUS_LINE} <comando>\` (por exemplo \`finish <feature> --pr\`),`);
+  lines.push('  ou arquive sem integrar: `morph-spec archive <feature> --force` (o Gate 3 dela não foi aprovado). Depois rode o `update` de novo.');
+  return lines;
+}

package/src/lib/specs/revocations.js

@@ -1,156 +1,98 @@
 /**
- * The plan's declaration of what a feature supersedes in the project's acervo:
- * the "UCs e ADRs que esta feature altera ou revoga" section of `spec.md`.
- *
- *   ## UCs e ADRs que esta feature altera ou revoga
- *
- *   | Id | Mudança | Substituto | Escopo em que o antigo ainda vale |
- *   |---|---|---|---|
- *   | UC-{nn} | parcial | UC-{nn} | {onde o antigo ainda vale} |
- *   | {feature}/ADR-{nnn} | total | — | — |
- *
- * Columns are positional, so the header wording is free. Parsing is pure: the
- * finish applies the entries (`acervo-lifecycle.js`), and `dag`/`usecase
- * check` report the problems while `spec.md` can still be edited — it freezes
- * at Gate 2, so a bad row found at close time can no longer be fixed there.
- *
- * Nothing ambiguous is applied: a row with any problem, and every row of an id
- * declared twice, stays out of `entries`. A table inside a code fence is an
- * example, never a declaration.
+ * The ADRs of the project index that a plan revokes: the table under
+ * `### Conflitos com o acervo` whose first header cell is `ADR`, with columns
+ * `{feature}/ADR-{nnn}`, `total|parcial` and the scope where the old one still holds.
+ * plan-check reports the problems while the plan can still change (it freezes
+ * at the plan gate); nothing ambiguous reaches the finish.
  */
 
-import { SEPARATOR_ROW_RE, UC_ID_RE, isTableLine, tableCells } from './acervo-format.js';
-
-export const REVOCATIONS_TITLE = 'UCs e ADRs que esta feature altera ou revoga';
+import { SEPARATOR_ROW_RE, isTableLine, tableCells } from './gfm-table.js';
 
 /** ADR numbers restart in every feature, so only `{feature}/ADR-{nnn}` is unambiguous. */
 export const ADR_REF_RE = /^[a-z0-9][a-z0-9-]*\/ADR-\d+$/;
 
-const HEADING_RE = /^(#{1,6})\s+(.+?)\s*#*\s*$/;
 const FENCE_RE = /^\s*(```|~~~)/;
-const ID_TOKEN_RE = /\b(?:UC|ADR)-\d+\b/;
-/** A list item: the shape a revocation takes when the author skips the table. */
+const REF_TOKEN_RE = /\b[a-z0-9][a-z0-9-]*\/ADR-\d+\b/;
 const LIST_ITEM_RE = /^\s*(?:[-*+]|\d+[.)])\s/;
-
 const CHANGES = new Map([['total', 'total'], ['parcial', 'parcial'], ['partial', 'parcial']]);
 
-/** `—`, `–`, `-` and an empty cell all mean "none". */
 const isNone = (cell) => /^(?:—|–|-)?$/.test(cell);
-
-/** Id-like cells tolerate the typography an author reaches for: `code` and **bold**. */
 const bare = (cell) => cell.replace(/^[`*]+|[`*]+$/g, '').trim();
 
-/**
- * The problems of one data row; `[]` = the row is applicable.
- * @returns {{ entry: object|null, problems: Array<{ id: string|null, reason: string, message: string }> }}
- */
 function readRow(line) {
   const problems = [];
   const problem = (id, reason, message) => problems.push({ id, reason, message });
 
   const row = tableCells(line);
-  if (row.length < 4) {
-    problem(null, 'malformed-row', `linha com ${row.length} coluna(s), esperado 4 (Id | Mudança | Substituto | Escopo): ${line.trim()}`);
+  if (row.length < 3) {
+    problem(null, 'malformed-row', `linha com ${row.length} coluna(s), esperado 3 (ADR | Mudança | Escopo): ${line.trim()}`);
     return { entry: null, problems };
   }
   const id = bare(row[0]);
-  const changeCell = bare(row[1]).toLowerCase();
-  const substitute = isNone(bare(row[2])) ? null : bare(row[2]);
-  const scope = isNone(row[3]) ? null : row[3];
+  const change = CHANGES.get(bare(row[1]).toLowerCase());
+  const scope = isNone(row[2]) ? null : row[2];
 
-  const kind = UC_ID_RE.test(id) ? 'uc' : ADR_REF_RE.test(id) ? 'adr' : null;
-  if (!kind) {
-    problem(id || null, 'malformed-id', `"${id}" não é um UC-{nn} nem um {feature}/ADR-{nnn}`);
+  if (!ADR_REF_RE.test(id)) {
+    problem(id || null, 'malformed-id', `"${id}" não é um {feature}/ADR-{nnn}`);
     return { entry: null, problems };
   }
-
-  const change = CHANGES.get(changeCell);
   if (!change) problem(id, 'malformed-change', `${id}: mudança "${bare(row[1])}" — use total ou parcial`);
-
-  if (kind === 'uc' && !substitute) {
-    problem(id, 'missing-substitute', `${id}: UC revogado precisa do substituto (UC-{nn}) — é o superseded_by do acervo`);
-  } else if (substitute && !(kind === 'uc' ? UC_ID_RE : ADR_REF_RE).test(substitute)) {
-    problem(id, 'malformed-substitute',
-      `${id}: substituto "${substitute}" — esperado ${kind === 'uc' ? 'UC-{nn}' : '{feature}/ADR-{nnn}'}`);
-  } else if (substitute === id) {
-    problem(id, 'self-substitute', `${id}: o substituto é o próprio ${id}`);
-  }
-
   if (change === 'parcial' && !scope) {
     problem(id, 'missing-scope', `${id}: revogação parcial precisa dizer onde o antigo ainda vale (coluna Escopo)`);
   } else if (change === 'total' && scope) {
     problem(id, 'scope-on-total', `${id}: revogação total com escopo "${scope}" — se o antigo ainda vale em algum lugar, a mudança é parcial`);
   }
 
-  return { entry: problems.length ? { id } : { kind, id, change, substitute, scope }, problems };
+  return { entry: problems.length ? { id } : { id, change, scope }, problems };
 }
 
 /**
- * @param {string} content - the whole `spec.md`
+ * @param {string|null} conflicts - the text of `### Conflitos com o acervo` (`parsePlan(...).conflicts.text`)
  * @returns {{
- *   declared: boolean,
- *   entries: Array<{ kind: 'uc'|'adr', id: string, change: 'total'|'parcial', substitute: string|null, scope: string|null }>,
+ *   entries: Array<{ id: string, change: 'total'|'parcial', scope: string|null }>,
  *   problems: Array<{ id: string|null, reason: string, message: string }>
  * }}
- *   `declared: false` — no section at all (a plan written before it existed).
  */
-export function parseRevocations(content) {
-  const lines = String(content ?? '').split(/\r?\n/);
-  const title = REVOCATIONS_TITLE.toLowerCase();
-
-  let start = -1;
-  let level = 0;
-  for (let i = 0; i < lines.length; i++) {
-    const h = HEADING_RE.exec(lines[i]);
-    if (h && h[2].toLowerCase().startsWith(title)) { start = i + 1; level = h[1].length; break; }
-  }
-  if (start === -1) return { declared: false, entries: [], problems: [] };
-
-  let end = lines.length;
-  for (let i = start; i < lines.length; i++) {
-    const h = HEADING_RE.exec(lines[i]);
-    if (h && h[1].length <= level) { end = i; break; }
-  }
-
+export function parseRevocations(conflicts) {
   const problems = [];
-  const rows = []; // { id, entry } in order, applicable or not
+  const rows = [];
   let fenced = false;
-  let separatorSeen = false;
-  let tableLines = 0;
+  let table = null;
 
-  for (const line of lines.slice(start, end)) {
-    if (FENCE_RE.test(line)) { fenced = !fenced; continue; }
+  for (const line of String(conflicts ?? '').split(/\r?\n/)) {
+    if (FENCE_RE.test(line)) { fenced = !fenced; table = null; continue; }
     if (fenced) continue;
 
     if (!isTableLine(line)) {
-      const stray = LIST_ITEM_RE.test(line) ? ID_TOKEN_RE.exec(line) : null;
+      table = null;
+      const stray = LIST_ITEM_RE.test(line) ? REF_TOKEN_RE.exec(line) : null;
       if (stray) {
         problems.push({ id: stray[0], reason: 'outside-table',
-          message: `${stray[0]} aparece fora da tabela — só as linhas da tabela são aplicadas no finish` });
+          message: `${stray[0]} aparece fora da tabela ADR | Mudança | Escopo — só as linhas da tabela são aplicadas no finish` });
       }
       continue;
     }
-    tableLines++;
-    if (SEPARATOR_ROW_RE.test(line)) { separatorSeen = true; continue; }
-    if (!separatorSeen) continue; // the header row: its wording is free
-
+    if (!table) {
+      table = { revocations: bare(tableCells(line)[0] ?? '').toLowerCase() === 'adr', separatorSeen: false };
+      continue;
+    }
+    if (!table.revocations) continue;
+    if (!table.separatorSeen) {
+      if (SEPARATOR_ROW_RE.test(line)) { table.separatorSeen = true; continue; }
+      problems.push({ id: null, reason: 'unreadable-table',
+        message: 'tabela de revogação ilegível — falta a linha separadora (|---|---|---|) depois do cabeçalho; nenhuma linha foi lida' });
+      table.revocations = false;
+      continue;
+    }
     const { entry, problems: rowProblems } = readRow(line);
     problems.push(...rowProblems);
     if (entry) rows.push(entry);
   }
 
-  if (tableLines > 0 && !separatorSeen) {
-    problems.push({ id: null, reason: 'unreadable-table',
-      message: 'tabela ilegível — falta a linha separadora (|---|---|---|---) depois do cabeçalho; nenhuma linha foi lida' });
-  }
-
-  // An id declared twice is ambiguous as a whole: none of its rows applies.
   const count = new Map();
   for (const r of rows) count.set(r.id, (count.get(r.id) ?? 0) + 1);
   for (const [id, n] of count) {
     if (n > 1) problems.push({ id, reason: 'duplicate-id', message: `${id} aparece em ${n} linhas — nenhuma foi aplicada; deixe uma só` });
   }
-  const entries = rows.filter((r) => r.kind && count.get(r.id) === 1);
-
-  return { declared: true, entries, problems };
+  return { entries: rows.filter((r) => r.change && count.get(r.id) === 1), problems };
 }

package/src/lib/specs/screen-checklist.js

@@ -3,14 +3,14 @@
  * dados precisa (volume, paginação, ordenação, filtro, os três estados,
  * mobile, abas) escritas por tela, na fase uiux.
  *
- * Existe porque o que o design não pergunta não vira `doneCriteria`, e o que
- * não é critério ninguém entrega: telas de admin saíam listando tudo, sem
+ * Existe porque o que o design não pergunta não vira cenário, e o que
+ * não é cenário ninguém entrega: telas de admin saíam listando tudo, sem
  * paginar nem ordenar, com o design aprovado. Os leitores do MESMO parser:
  *
  *   - `gate-check uiux` pausa com os problemas nomeados;
  *   - `approve`/`advance` com assinatura `auto` recusam a mesma pausa sem uma
  *     decisão gravada (`uiuxAutoApprovalBlock`) — a regra é a do risk-detector;
- *   - `gate-check review` exige que o avaliador registre a conferência de cada
+ *   - `gate-check review` exige que o verificador registre a conferência de cada
  *     item decidido contra a tela entregue (`checklistCoverage`).
  *
  * Mockup no formato ANTERIOR ao checklist (telas `## S001: …`, sem nenhuma
@@ -27,7 +27,7 @@ import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import { fileURLToPath } from 'url';
 import { getAbsoluteOutputPath } from '../../core/paths/output-schema.js';
-import { evaluatorScreenChecklist } from '../evaluator-report.js';
+import { verifierScreenChecklist } from '../review-reports.js';
 import { LEGACY_MOCKUP_EXEMPTION, uiuxChecklistPause } from '../risk-detector.js';
 
 const PACKAGE_AGENTS = fileURLToPath(new URL('../../../framework/agents.json', import.meta.url));
@@ -52,7 +52,7 @@ export const SCREEN_CHECKLIST_ITEMS = [
 ];
 
 /**
- * Itens que o avaliador não confere contra a tela: a superfície decide QUAIS
+ * Itens que o verificador não confere contra a tela: a superfície decide QUAIS
  * standards a tela lê, não um comportamento que a tela entregue exiba.
  */
 const NOT_VERIFIED_AT_REVIEW = new Set(['superficie']);
@@ -180,8 +180,8 @@ const labelOf = (id) => SCREEN_CHECKLIST_ITEMS.find((item) => item.id === id)?.l
 
 /**
  * As superfícies que a persona `ui-designer` declara no `agents.json` — o
- * vocabulário válido do item `Superfície`, que o `morph-plan` §5a usa para
- * somar os standards da tela em `tasks[].standards`. Lê a cópia instalada do
+ * vocabulário válido do item `Superfície`, que o `morph-plan` usa para
+ * somar os standards da tela no `standards:` da fatia. Lê a cópia instalada do
  * projeto; sem ela (este repositório), a do pacote. Persona sem `surfaces`
  * (instalação anterior ao campo) devolve null: o valor não é validado.
  *
@@ -189,14 +189,15 @@ const labelOf = (id) => SCREEN_CHECKLIST_ITEMS.find((item) => item.id === id)?.l
  * @returns {string[]|null}
  */
 export function knownSurfaces(cwd) {
+  const surfaces = readAgentsJson(cwd)?.agents?.['ui-designer']?.surfaces;
+  return surfaces && typeof surfaces === 'object' && !Array.isArray(surfaces) ? Object.keys(surfaces) : null;
+}
+
+/** The project's installed `agents.json`, else the package's; null when unreadable. */
+export function readAgentsJson(cwd) {
   for (const path of [join(cwd, '.morph', 'framework', 'agents.json'), PACKAGE_AGENTS]) {
     if (!existsSync(path)) continue;
-    try {
-      const surfaces = JSON.parse(readFileSync(path, 'utf8'))?.agents?.['ui-designer']?.surfaces;
-      return surfaces && typeof surfaces === 'object' && !Array.isArray(surfaces) ? Object.keys(surfaces) : null;
-    } catch {
-      return null;
-    }
+    try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
   }
   return null;
 }
@@ -257,7 +258,7 @@ export function auditScreenChecklist(markdown, { surfaces = null } = {}) {
  *
  * `mockups: false` é "a feature não tem mockup" — nada a cobrar. No review, o
  * que se cobra é a conferência (`uncovered`: itens decididos sem linha na
- * seção do avaliador), não o design, que já passou pelo Gate uiux.
+ * seção do verificador), não o design, que já passou pelo Gate uiux.
  *
  * @param {string} cwd
  * @param {string} featureName
@@ -272,7 +273,7 @@ export function collectScreenChecklist(cwd, featureName, gateName) {
   const signal = { mockups: true, legacy: audit.legacy, screens: audit.screens.map((s) => s.name), problems: audit.problems };
   if (audit.legacy) signal.exempt = LEGACY_MOCKUP_EXEMPTION;
   if (gateName === 'review') {
-    const report = evaluatorScreenChecklist(cwd, featureName);
+    const report = verifierScreenChecklist(cwd, featureName);
     signal.section = report.section;
     signal.uncovered = checklistCoverage(mockups, report.section ? report.body : '');
   }
@@ -300,13 +301,13 @@ export function uiuxAutoApprovalBlock(cwd, featureName, feature) {
 }
 
 /**
- * O que o avaliador deixou de conferir: por tela do mockup, os itens com
+ * O que o verificador deixou de conferir: por tela do mockup, os itens com
  * decisão (nem "não se aplica", nem a superfície) sem linha na seção
  * `## Checklist de tela` do relatório. Uma linha que o avaliador marca como
  * não verificável conta como conferida — o que pausa é a AUSÊNCIA da linha.
  *
  * @param {string} designMarkdown - o `1-design/mockups.md`
- * @param {string} reportSection - o corpo da seção do `evaluator-report.md`
+ * @param {string} reportSection - o corpo da seção do `verifier.md`
  * @returns {string[]} `"<tela>: <item>, <item>"` por tela com lacuna
  */
 export function checklistCoverage(designMarkdown, reportSection) {

package/src/lib/stack/dotnet-build-ignores.js

@@ -0,0 +1,47 @@
+import { readdirSync } from 'fs';
+import { join } from 'path';
+import { ensureDotnetBuildIgnores } from '../../utils/file-copier.js';
+import { getProjectTags } from '../stack-filter.js';
+import { readMorphConfig } from '../tasks/test-runner.js';
+import { readPlanChecks } from '../plan/checks.js';
+import { WORKTREE_DIR_NAMES } from '../worktree/dirs.js';
+
+export const DOTNET_IMPLEMENTERS = ['dotnet-senior', 'ef-modeler', 'maf-expert'];
+
+const SKIPPED_DIRS = new Set([...WORKTREE_DIR_NAMES, 'node_modules', 'bin', 'obj']);
+const DOTNET_PROJECT_FILE = /\.(?:csproj|slnx?)$/i;
+const MAX_DEPTH = 6;
+
+export function hasDotnetProjectFile(root, depth = 0) {
+  let entries;
+  try { entries = readdirSync(root, { withFileTypes: true }); } catch { return false; }
+  if (entries.some((e) => e.isFile() && DOTNET_PROJECT_FILE.test(e.name))) return true;
+  if (depth >= MAX_DEPTH) return false;
+  return entries.some((e) => e.isDirectory() && !e.name.startsWith('.') && !SKIPPED_DIRS.has(e.name)
+    && hasDotnetProjectFile(join(root, e.name), depth + 1));
+}
+
+function planHasDotnetSlice(tree, featureName) {
+  if (!featureName) return false;
+  const { checks } = readPlanChecks(tree, featureName);
+  return (checks?.slices || []).some((slice) => DOTNET_IMPLEMENTERS.includes(String(slice.persona || '').replace(/^morph-/, '')));
+}
+
+/**
+ * "Is this a .NET project?" from what is known before the first code commit:
+ * the declared `project.stack`, a .NET implementer in the plan's slices, or a
+ * .csproj/.sln/.slnx already in the tree. Greenfield has only the second.
+ */
+export function isDotnetProject(tree, { featureName, configRoot = tree } = {}) {
+  if (getProjectTags(readMorphConfig(configRoot)).includes('dotnet')) return true;
+  return planHasDotnetSlice(tree, featureName) || hasDotnetProjectFile(tree);
+}
+
+/** @returns {string[]} the `.gitignore` entries added to `tree`; `[]` when not .NET or on any error */
+export function seedDotnetBuildIgnores(tree, options = {}) {
+  try {
+    return isDotnetProject(tree, options) ? ensureDotnetBuildIgnores(tree) : [];
+  } catch {
+    return [];
+  }
+}