@polymorphism-tech/morph-spec 8.47.0 → 9.0.0

package/src/lib/stack/stack-scan.js

@@ -0,0 +1,267 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join, relative } from 'path';
+import { getProjectTags } from '../stack-filter.js';
+import { PACKAGE_LOCATIONS } from '../detectors/index.js';
+import { isTestPath } from '../graph/sanitize.js';
+import { WORKTREE_DIR_NAMES } from '../worktree/dirs.js';
+
+export const SEVERITIES = ['Bloqueante', 'Alto', 'Médio', 'Baixo'];
+export const MAX_FILES = 20000;
+
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', 'bin', 'obj', 'dist', 'build', 'out', 'coverage', '.next', '.morph', '.claude', '.vs', '.idea',
+  ...WORKTREE_DIR_NAMES,
+]);
+const SOURCE_EXT = /\.(cs|csproj|sln|props|ts|tsx)$/i;
+const DOTNET_EXPECTED_MAJOR = 10;
+const WHERE_LIMIT = 5;
+
+function walk(root) {
+  const files = [];
+  const dirs = new Set();
+  let unreadable = 0;
+  let truncated = false;
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { unreadable++; continue; }
+    for (const e of entries) {
+      const full = join(dir, e.name);
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name)) continue;
+        dirs.add(relative(root, full).replace(/\\/g, '/'));
+        stack.push(full);
+      } else if (SOURCE_EXT.test(e.name) || e.name === 'package.json') {
+        if (files.length >= MAX_FILES) { truncated = true; continue; }
+        files.push(relative(root, full).replace(/\\/g, '/'));
+      }
+    }
+  }
+  return { files, dirs, unreadable, truncated };
+}
+
+function reader(root) {
+  const failed = new Set();
+  const read = (file) => {
+    try { return readFileSync(join(root, file), 'utf8'); } catch { failed.add(file); return null; }
+  };
+  return { read, failed };
+}
+
+const majorOf = (version) => {
+  const m = /(\d+)/.exec(String(version ?? ''));
+  return m ? Number(m[1]) : null;
+};
+
+function dotnetPackages(files, read) {
+  const packages = new Map();
+  for (const f of files.filter((x) => /\.(csproj|props)$/i.test(x))) {
+    const text = read(f);
+    if (!text) continue;
+    for (const m of text.matchAll(/<Package(?:Reference|Version)\s+Include="([^"]+)"(?:\s+Version="([^"]*)")?/g)) {
+      if (!packages.has(m[1]) || m[2]) packages.set(m[1], m[2] ?? packages.get(m[1]) ?? null);
+    }
+  }
+  return packages;
+}
+
+function grepFiles(files, read, re) {
+  const hits = [];
+  for (const f of files) {
+    const text = read(f);
+    if (text && re.test(text)) hits.push(f);
+  }
+  return hits;
+}
+
+function auditDotnet(files, read) {
+  const rows = [];
+  const deviations = [];
+  const add = (severity, rule, where, migration) => deviations.push({ severity, stack: 'dotnet', rule, where, migration });
+  const projects = files.filter((f) => f.endsWith('.csproj'));
+  const source = files.filter((f) => f.endsWith('.cs') && !isTestPath(f));
+
+  const frameworks = new Map();
+  for (const p of projects) {
+    const m = /<TargetFrameworks?>([^<]+)</.exec(read(p) ?? '');
+    if (m) for (const tf of m[1].split(';').map((s) => s.trim()).filter(Boolean)) frameworks.set(tf, [...(frameworks.get(tf) ?? []), p]);
+  }
+  const tfs = [...frameworks.keys()];
+  const old = tfs.filter((tf) => /^net\d/.test(tf) && majorOf(tf) < DOTNET_EXPECTED_MAJOR);
+  rows.push({ layer: 'Runtime', detected: tfs.join(', ') || 'nenhum TargetFramework', expected: `net${DOTNET_EXPECTED_MAJOR}.0`, ok: tfs.length > 0 && old.length === 0 });
+  for (const tf of old) add('Bloqueante', `Runtime diferente (${tf})`, frameworks.get(tf), `subir o TargetFramework para net${DOTNET_EXPECTED_MAJOR}.0`);
+
+  const packages = dotnetPackages(files, read);
+  const has = (re) => [...packages.keys()].filter((p) => re.test(p));
+  const ef = has(/^Microsoft\.EntityFrameworkCore/);
+  const npgsql = has(/Npgsql/);
+  const otherDb = has(/^(Microsoft\.EntityFrameworkCore\.SqlServer|Pomelo\.EntityFrameworkCore\.MySql|MySql\.|MySqlConnector|Microsoft\.Data\.SqlClient|System\.Data\.SqlClient)/);
+  rows.push({ layer: 'ORM', detected: ef.length > 0 ? 'EF Core' : (packages.has('Dapper') ? 'Dapper' : 'ausente'), expected: 'EF Core', ok: ef.length > 0 });
+  rows.push({ layer: 'Banco', detected: npgsql.length > 0 ? 'Postgres (Npgsql)' : (otherDb.join(', ') || 'ausente'), expected: 'Neon (Postgres)', ok: npgsql.length > 0 && otherDb.length === 0 });
+  rows.push({ layer: 'IA', detected: has(/^Microsoft\.(Agents\.AI|Extensions\.AI)/).join(', ') || 'ausente', expected: 'MAF quando houver agentes', ok: true });
+  rows.push({ layer: 'Jobs', detected: has(/^Hangfire/).length > 0 ? 'Hangfire' : 'ausente', expected: 'Hangfire só com razão real', ok: true });
+  if (packages.has('Dapper') && ef.length === 0) add('Bloqueante', 'ORM diferente (Dapper puro sem EF Core)', projects, 'migrar o acesso a dados para EF Core');
+  if (otherDb.length > 0) add('Bloqueante', `Banco diferente (${otherDb.join(', ')})`, projects, 'migrar para Neon (Postgres, Npgsql)');
+  for (const p of has(/^Microsoft\.(EntityFrameworkCore|AspNetCore|Extensions)(?!\.AI)/)) {
+    const major = majorOf(packages.get(p));
+    if (major !== null && major < DOTNET_EXPECTED_MAJOR) add('Baixo', `Pacote desatualizado mas compatível (${p} ${packages.get(p)})`, [], `subir para ${DOTNET_EXPECTED_MAJOR}.x`);
+  }
+
+  const newGuid = grepFiles(source, read, /Guid\.NewGuid\(\)/);
+  if (newGuid.length > 0) add('Alto', '`Guid.NewGuid()`', newGuid, 'trocar por `Guid.CreateVersion7()`');
+  const repository = grepFiles(source, read, /interface\s+(IRepository\s*<|IUnitOfWork\b)/);
+  if (repository.length > 0) {
+    const di = grepFiles(source, read, /Add(Scoped|Transient|Singleton)\s*(<\s*(IRepository|IUnitOfWork)|\(\s*typeof\s*\(\s*(IRepository|IUnitOfWork))/);
+    add('Alto', 'Repository genérico (`IRepository<T>`/`IUnitOfWork`)', [...repository, ...di],
+      'código morto: deletar a pasta `Repository/` e as 2 linhas de DI; confirme os consumidores com `morph-spec graph affected IRepository --uses-only`');
+  }
+  const serviceLayer = source.filter((f) => {
+    const text = read(f);
+    return text && /\bclass\s+\w+(Service|Manager)\b/.test(text) && /DbContext/.test(text);
+  });
+  if (serviceLayer.length > 0) add('Alto', 'Camada de Service/Manager entre handler e dados', serviceLayer, 'o handler fala com o `ApplicationDbContext` direto');
+  const rawSql = grepFiles(source, read, /\b(FromSqlRaw|ExecuteSqlRaw|SqlQueryRaw|ExecuteQuery)\s*\(/);
+  if (rawSql.length > 0) add('Alto', 'SQL cru', rawSql, 'LINQ, ou store dedicado com justificativa em ADR');
+  const notSealed = source.filter((f) => {
+    const text = read(f) ?? '';
+    return [...text.matchAll(/^\s*(?:public|internal)\s+((?:\w+\s+)*)class\s+\w+/gm)]
+      .some((m) => !/\b(sealed|abstract|static|partial)\b/.test(m[1]));
+  });
+  if (notSealed.length > 0) add('Médio', 'Classes não-sealed', notSealed, '`sealed` por padrão');
+  const controllers = grepFiles(source, read, /:\s*Controller(Base)?\b/);
+  rows.push({ layer: 'Estrutura', detected: controllers.length > 0 ? `${controllers.length} controller(s) MVC` : 'sem controllers', expected: 'VSA (endpoint por slice)', ok: controllers.length === 0 });
+  return { rows, deviations };
+}
+
+const UI_LIBRARIES = ['@mui/material', 'antd', '@chakra-ui/react', 'bootstrap', 'react-bootstrap', '@mantine/core'];
+
+function auditNextjs(root, read) {
+  const rows = [];
+  const deviations = [];
+  const add = (severity, rule, where, migration) => deviations.push({ severity, stack: 'nextjs', rule, where, migration });
+  const packages = PACKAGE_LOCATIONS
+    .map((loc) => ({ loc, file: loc === '.' ? 'package.json' : `${loc}/package.json` }))
+    .filter(({ file }) => existsSync(join(root, file)))
+    .map((p) => {
+      const text = read(p.file);
+      let deps = null;
+      try { const pkg = JSON.parse(text); deps = { ...pkg.dependencies, ...pkg.devDependencies }; } catch { deps = null; }
+      return { ...p, deps };
+    })
+    .filter((p) => p.deps);
+  const next = packages.find((p) => p.deps.next);
+  if (!next) {
+    const other = packages.find((p) => p.deps.react || p.deps.vue);
+    rows.push({ layer: 'Frontend', detected: other ? (other.deps.vue ? 'Vue' : 'React sem Next.js') : 'sem frontend', expected: 'Next.js App Router', ok: !other });
+    if (other) add('Bloqueante', 'Frontend sem Next.js', [other.file], 'migrar para Next.js App Router');
+    return { rows, deviations };
+  }
+  const base = next.loc === '.' ? '' : `${next.loc}/`;
+  const isDir = (p) => { try { return statSync(join(root, p)).isDirectory(); } catch { return false; } };
+  const appRouter = isDir(`${base}app`) || isDir(`${base}src/app`);
+  const pagesRouter = isDir(`${base}pages`) || isDir(`${base}src/pages`);
+  rows.push({ layer: 'Frontend', detected: `Next.js ${next.deps.next}`, expected: 'Next.js App Router', ok: true });
+  rows.push({ layer: 'Roteamento', detected: appRouter ? 'App Router' : (pagesRouter ? 'Pages Router' : 'não detectado'), expected: 'App Router', ok: appRouter || !pagesRouter });
+  if (pagesRouter && !appRouter) add('Médio', 'Pages Router em vez de App Router', [next.file], 'migrar as rotas para `app/`');
+  rows.push({ layer: 'Estilo', detected: next.deps.tailwindcss ? 'Tailwind' : 'ausente', expected: 'Tailwind', ok: Boolean(next.deps.tailwindcss) });
+  rows.push({ layer: 'Motion', detected: next.deps['framer-motion'] || next.deps.motion ? 'Framer Motion' : 'ausente', expected: 'Framer Motion', ok: true });
+  const shadcn = existsSync(join(root, base, 'components.json'));
+  const otherUi = UI_LIBRARIES.filter((lib) => next.deps[lib]);
+  rows.push({ layer: 'UI', detected: otherUi.join(', ') || (shadcn ? 'shadcn' : 'ausente'), expected: 'shadcn', ok: otherUi.length === 0 });
+  if (otherUi.length > 0) add('Médio', `Biblioteca de UI diferente (${otherUi.join(', ')})`, [next.file], 'shadcn sobre Tailwind');
+  return { rows, deviations };
+}
+
+const AUDITS = { dotnet: auditDotnet, nextjs: auditNextjs };
+
+/**
+ * Deterministic stack audit of the tree at `root`, driven by `config.project.stack`:
+ * only the configured stacks are judged; no configured stack means no rule runs.
+ *
+ * @param {string} root
+ * @param {object|null} config the parsed `.morph/config/config.json`
+ */
+export function scanStack(root, config) {
+  const stack = typeof config?.project?.stack === 'string' ? config.project.stack : null;
+  const tags = getProjectTags(config);
+  const { files, unreadable, truncated } = walk(root);
+  const { read, failed } = reader(root);
+  const hasDotnet = files.some((f) => /\.(csproj|sln|cs)$/i.test(f));
+  const hasNode = files.some((f) => f.endsWith('package.json') || /\.(ts|tsx)$/i.test(f));
+  const greenfield = !hasDotnet && !hasNode;
+
+  const rows = [];
+  const deviations = [];
+  const notes = [];
+  if (!greenfield) {
+    for (const tag of tags) {
+      const audit = AUDITS[tag];
+      if (!audit) continue;
+      const result = tag === 'nextjs' ? audit(root, read) : audit(files, read);
+      rows.push(...result.rows);
+      deviations.push(...result.deviations);
+    }
+    if (hasDotnet && !tags.includes('dotnet')) notes.push('Há código .NET, mas `dotnet` não está em `project.stack` — não auditado.');
+    if (hasNode && !tags.includes('nextjs') && files.some((f) => f.endsWith('package.json'))) notes.push('Há `package.json`, mas `nextjs` não está em `project.stack` — não auditado.');
+  }
+  const unjudged = tags.filter((t) => !AUDITS[t]);
+  if (unjudged.length > 0) notes.push(`Sem regras de varredura para: ${unjudged.join(', ')}.`);
+  if (truncated) notes.push(`Varredura parou em ${MAX_FILES} arquivos.`);
+  if (unreadable + failed.size > 0) notes.push(`${unreadable + failed.size} arquivo(s) ou pasta(s) ilegível(is) ignorado(s).`);
+
+  deviations.sort((a, b) => SEVERITIES.indexOf(a.severity) - SEVERITIES.indexOf(b.severity));
+  const audited = tags.some((t) => AUDITS[t]);
+  return { stack, tags, greenfield, audited, rows, deviations, notes, filesScanned: files.length };
+}
+
+const cell = (s) => String(s).replace(/\|/g, '\\|');
+
+function whereText(where) {
+  if (!where || where.length === 0) return '';
+  const unique = [...new Set(where)];
+  const shown = unique.slice(0, WHERE_LIMIT).map((w) => `\`${w}\``).join(', ');
+  return ` — onde: ${shown}${unique.length > WHERE_LIMIT ? ` (+${unique.length - WHERE_LIMIT})` : ''} (${unique.length} arquivo(s))`;
+}
+
+export function notAuditedReason(result) {
+  return result.stack
+    ? `não auditado: nenhuma regra de varredura para \`${result.stack}\``
+    : 'não auditado: project.stack ausente em .morph/config/config.json';
+}
+
+/** The scan as the markdown report the morph-plan skill reads. */
+export function renderStackScan(result, title) {
+  const out = [`# Stack Scan — ${title}`, ''];
+  out.push(`**Stack configurado:** ${result.stack ? `\`${result.stack}\`` : 'ausente em `project.stack` — nenhuma regra aplicada'}`);
+  const blocking = result.deviations.filter((d) => d.severity === 'Bloqueante' || d.severity === 'Alto');
+  const status = result.greenfield ? 'GREENFIELD (sem código fonte)'
+    : !result.audited ? notAuditedReason(result)
+    : result.deviations.length === 0 ? 'Em compliance' : `Desvios detectados (${result.deviations.length})`;
+  out.push(`**Resultado:** ${status}`, '');
+
+  if (result.rows.length > 0) {
+    out.push('## Stack detectado', '', '| Camada | Detectado | Esperado | Status |', '|---|---|---|---|');
+    for (const r of result.rows) out.push(`| ${cell(r.layer)} | ${cell(r.detected)} | ${cell(r.expected)} | ${r.ok ? '✓' : '✗'} |`);
+    out.push('');
+  }
+  if (result.deviations.length > 0) {
+    out.push('## Desvios (por severidade)', '');
+    for (const severity of SEVERITIES) {
+      const list = result.deviations.filter((d) => d.severity === severity);
+      if (list.length === 0) continue;
+      out.push(`### ${severity}`, '');
+      for (const d of list) out.push(`- ${d.rule}${whereText(d.where)} — migração: ${d.migration}`);
+      out.push('');
+    }
+  }
+  out.push('## Notas', '');
+  out.push('- Contagens por varredura de texto (grep): superestimam consumidores, porque não separam herança de uso. Para um símbolo, `morph-spec graph affected <símbolo> --uses-only`.');
+  for (const n of result.notes) out.push(`- ${n}`);
+  out.push('', '## Recomendação', '');
+  if (result.greenfield) out.push('Compliance trivial: aplicar o stack padrão de `MORPH.md`.');
+  else if (!result.audited) out.push('Nenhuma regra rodou, então nada aqui atesta compliance: declare `project.stack` e rode o stack-scan de novo.');
+  else if (blocking.length > 0) out.push('Há desvio Bloqueante ou Alto: entra na árvore de decisões como "a migração entra nesta feature ou vira feature separada?".');
+  else out.push('Nenhum desvio Bloqueante ou Alto: prossiga com o plano.');
+  return `${out.join('\n')}\n`;
+}

package/src/lib/standards/registry.js

@@ -0,0 +1,43 @@
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+export const STANDARDS_FILE = 'STANDARDS.json';
+export const STANDARDS_META_FILE = 'STANDARDS.meta.json';
+
+/** Per-standard fields that live in the sidecar, keyed by id: no runtime reader needs them to pick a standard. */
+export const META_FIELDS = ['aliases', 'verifiedAgainst', 'provedBy'];
+
+export function metaPathFor(standardsJsonPath) {
+  return join(dirname(standardsJsonPath), STANDARDS_META_FILE);
+}
+
+function readMeta(standardsJsonPath) {
+  const path = metaPathFor(standardsJsonPath);
+  if (!existsSync(path)) return { standards: {}, sharedAliases: {} };
+  try {
+    const meta = JSON.parse(readFileSync(path, 'utf8'));
+    return { standards: meta?.standards || {}, sharedAliases: meta?.sharedAliases || {} };
+  } catch {
+    return { standards: {}, sharedAliases: {} };
+  }
+}
+
+/**
+ * The registry as every reader sees it: runtime entries with their sidecar
+ * fields merged back by id. A missing or unreadable sidecar degrades to "no
+ * aliases"; a missing or unreadable STANDARDS.json throws.
+ * @param {string} standardsJsonPath
+ * @returns {{ version: string|null, standards: object[], sharedAliases: Record<string, string[]> }}
+ */
+export function loadStandardsRegistry(standardsJsonPath) {
+  const runtime = JSON.parse(readFileSync(standardsJsonPath, 'utf8'));
+  const meta = readMeta(standardsJsonPath);
+  const standards = (Array.isArray(runtime.standards) ? runtime.standards : []).map((s) => {
+    const extra = meta.standards[s.id];
+    if (!extra) return s;
+    const merged = { ...s };
+    for (const field of META_FIELDS) if (extra[field] !== undefined) merged[field] = extra[field];
+    return merged;
+  });
+  return { version: runtime.version ?? null, standards, sharedAliases: meta.sharedAliases };
+}

package/src/lib/standards/sections.js

@@ -0,0 +1,58 @@
+// The literal regex of the `github-slugger` package: anchors are read off the rendered .md.
+const SLUG_STRIP = /[ -⸀-⹿\\'!"#$%&()*+,./:;<=>?@[\]^`{|}~ ]/g;
+
+export function ghSlug(heading) {
+  return heading.trim().toLowerCase().replace(SLUG_STRIP, '').replace(/ /g, '-');
+}
+
+/**
+ * Every heading outside code fences, with the slug GitHub gives it (`-1`, `-2`
+ * for repeats) and the line it sits on.
+ * @param {string} text
+ * @returns {Array<{ level: number, title: string, slug: string, line: number }>}
+ */
+export function markdownHeadings(text) {
+  const out = [];
+  const seen = new Map();
+  let inFence = false;
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*```/.test(line)) { inFence = !inFence; continue; }
+    if (inFence) continue;
+    const m = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line.replace(/\r$/, ''));
+    if (!m) continue;
+    let slug = ghSlug(m[2]);
+    if (seen.has(slug)) {
+      const n = seen.get(slug) + 1;
+      seen.set(slug, n);
+      slug = `${slug}-${n}`;
+    } else {
+      seen.set(slug, 0);
+    }
+    out.push({ level: m[1].length, title: m[2], slug, line: i });
+  }
+  return out;
+}
+
+export function headingSlugs(text) {
+  return new Set(markdownHeadings(text).map((h) => h.slug));
+}
+
+/**
+ * The section a slug opens: its heading through the line before the next
+ * heading of the same or a higher level. `null` when no heading has the slug.
+ * @param {string} text
+ * @param {string} slug - with or without the leading `#`
+ * @returns {string|null}
+ */
+export function sectionBySlug(text, slug) {
+  const want = String(slug).replace(/^#/, '');
+  const all = markdownHeadings(text);
+  const idx = all.findIndex((h) => h.slug === want);
+  if (idx === -1) return null;
+  const start = all[idx];
+  const next = all.slice(idx + 1).find((h) => h.level <= start.level);
+  const lines = text.split('\n');
+  return lines.slice(start.line, next ? next.line : lines.length).join('\n').replace(/\s+$/, '') + '\n';
+}

package/src/lib/tasks/eval-node.js

@@ -183,26 +183,18 @@ export function readEvalStamp(cacheRoot) {
  *
  * **There is no `skip` for a bad cache.** A skip here would recreate the hole
  * this harness closed twice: a green gate over a verification that never
- * happened. The only skip is scope — an eval suite does not belong in the
- * per-task loop.
+ * happened.
  *
  * @param {string} projectPath
  * @param {object} node - a resolved test node with `runner === 'evals'`
- * @param {{taskId?: string|null, refresh?: boolean}} [options]
- * @returns {{status: 'skip'|'fail'|null, reason: string|null}} status null means RUN
+ * @param {{refresh?: boolean}} [options]
+ * @returns {{status: 'fail'|null, reason: string|null}} status null means RUN
  */
 export function evalPreflight(projectPath, node, options = {}) {
-  const { taskId = null, refresh = false } = options;
+  const { refresh = false } = options;
 
   if (node?.runner !== EVAL_RUNNER) return { status: null, reason: null };
 
-  // Scope first: an eval suite does not pay for itself in a per-task loop, and
-  // the result Gate 3 reads is the feature-scoped one. Same treatment `e2e: true`
-  // already gets.
-  if (taskId) {
-    return { status: 'skip', reason: 'eval node runs at feature scope only' };
-  }
-
   const { cacheRoot, envFile } = resolveEvalPaths(node, projectPath);
 
   // In refresh the tree is being (re)written; demanding a populated, stamped

package/src/lib/tasks/test-nodes.js

@@ -51,41 +51,6 @@ import { PACKAGE_LOCATIONS } from '../detectors/index.js';
  */
 export const TEST_RUNNERS = ['dotnet', 'vitest', 'jest', 'node-test', 'playwright', 'none', EVAL_RUNNER];
 
-/**
- * The task-group vocabulary a node can declare via `groups`, and that
- * `tasks.json` entries declare via `group` (framework/schemas/tasks.schema.json
- * `~:28`) — ONE enum, checked to agree by canary, never two that drift.
- * Single home for B3's task-scope selection (`test-scope.js`) to import from.
- */
-export const TASK_GROUPS = ['backend', 'frontend', 'tests', 'infra', 'docs'];
-
-/**
- * Which group(s) a node serves when it does NOT declare `groups` itself,
- * keyed by runner. `none` and `evals` are deliberately ABSENT — a command
- * nobody could read (`none`) and a declared eval suite (`evals`) have no
- * honest default group, so `effectiveGroups()` answers null for them rather
- * than guessing one.
- */
-export const RUNNER_DEFAULT_GROUPS = {
-  dotnet: ['backend'],
-  'node-test': ['backend'],
-  vitest: ['frontend'],
-  jest: ['frontend'],
-  playwright: ['frontend'],
-};
-
-/**
- * Which task group(s) this node answers to: what it DECLARED, or else its
- * runner's default. **null is "no mapping"**, never an invented guess — B3's
- * task-scope selection reads null as "this node is unscoped, always runs".
- *
- * @param {import('./test-nodes.js').TestNode} node
- * @returns {string[]|null}
- */
-export function effectiveGroups(node) {
-  return node?.groups ?? RUNNER_DEFAULT_GROUPS[node?.runner] ?? null;
-}
-
 /**
  * A node id is what `--filter` matches and what keys `runs[]`. Lowercase and
  * dash-only so it survives a shell argument and a JSON key without quoting.
@@ -209,11 +174,6 @@ function makeNode(partial) {
     // eval node"** — distinct from an eval node with an empty block, which
     // `validateTestNodes` already refused.
     evals: partial.evals ?? null,
-    // Declared task-group(s) this node serves (§B3 task-scope selection).
-    // **null is "not declared"**, distinct from an empty array (which
-    // `firstProblem` refuses outright) — effectiveGroups() falls back to the
-    // runner's default only when this is null.
-    groups: partial.groups ?? null,
     status: partial.status ?? null,
     reason: partial.reason ?? null,
   };
@@ -296,28 +256,6 @@ function firstProblem(raw, projectPath) {
     return `evals applies only to runner "${EVAL_RUNNER}"`;
   }
 
-  if (raw.groups !== undefined) {
-    if (!Array.isArray(raw.groups)) {
-      return 'groups must be a non-empty array';
-    }
-    if (raw.groups.length === 0) {
-      return 'groups must be a non-empty array';
-    }
-    const invalid = raw.groups.filter((g) => !TASK_GROUPS.includes(g));
-    if (invalid.length > 0) {
-      return `groups must contain only ${TASK_GROUPS.join(' | ')} (invalid: ${invalid.join(', ')})`;
-    }
-    const seenGroups = new Set();
-    const duplicates = new Set();
-    for (const g of raw.groups) {
-      if (seenGroups.has(g)) duplicates.add(g);
-      seenGroups.add(g);
-    }
-    if (duplicates.size > 0) {
-      return `groups must not contain duplicates (repeated: ${[...duplicates].join(', ')})`;
-    }
-  }
-
   // The cwd checks come last because they are the expensive ones, and because
   // a node that is malformed in shape has a better error to report first.
   const cwd = typeof raw.cwd === 'string' ? raw.cwd.trim() : '.';
@@ -390,7 +328,6 @@ export function validateTestNodes(config, projectPath = null) {
       e2e: entry.e2e ?? false,
       linuxImage: entry.linuxImage ?? null,
       evals: entry.evals ?? null,
-      groups: entry.groups ?? null,
       projectCount: 1,
     });
   });
@@ -586,14 +523,9 @@ export function morphConfigPath(projectPath = '.') {
  *     the declaration the command came to update);
  *   - a declared node with no measurement (a baseline recorded for part of a
  *     fleet says nothing true about the rest of it);
- *   - a measurement carrying a task-scope `selection` (#87): narrowed, scoped
- *     out or run whole INSIDE a task-scoped verify, it measured a recorte, and
- *     `expectedCount` is the whole suite's number. `verify` already refuses
- *     `--record-baseline` with a task id before the build; this is the second
- *     barrier, at the writer, so no caller can route around it.
  *
  * @param {string} projectPath - Project root
- * @param {Array<{id: string, count: number|null, selection?: object|null}>} measurements - One per node that ran
+ * @param {Array<{id: string, count: number|null}>} measurements - One per node that ran
  * @returns {{ recorded: boolean, reason: string|null, updates: Array<{id: string, from: number|null, to: number}>, path: string }}
  */
 export function recordTestBaselines(projectPath, measurements) {
@@ -614,11 +546,6 @@ export function recordTestBaselines(projectPath, measurements) {
     return refuse('config.json não declara project.tests[] — não há entrada onde gravar a baseline');
   }
 
-  const recortes = measurements.filter((m) => m.selection != null).map((m) => m.id);
-  if (recortes.length > 0) {
-    return refuse(`medição de recorte de task em: ${recortes.join(', ')} — baseline só de execução inteira, sem {task}`);
-  }
-
   const unreadable = measurements.filter((m) => !Number.isInteger(m.count)).map((m) => m.id);
   if (unreadable.length > 0) {
     return refuse(`contagem desconhecida em: ${unreadable.join(', ')} — desconhecido nunca vira 0`);