@polymorphism-tech/morph-spec 10.1.1 → 10.5.2

package/src/lib/review-confirmation.js

@@ -0,0 +1,67 @@
+import { execFileSync } from 'child_process';
+import { basename } from 'path';
+import { treeMovedSince } from './git/evidence-staleness.js';
+import { isTestOnly, securityReviewFor } from './risk-detector.js';
+
+function resolveCommit(cwd, ref) {
+  try {
+    return execFileSync('git', ['rev-parse', '--verify', `${ref}^{commit}`], { cwd, stdio: 'pipe' }).toString().trim();
+  } catch {
+    return null;
+  }
+}
+
+function changedBetween(cwd, from, to) {
+  try {
+    return execFileSync('git', ['diff', '--name-only', '--no-renames', from, to, '--', '.', ':(exclude).morph'], { cwd, stdio: 'pipe' })
+      .toString().split('\n').map((line) => line.trim()).filter(Boolean);
+  } catch {
+    return null;
+  }
+}
+
+function citedByBlockers(reports) {
+  return Object.values(reports)
+    .flatMap((report) => report.rounds ?? [])
+    .flatMap((round) => round.blockers ?? [])
+    .map((blocker) => `${blocker.where} ${blocker.evidence}`)
+    .join('\n');
+}
+
+const openedBlockers = (report) => (report.rounds ?? []).some((round) => (round.blockers ?? []).length > 0);
+const isCleanShip = (report) => report.verdict === 'SHIP' && (report.blockers ?? []).length === 0;
+
+function deltaIsNarrow(role, delta, cited) {
+  if (delta === null) return false;
+  if (role === 'security') return !securityReviewFor(delta).required;
+  return delta.every((file) => isTestOnly(file) || cited.includes(file) || cited.includes(basename(file)));
+}
+
+/**
+ * After a fix, a role that shipped clean need not return when the delta stays inside what the
+ * blockers named (security: when it touches no sensitive path). `moved` lists the roles behind
+ * `head`; `skippable` says it holds; `confirmed` says a role that opened blockers re-judged `head`,
+ * without which nothing is skippable at approval.
+ */
+export function reviewConfirmation(cwd, reports, head) {
+  const cited = citedByBlockers(reports);
+  const moved = [];
+  let confirmed = false;
+
+  for (const [role, report] of Object.entries(reports)) {
+    if (report.status === 'missing' || !report.reviewedSha) continue;
+    const reviewed = resolveCommit(cwd, report.reviewedSha);
+    if (!reviewed) continue;
+    if (!treeMovedSince(cwd, reviewed, head)) {
+      if (openedBlockers(report)) confirmed = true;
+      continue;
+    }
+    moved.push({
+      role,
+      reviewed,
+      skippable: isCleanShip(report) && deltaIsNarrow(role, changedBetween(cwd, reviewed, head), cited),
+    });
+  }
+
+  return { moved, confirmed };
+}

package/src/lib/review-reports.js

@@ -32,6 +32,7 @@ const SCREEN_CHECKLIST_SECTION_RE = sectionRe('Checklist\\s+de\\s+tela');
 
 /** Hotfix: só o verificador, escrito pelo orquestrador sem dispatch. Chore: só o revisor (review leve). */
 export function requiredReviewRoles({ workType, securityRequired = false } = {}) {
+  // Sem `security` mesmo em caminho sensível: o humano assina todo hotfix.
   if (workType === 'hotfix') return ['verifier'];
   const base = workType === 'chore' ? ['reviewer'] : ['verifier', 'reviewer'];
   return securityRequired ? [...base, 'security'] : base;

package/src/lib/risk-detector.js

@@ -83,7 +83,7 @@ export function reviewPause(signal) {
            + ' auto-avaliação de quem implementou não decide o ship';
     }
     if (r.status === 'partial') {
-      return `\`${file}\` está PARCIAL — retome o mesmo agente por SendMessage; parcial não é veredito`;
+      return `\`${file}\` está PARCIAL — despache o mesmo papel de novo dizendo o que já está no relatório; parcial não é veredito`;
     }
     if (r.status !== 'ok') {
       return `\`${file}\` sem \`**Verdict:** SHIP|FIX\` — o relatório não seguiu o contrato`;
@@ -144,7 +144,7 @@ export function verifierModelFor({ promptModelTouched = false, generatesMedia =
 
 // Teste e artefato de teste não são superfície de ataque: `e2e/login.spec.ts` não pede a persona security.
 const E2E_DIR_RE = /(^|\/)e2e\//;
-const isTestOnly = (f) => isTestPath(f) || E2E_DIR_RE.test(f) || isTestArtifact(f);
+export const isTestOnly = (f) => isTestPath(f) || E2E_DIR_RE.test(f) || isTestArtifact(f);
 
 export function securityReviewFor(changedFiles = []) {
   const risky = changedFiles

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

@@ -83,12 +83,14 @@ function makeNode(partial) {
     runner,
     expectedCount: keepsBaseline(runner) ? partial.expectedCount ?? null : null,
     timeoutMs: partial.timeoutMs ?? null,
+    parallel: partial.parallel ?? false,
     build: partial.build ?? [],
     e2e: partial.e2e ?? false,
     linuxImage: partial.linuxImage ?? null,
     projectCount: partial.projectCount ?? 1,
     // null is "not an eval node", distinct from an empty block (already refused).
     evals: partial.evals ?? null,
+    affected: partial.affected ?? null,
     status: partial.status ?? null,
     reason: partial.reason ?? null,
   };
@@ -127,12 +129,18 @@ function firstProblem(raw, projectPath) {
   if (raw.runner !== undefined && !TEST_RUNNERS.includes(raw.runner)) {
     return `runner must be one of ${TEST_RUNNERS.join(' | ')}`;
   }
+  if (raw.affected !== undefined && (!isPlainObject(raw.affected) || typeof raw.affected.flag !== 'string' || !raw.affected.flag.trim())) {
+    return 'affected must be an object with a non-empty flag';
+  }
   if (raw.expectedCount !== undefined && !isNonNegativeInteger(raw.expectedCount)) {
     return 'expectedCount must be an integer >= 0';
   }
   if (raw.timeoutMs !== undefined && !(Number.isInteger(raw.timeoutMs) && raw.timeoutMs > 0)) {
     return 'timeoutMs must be an integer > 0';
   }
+  if (raw.parallel !== undefined && typeof raw.parallel !== 'boolean') {
+    return 'parallel must be a boolean';
+  }
   if (raw.build !== undefined && (!Array.isArray(raw.build) || raw.build.some((b) => typeof b !== 'string'))) {
     return 'build must be an array of strings';
   }
@@ -208,10 +216,12 @@ export function validateTestNodes(config, projectPath = null) {
       runner: entry.runner ?? inferRunner(entry.command),
       expectedCount: entry.expectedCount ?? null,
       timeoutMs: entry.timeoutMs ?? null,
+      parallel: entry.parallel ?? false,
       build: entry.build ?? [],
       e2e: entry.e2e ?? false,
       linuxImage: entry.linuxImage ?? null,
       evals: entry.evals ?? null,
+      affected: entry.affected ?? null,
       projectCount: 1,
     });
   });

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

@@ -1,5 +1,5 @@
-import { execSync, execFileSync } from 'child_process';
-import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from 'fs';
+import { exec as execCallback, execSync, execFileSync } from 'child_process';
+import { existsSync, readFileSync, readdirSync, realpathSync } from 'fs';
 import { join, resolve, relative, isAbsolute } from 'path';
 import { globSync } from 'glob';
 
@@ -157,6 +157,7 @@ function countCompletedRuns(output) {
 }
 
 const NO_BUILD_FLAG = /(^|\s)--no-build(\s|$)/;
+const DOTNET_COMMAND = /^\s*dotnet\s/;
 
 // `[]` is the safe answer: nothing compiled here, so a `--no-build` in the same command is refused.
 export function extractCsprojTargets(command) {
@@ -177,28 +178,6 @@ export function resolveTestBuildTargets(node) {
   return extractCsprojTargets(node.command);
 }
 
-const DOTNET_BUILDABLE = /"([^"]+\.(?:slnx?|csproj))"|'([^']+\.(?:slnx?|csproj))'|(\S+\.(?:slnx?|csproj))/gi;
-
-/**
- * What `dotnet test` compiles for this node, relative to its `cwd`: declared `build`,
- * else what the command names, else the directory's single solution/project; `[]` = undiscoverable.
- */
-export function discoverDotnetBuildTargets(node, cwd) {
-  if (node?.runner !== 'dotnet') return [];
-  if (Array.isArray(node.build) && node.build.length > 0) return node.build;
-  const command = typeof node.command === 'string' ? node.command : '';
-  const named = [...command.matchAll(DOTNET_BUILDABLE)].map((m) => m[1] ?? m[2] ?? m[3]);
-  if (named.length > 0) return [...new Set(named)];
-
-  const dirArg = command.split(/\s+/).find((token) => token && !token.startsWith('-') && token !== 'dotnet' && token !== 'test'
-    && isDirectory(join(cwd, token)));
-  const dir = dirArg ?? '.';
-  let entries;
-  try { entries = readdirSync(join(cwd, dir)); } catch { return []; }
-  const only = singleDotnetBuildable(entries);
-  return only ? [dir === '.' ? only : join(dir, only).replace(/\\/g, '/')] : [];
-}
-
 function singleDotnetBuildable(files) {
   const solutions = files.filter((f) => /\.slnx?$/i.test(f));
   const projects = files.filter((f) => /\.csproj$/i.test(f));
@@ -237,10 +216,6 @@ export function discoverDotnetSolution(root) {
   return { target: single, candidates: pool };
 }
 
-function isDirectory(path) {
-  try { return statSync(path).isDirectory(); } catch { return false; }
-}
-
 // Derived from build-check.js, the single spelling of "dotnet build". `--no-restore` is
 // dropped: a test project outside the solution may never have been restored.
 export function dotnetBuildCommandFor(target, projectPath) {
@@ -253,7 +228,7 @@ export function dotnetBuildCommandFor(target, projectPath) {
 
 // Runs only with declared `build[]` or `--no-build`: a plain `dotnet test` builds
 // itself, and pre-compiling it would double the clock of the hot path.
-function runTestPrebuild({ node, cwd, exec, timeout, projectPath }) {
+function runTestPrebuild({ node, cwd, exec, timeout, projectPath, builtTargets = new Set() }) {
   if (node.runner !== 'dotnet') return { built: false, failure: null };
 
   const declared = Array.isArray(node.build) ? node.build : [];
@@ -265,10 +240,13 @@ function runTestPrebuild({ node, cwd, exec, timeout, projectPath }) {
   const outputs = [];
 
   for (const target of targets) {
+    const key = `${cwd}\0${target}`;
+    if (builtTargets.has(key)) continue;
     const command = dotnetBuildCommandFor(target, projectPath);
     if (!command) return { built: false, failure: null };
     try {
       exec(command, { cwd, timeout, encoding: 'utf8', stdio: 'pipe' });
+      builtTargets.add(key);
     } catch (err) {
       outputs.push(`[${command}]\n${(err.stdout || '') + (err.stderr || '')}`);
       return {
@@ -511,12 +489,12 @@ export function runTestSuite(projectPath = '.', opts = {}) {
   const cwd = resolve(projectPath, node.cwd || '.');
 
   // Prebuild BEFORE judging `--no-build`: the build is what makes the flag legal.
-  const prebuild = runTestPrebuild({ node, cwd, exec, timeout, projectPath });
+  const prebuild = runTestPrebuild({ node, cwd, exec, timeout, projectPath, builtTargets: opts.builtTargets });
   if (prebuild.failure) return prebuild.failure;
 
   // `--no-build` without a build here would run a stale assembly. The command is never
   // rewritten: a silent fix would make the reported `command` a lie about what ran.
-  if (node.runner === 'dotnet' && NO_BUILD_FLAG.test(cmd) && !prebuild.built) {
+  if (DOTNET_COMMAND.test(cmd) && NO_BUILD_FLAG.test(cmd) && !prebuild.built && !opts.solutionBuilt) {
     return {
       passed: false,
       buildFailed: false,
@@ -530,18 +508,17 @@ export function runTestSuite(projectPath = '.', opts = {}) {
   // Layered OVER process.env: a child that lost PATH fails for reasons unrelated to the suite.
   const env = opts.env ? { ...process.env, ...opts.env } : undefined;
 
-  try {
-    const output = exec(cmd, {
-      cwd,
-      timeout,
-      encoding: 'utf8',
-      stdio: 'pipe',
-      // Node's 1 MiB default kills a large suite mid-run (ENOBUFS), which then reads as a red suite.
-      maxBuffer: TEST_OUTPUT_MAX_BUFFER,
-      ...(env ? { env } : {}),
-    });
-    return { passed: true, output: output ?? '', exitCode: 0, timeoutMs: timeout };
-  } catch (err) {
+  const execOptions = {
+    cwd,
+    timeout,
+    encoding: 'utf8',
+    stdio: 'pipe',
+    // Node's 1 MiB default kills a large suite mid-run (ENOBUFS), which then reads as a red suite.
+    maxBuffer: TEST_OUTPUT_MAX_BUFFER,
+    ...(env ? { env } : {}),
+  };
+  const passed = (output) => ({ passed: true, output: output ?? '', exitCode: 0, timeoutMs: timeout });
+  const failed = (err) => {
     // A spawn failure or a kill leaves both streams empty; its own error is then the only lead.
     const output = (err.stdout || '') + (err.stderr || '')
       || [err.code, err.signal, err.message].filter(Boolean).join(' ');
@@ -571,5 +548,22 @@ export function runTestSuite(projectPath = '.', opts = {}) {
       exitCode: err.status ?? 1,
       timeoutMs: timeout,
     };
+  };
+
+  if (opts.background) return runInBackground(cmd, execOptions).then(passed, failed);
+  try {
+    return passed(exec(cmd, execOptions));
+  } catch (err) {
+    return failed(err);
   }
 }
+
+// `exec` reports the exit code in `err.code`; the shared handler reads `err.status`, as from execSync.
+function runInBackground(cmd, options) {
+  return new Promise((resolvePromise, reject) => {
+    execCallback(cmd, options, (err, stdout, stderr) => {
+      if (!err) return resolvePromise(stdout);
+      return reject(Object.assign(err, { stdout, stderr, status: Number.isInteger(err.code) ? err.code : null }));
+    });
+  });
+}

package/src/lib/telemetry/telemetry-reader.js

@@ -164,8 +164,7 @@ export function aggregateTelemetry(events, opts = {}) {
   };
 }
 
-// Kept apart from aggregateTelemetry: its return shape is spread into `telemetry --json`, so new fields
-// there would leak into that contract. Bytes re-ingested is a proxy for cost, never a token count.
+// Bytes re-ingested is a proxy for cost, never a token count.
 
 function mapToObj(map) {
   const out = {};

package/src/lib/telemetry/verify-event.js

@@ -11,6 +11,11 @@ export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerp
     if (!node) continue;
     nodes[name] = { status: node.status, durationMs: Number.isFinite(node.durationMs) ? node.durationMs : null };
   }
+  if (nodes.tests && Array.isArray(result.nodes.tests.runs)) {
+    nodes.tests.runs = result.nodes.tests.runs.map(({ id, status, durationMs }) => ({
+      id, status: status ?? null, durationMs: Number.isFinite(durationMs) ? durationMs : null,
+    }));
+  }
   if (nodes.validators) {
     nodes.validators.ran = [...(result.nodes.validators.ran || [])];
     nodes.validators.skipped = (result.nodes.validators.skipped || [])
@@ -26,6 +31,8 @@ export function buildVerifyEvent(result, { sha, tree, persisted, reason, fingerp
     persisted,
     reason: persisted ? null : (reason ?? null),
     source,
+    reused: result.reused ?? [],
+    flaky: result.flaky ?? [],
     nodes,
   };
 }

package/src/lib/validators/verify-cache.js

@@ -0,0 +1,63 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+
+// Ignored files (`.env`, a database) are outside the fingerprint: `verify --fresh` is the way out.
+function cachePath(gitCommonDir, featureName) {
+  return join(gitCommonDir, 'morph-spec', `verify-nodes-${featureName}.json`);
+}
+
+export function readVerifyCache(gitCommonDir, featureName) {
+  try {
+    return JSON.parse(readFileSync(cachePath(gitCommonDir, featureName), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/** Fail-open: a cache that cannot be written costs a rerun, never a verdict. */
+export function writeVerifyCache(gitCommonDir, featureName, entry) {
+  try {
+    const path = cachePath(gitCommonDir, featureName);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(entry));
+  } catch { /* see above */ }
+}
+
+const withoutOutput = ({ output: _output, ...rest }) => rest;
+
+export function cacheEntryFrom(fingerprint, nodes) {
+  return {
+    fingerprint,
+    build: withoutOutput(nodes.build),
+    tests: (nodes.tests.runs || []).map(withoutOutput),
+    e2e: withoutOutput(nodes.e2e),
+  };
+}
+
+const NOTHING = Object.freeze({
+  build: null, tests: new Map(), e2e: null, redFirst: new Set(), retried: new Set(),
+});
+
+/**
+ * Same tree: green nodes stand, red ones run again (`retried`, to name a flake when they turn green).
+ * Tree moved: nothing stands, and last round's red suites run first (`redFirst`).
+ */
+export function planReuse(previous, fingerprint) {
+  if (!previous || !fingerprint) return NOTHING;
+  const runs = previous.tests || [];
+  const red = new Set(runs.filter((run) => run.status === 'fail').map((run) => run.id));
+
+  if (previous.fingerprint !== fingerprint) return { ...NOTHING, redFirst: red };
+
+  return {
+    build: previous.build?.status === 'pass' ? previous.build : null,
+    tests: new Map(runs.filter((run) => run.status === 'pass').map((run) => [run.id, run])),
+    e2e: previous.e2e?.status === 'pass' ? previous.e2e : null,
+    redFirst: red,
+    retried: previous.e2e?.status === 'fail' ? new Set([...red, 'e2e']) : red,
+  };
+}
+
+export function reusedEntry(entry) {
+  return { ...entry, output: '', durationMs: 0, reused: true };
+}