@codedology/code-forge 0.15.4 → 0.16.0

package/src/gates/dependents.mjs

@@ -0,0 +1,200 @@
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { Script } from 'node:vm';
+
+/** @typedef {{value: string, string?: boolean, start: number, end: number}} Token */
+
+/** Tokenize without treating comments, quoted text or regular expressions as imports.
+ * @param {string} source @returns {Token[]}
+ */
+function tokens(source) {
+  const out = /** @type {Token[]} */ ([]);
+  const templates = /** @type {{expression: boolean, depth: number}[]} */ ([]);
+  let i = 0;
+  while (i < source.length) {
+    const start = i, char = source[i];
+    const template = templates.at(-1);
+    if (template && !template.expression) {
+      if (char === '\\') { i += 2; continue; }
+      if (char === '`') { templates.pop(); i++; continue; }
+      if (source.startsWith('${', i)) {
+        template.expression = true;
+        i += 2;
+        out.push({ value: '{', start, end: i });
+      } else i++;
+      continue;
+    }
+    if (char === '`') { templates.push({ expression: false, depth: 0 }); i++; continue; }
+    if (template && char === '{') template.depth++;
+    if (template && char === '}') {
+      if (template.depth === 0) template.expression = false;
+      else template.depth--;
+    }
+    if (/\s/.test(char)) { i++; continue; }
+    if (source.startsWith('//', i) || (i === 0 && source.startsWith('#!'))) {
+      i = source.indexOf('\n', i);
+      if (i < 0) break;
+      continue;
+    }
+    if (source.startsWith('/*', i)) {
+      i = source.indexOf('*/', i + 2);
+      if (i < 0) throw new SyntaxError('unclosed comment');
+      i += 2;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      i++;
+      while (i < source.length && source[i] !== char) {
+        if (source[i] === '\\') i++;
+        i++;
+      }
+      if (i === source.length) throw new SyntaxError('unclosed string');
+      out.push({ value: source.slice(start + 1, i), string: true, start, end: ++i });
+      continue;
+    }
+    // A slash after an expression-start token is a regexp, not a division operator.
+    if (char === '/' && (!out.length || /^(?:[=(:,;!&|?{}\[]|return|throw|case|=>)$/.test(out.at(-1).value))) {
+      let bracket = false;
+      i++;
+      while (i < source.length) {
+        if (source[i] === '\\') { i += 2; continue; }
+        if (source[i] === '[') bracket = true;
+        if (source[i] === ']') bracket = false;
+        if (source[i++] === '/' && !bracket) break;
+      }
+      while (/[a-z]/i.test(source[i] ?? '') && i < source.length) i++;
+      out.push({ value: 'regexp', start, end: i });
+      continue;
+    }
+    const word = /^[\w$]+/.exec(source.slice(i));
+    i += word ? word[0].length : 1;
+    out.push({ value: source.slice(start, i), start, end: i });
+  }
+  if (templates.length) throw new SyntaxError('unclosed template');
+  return out;
+}
+
+/** Extract module edges and syntax-check a script equivalent without executing it.
+ * Module declarations are removed only for the syntax check; dynamic imports stay intact.
+ * @param {string} source @returns {string[]}
+ */
+function specifiers(source) {
+  const list = tokens(source);
+  const specs = [];
+  const edits = /** @type {{start: number, end: number, text: string}[]} */ ([]);
+  let depth = 0;
+  for (let i = 0; i < list.length; i++) {
+    const token = list[i], next = list[i + 1];
+    if (token.string) continue;
+    if (['{', '[', '('].includes(token.value)) depth++;
+    if (['}', ']', ')'].includes(token.value)) depth--;
+    if (!next || list[i - 1]?.value === '.') continue;
+    if (token.value === 'import' && next.value === '(') {
+      if (list[i + 2]?.string && [')', ','].includes(list[i + 3]?.value)) specs.push(list[i + 2].value);
+      continue;
+    }
+    if (token.value === 'import' && next.value === '.') {
+      edits.push({ start: token.start, end: list[i + 2].end, text: '({})' });
+      i += 2;
+      continue;
+    }
+    if (depth !== 0 || (token.value !== 'import' && token.value !== 'export')) continue;
+    if (token.value === 'export' && !['{', '*'].includes(next.value)) {
+      const isDefault = next.value === 'default';
+      edits.push({ start: token.start, end: isDefault ? next.end : token.end, text: isDefault ? 'const __default_export__ =' : '' });
+      if (isDefault) i++;
+      continue;
+    }
+    let end = i + 1;
+    if (!next.string) {
+      if (next.value === '{') {
+        while (end < list.length && list[end].value !== '}') end++;
+        if (list[end + 1]?.value === 'from') end += 2;
+      } else {
+        while (end < list.length && !(list[end].value === 'from' && list[end + 1]?.string)) end++;
+        end++;
+      }
+    }
+    if (!list[end]) throw new SyntaxError('incomplete module declaration');
+    if (list[end].string) specs.push(list[end].value);
+    // JSON import attributes are part of the declaration being removed.
+    if (['with', 'assert'].includes(list[end + 1]?.value) && list[end + 2]?.value === '{') {
+      end += 3;
+      while (end < list.length && list[end].value !== '}') end++;
+      if (!list[end]) throw new SyntaxError('incomplete import attributes');
+    }
+    edits.push({ start: token.start, end: list[end].end, text: '' });
+    i = end;
+  }
+  // Keep source positions stable when stripping a hashbang.
+  let script = source.replace(/^#![^\n]*/, (line) => ' '.repeat(line.length));
+  for (const edit of edits.reverse()) script = script.slice(0, edit.start) + edit.text + script.slice(edit.end);
+  new Script(`(async function () { "use strict";\n${script}\n})`);
+  return specs.filter((specifier) => specifier.startsWith('./') || specifier.startsWith('../'));
+}
+
+/** @param {string} file */
+const testPath = (file) => /(?:^|\/)(?:test|tests|__tests__|spec)\//.test(file) || /\.(?:test|spec)\.[^/]+$/.test(file);
+
+/** Build a reverse transitive graph, shared by the async selector and the synchronous scope.
+ * Every module is read and parsed at most once. Missing/deleted targets remain graph edges.
+ * @param {{cwd: string, testFiles: string[]}} opts
+ * @returns {Promise<Record<string, string[]>>}
+ */
+export async function testDependents({ cwd, testFiles }) {
+  const root = path.resolve(cwd);
+  const reads = new Map();
+  const stats = new Map();
+  const graph = /** @type {Record<string, string[]>} */ (Object.create(null));
+  /** @param {string} file @returns {Promise<boolean>} */
+  function exists(file) {
+    if (!stats.has(file)) stats.set(file, stat(path.join(root, file)).then((s) => s.isFile()).catch(() => false));
+    return stats.get(file);
+  }
+  /** @param {string} file @returns {Promise<string[] | null>} */
+  function imports(file) {
+    if (!reads.has(file)) reads.set(file, (async () => {
+      try {
+        const specs = specifiers(await readFile(path.join(root, file), 'utf8'));
+        const edges = [];
+        for (const spec of specs) {
+          const relative = path.relative(root, path.resolve(root, path.dirname(file), spec)).split(path.sep).join('/');
+          if (relative === '..' || relative.startsWith('../') || path.isAbsolute(relative)) continue;
+          const choices = path.extname(relative) ? [relative] : [relative + '.mjs', relative + '.js', relative + '/index.mjs'];
+          let resolved = choices[0];
+          for (const choice of choices) if (await exists(choice)) { resolved = choice; break; }
+          edges.push(resolved);
+        }
+        return edges;
+      } catch { return null; }
+    })());
+    return reads.get(file);
+  }
+  for (const test of [...new Set(testFiles)].sort()) {
+    if (!(await imports(test))) continue;
+    const seen = new Set([test]);
+    const pending = [test];
+    while (pending.length) {
+      for (const dependency of (await imports(pending.pop())) ?? []) {
+        if (seen.has(dependency)) continue;
+        seen.add(dependency);
+        (graph[dependency] ??= []).push(test);
+        pending.push(dependency);
+      }
+    }
+    if (/^test\/(?:config|doctor)\//.test(test)) (graph['schema/code-forge.schema.json'] ??= []).push(test);
+  }
+  for (const file of Object.keys(graph)) graph[file] = [...new Set(graph[file])].sort();
+  return graph;
+}
+
+/** Tests importing any changed non-test source, directly or through repository modules.
+ * @param {{cwd: string, changed: string[], testFiles: string[]}} opts
+ * @returns {Promise<string[]>}
+ */
+export async function dependentTests({ cwd, changed, testFiles }) {
+  const sources = changed.filter((file) => !testPath(file) && !testFiles.includes(file));
+  if (!sources.length) return [];
+  const graph = await testDependents({ cwd, testFiles });
+  return [...new Set(sources.flatMap((file) => graph[file] ?? []))].sort();
+}

package/src/gates/expand.mjs

@@ -28,6 +28,7 @@ import path from 'node:path';
 import { isExactEntry, ownsFile } from '../state/registry.mjs';
 import { pairsFor } from '../review/paired.mjs';
 import { computeFileSet } from './scope.mjs';
+import { dependentTests, testDependents } from './dependents.mjs';
 import { exec } from '../util/exec.mjs';
 import { TEST_FILES_TOKEN, CHANGED_FILES_TOKEN } from '../util/gate-token.mjs';
 
@@ -73,14 +74,38 @@ export function isChangedTest(file) {
 }
 
 /**
- * Existing block tests added or changed since its base, independent of the last green scope
- * and its threshold. Deleted tests and unchanged source-paired tests are not repeat candidates.
+ * Keep test files supported by the executable's runner family. Wrappers in the JS family
+ * still accept JS tests; unknown executables retain the caller's complete file list.
+ * @param {ReadonlyArray<string>} argv @param {ReadonlyArray<string>} files
+ * @returns {string[]}
+ */
+export function testsForRunner(argv, files) {
+  let extensions;
+  switch (path.basename(argv[0] ?? '')) {
+    case 'node': case 'bun': case 'deno': case 'npm': case 'npx': case 'pnpm':
+    case 'yarn': case 'bunx': case 'vitest': case 'jest': case 'mocha':
+      extensions = /\.(?:js|mjs|cjs|jsx|ts|mts|cts|tsx)$/;
+      break;
+    case 'go': extensions = /\.go$/; break;
+    case 'php': case 'pest': case 'phpunit': extensions = /\.php$/; break;
+    case 'pytest': case 'python': case 'python3': extensions = /\.py$/; break;
+    case 'cargo': extensions = /\.rs$/; break;
+    case 'swift': case 'xcodebuild': extensions = /\.swift$/; break;
+    default: return [...files];
+  }
+  return files.filter((file) => extensions.test(file));
+}
+
+/**
+ * Existing owned changed tests plus every test importing an owned changed source since base.
+ * Deleted tests are omitted; ownership limits changed inputs, not their test callers.
  * @param {{cwd: string, base: string, owned: string[], kinds?: Record<string, string>}} opts
  * @returns {Promise<string[]>}
  */
 export async function changedTestFiles({ cwd, base, owned, kinds }) {
   const { all } = await computeFileSet({ cwd, base });
-  const files = all.filter((file) => ownsFile(owned, file, kinds) && isChangedTest(file));
+  const changed = all.filter((file) => ownsFile(owned, file, kinds));
+  const files = changed.filter(isChangedTest);
   const existing = await Promise.all(files.map(async (file) => {
     const stat = await lstat(path.join(cwd, file)).catch((error) => {
       if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return null;
@@ -88,7 +113,9 @@ export async function changedTestFiles({ cwd, base, owned, kinds }) {
     });
     return stat?.isFile() === true;
   }));
-  return files.filter((_, i) => existing[i]);
+  const testFiles = (await repositoryFiles(cwd) ?? []).filter(isChangedTest);
+  const dependents = await dependentTests({ cwd, changed: changed.filter((file) => !isChangedTest(file)), testFiles });
+  return [...new Set([...files.filter((_, i) => existing[i]), ...dependents])].sort();
 }
 
 /**
@@ -98,8 +125,8 @@ export async function changedTestFiles({ cwd, base, owned, kinds }) {
 const isConcreteFile = (p) => typeof p === 'string' && p.length > 0 && isExactEntry(p) && !p.endsWith('/');
 
 /**
- * @typedef {{scope: 'related', files: string[]} | {scope: 'full', reason: 'threshold' | 'no_tests'}} TestScope
- * @typedef {{scope: 'changed', files: string[], changedFiles: string[], reason?: 'no_baseline'|'unpaired'|'threshold'|'no_changes'}} ChangedScope
+ * @typedef {{scope: 'related', files: string[]} | {scope: 'full', files?: string[], reason: 'threshold' | 'no_tests' | 'runner-filter'}} TestScope
+ * @typedef {{scope: 'changed', files: string[], changedFiles: string[], dependents?: string[], reason?: 'no_baseline'|'unpaired'|'threshold'|'no_changes'}} ChangedScope
  */
 
 /** A gate run with no block: no test file is known. */
@@ -151,21 +178,28 @@ function safeFile(file) {
   return file.length > 0 && !file.startsWith('-') && !path.isAbsolute(file) && !/[\\\x00-\x1f]/.test(file) && !file.split('/').some((s) => s === '' || s === '.' || s === '..');
 }
 
+/** Tracked and new, non-ignored repo files in an isolated git environment.
+ * @param {string} cwd @returns {Promise<string[] | null>}
+ */
+async function repositoryFiles(cwd) {
+  const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_')));
+  env.GIT_CONFIG_NOSYSTEM = '1';
+  env.GIT_CONFIG_GLOBAL = os.devNull;
+  const listed = await exec(['git', 'ls-files', '-z', '--cached', '--others', '--exclude-standard'], { cwd, env, timeoutMs: 30000 });
+  return listed.result === 'ok' ? [...new Set(listed.stdout.split('\0').filter(Boolean))].sort() : null;
+}
+
 /**
  * Bounded content baseline. Missing listed files are omitted from hashes and candidates; an
  * owned entry with no current file has no hash. More than 200 owned files, a symlink, a
  * non-regular owned file, a path outside the root or another read error means no record;
  * callers retain the old scope. Git sees only argv and an isolated git environment.
  * @param {string} cwd @param {string[]} owned @param {Record<string, string>} [kinds]
- * @returns {Promise<{files: Record<string, string>, candidates: string[]} | null>}
+ * @returns {Promise<{files: Record<string, string>, candidates: string[], dependents?: Record<string, string[]>} | null>}
  */
 export async function fileBaseline(cwd, owned, kinds) {
-  const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('GIT_')));
-  env.GIT_CONFIG_NOSYSTEM = '1';
-  env.GIT_CONFIG_GLOBAL = os.devNull;
-  const listed = await exec(['git', 'ls-files', '-z', '--cached', '--others', '--exclude-standard'], { cwd, env, timeoutMs: 30000 });
-  if (listed.result !== 'ok') return null;
-  const listedFiles = [...new Set(listed.stdout.split('\0').filter(Boolean))].sort();
+  const listedFiles = await repositoryFiles(cwd);
+  if (!listedFiles) return null;
   const candidates = [];
   const files = /** @type {Record<string, string>} */ (Object.create(null));
   try {
@@ -192,11 +226,13 @@ export async function fileBaseline(cwd, owned, kinds) {
       files[file] = createHash('sha256').update(await readFile(absolute)).digest('hex');
     }
   } catch { return null; }
-  return { files, candidates };
+  const dependents = await testDependents({ cwd, testFiles: candidates.filter(isChangedTest) });
+  // The graph is transient: keep the baseline's public/serialized hash-and-candidate shape.
+  return Object.defineProperty({ files, candidates }, 'dependents', { value: dependents });
 }
 
 /**
- * Compare the last green record. A source without a stem pair cannot narrow the test gate.
+ * Compare the last green record, adding importers and retaining stem pairs as a fallback.
  * @param {{baseline: unknown, current: Awaited<ReturnType<typeof fileBaseline>>, fallback: TestScope, threshold?: number, owned?: string[], kinds?: Record<string, string>}} opts
  * @returns {ChangedScope}
  */
@@ -204,29 +240,46 @@ export function changedScope({ baseline, current, fallback, threshold = DEFAULT_
   const old = /** @type {Record<string, string> | null} */ (baseline);
   const candidates = new Set(current?.candidates);
   const fallbackFiles = fallback.scope === 'related' ? fallback.files.filter((file) => !current || candidates.has(file)) : [];
+  /** Merge callers while preserving the legacy fallback for sources with no known callers.
+   * @param {string[]} files @param {string[]} sources @param {string[]} changedFiles
+   * @param {ChangedScope['reason']} [reason] @returns {ChangedScope}
+   */
+  function withDependents(files, sources, changedFiles, reason) {
+    const dependents = [...new Set(sources.filter((file) => !isChangedTest(file)).flatMap((file) => current?.dependents?.[file] ?? []))]
+      .filter((file) => !files.includes(file)).sort();
+    // An empty full fallback means every test; adding callers would narrow that run.
+    const fullFallback = fallback.scope === 'full' && (reason === 'unpaired' || reason === 'no_baseline');
+    const union = fullFallback ? [] : [...new Set([...files, ...dependents])].sort();
+    const overThreshold = union.length > threshold || reason === 'threshold';
+    return { scope: 'changed', files: overThreshold ? [] : union, changedFiles,
+      ...(current?.dependents || current === null ? { dependents } : {}),
+      ...(overThreshold ? { reason: /** @type {const} */ ('threshold') } : reason ? { reason } : {}),
+    };
+  }
   if (!current || !old || typeof old !== 'object' || Array.isArray(old) || Object.keys(old).length > 200 ||
       Object.entries(old).some(([file, hash]) => !safeFile(file) || (owned && !ownsFile(owned, file, kinds)) || typeof hash !== 'string' || !/^[a-f0-9]{64}$/.test(hash))) {
-    return { scope: 'changed', files: fallbackFiles, changedFiles: [], reason: 'no_baseline' };
+    return withDependents(fallbackFiles, Object.keys(current?.files ?? {}), [], fallback.scope === 'full' && fallback.reason === 'threshold' ? 'threshold' : 'no_baseline');
   }
   const changes = [...new Set([...Object.keys(old), ...Object.keys(current.files)])].filter((file) => old[file] !== current.files[file]).sort();
-  if (changes.length > threshold) return { scope: 'changed', files: [], changedFiles: [], reason: 'threshold' };
+  if (changes.length > threshold) return withDependents([], changes, [], 'threshold');
   const changedFiles = changes.filter((file) => candidates.has(file));
   const tests = new Set(changedFiles.filter(isChangedTest));
   for (const file of changes.filter((f) => !isChangedTest(f))) {
+    if (current.dependents?.[file]?.length) continue;
     const pairs = pairsFor(file, current.candidates).filter(isChangedTest);
-    if (pairs.length === 0) return { scope: 'changed', files: fallbackFiles, changedFiles, reason: 'unpaired' };
+    if (pairs.length === 0) return withDependents(fallbackFiles, changes, changedFiles, 'unpaired');
     for (const paired of pairs) tests.add(paired);
   }
-  if (tests.size === 0) return { scope: 'changed', files: fallbackFiles, changedFiles, reason: 'no_changes' };
-  return { scope: 'changed', files: [...tests].sort(), changedFiles };
+  if (tests.size === 0 && !changes.some((file) => current.dependents?.[file]?.length)) return withDependents(fallbackFiles, changes, changedFiles, 'no_changes');
+  return withDependents([...tests].sort(), changes, changedFiles);
 }
 
 /**
  * One gate argv with every item that is exactly {@link TEST_FILES_TOKEN} replaced by the related
- * test files, or dropped for a full run. Always a new array; `scoped` is false (and the items
- * unchanged) when the gate has no such item.
+ * test files, or dropped for a full run. Always a new array; `scoped` records whether a scope
+ * placeholder was handled, including full runs. `full` signals a runner-filter fallback.
  * @param {ReadonlyArray<string>} argv @param {TestScope | ChangedScope} scope
- * @returns {{argv: string[], scoped: boolean}}
+ * @returns {{argv: string[], scoped: boolean, full?: true, reason?: 'runner-filter'}}
  * @throws {TypeError} a test path that starts with `-` (it would be read as an option; `block
  *   open --tests` refuses one too).
  */
@@ -237,17 +290,21 @@ export function expandArgv(argv, scope) {
   if (changed.some((file) => !safeFile(file))) throw new TypeError('expandArgv: unsafe changed path');
   const dashed = files.find((f) => f.startsWith('-'));
   if (dashed !== undefined) throw new TypeError(`expandArgv: test path ${JSON.stringify(dashed)} starts with "-"`);
-  return { argv: argv.flatMap((item) => item === TEST_FILES_TOKEN ? files : item === CHANGED_FILES_TOKEN ? changed : [item]), scoped: true };
+  const runnerFiles = testsForRunner(argv, files);
+  const full = argv.includes(TEST_FILES_TOKEN) && files.length > 0 && runnerFiles.length === 0;
+  return { argv: argv.flatMap((item) => item === TEST_FILES_TOKEN ? runnerFiles : item === CHANGED_FILES_TOKEN ? changed : [item]), scoped: true,
+    ...(full ? { full: /** @type {const} */ (true), reason: /** @type {const} */ ('runner-filter') } : {}),
+  };
 }
 
 /**
  * The fields a scoped gate's result and ledger row carry: `scope`, plus `test_count` when related
  * or `reason` when full.
  * @param {TestScope | ChangedScope} scope
- * @returns {{scope: 'changed', test_count: number, reason?: 'no_baseline'|'unpaired'|'threshold'|'no_changes'} | {scope: 'related', test_count: number} | {scope: 'full', reason: 'threshold'|'no_tests'}}
+ * @returns {{scope: 'changed', test_count: number, dependents?: string[], reason?: 'no_baseline'|'unpaired'|'threshold'|'no_changes'} | {scope: 'related', test_count: number} | {scope: 'full', reason: 'threshold'|'no_tests'|'runner-filter'}}
  */
 export function scopeFields(scope) {
-  if (scope.scope === 'changed') return { scope: 'changed', test_count: scope.files.length, ...(scope.reason ? { reason: scope.reason } : {}) };
+  if (scope.scope === 'changed') return { scope: 'changed', test_count: scope.files.length, ...(scope.dependents ? { dependents: scope.dependents } : {}), ...(scope.reason ? { reason: scope.reason } : {}) };
   return scope.scope === 'related' ? { scope: 'related', test_count: scope.files.length } : { scope: 'full', reason: scope.reason };
 }
 

package/src/gates/run.mjs

@@ -14,7 +14,7 @@ import { customGateMessages } from '../config/validate.mjs';
 import { exec } from '../util/exec.mjs';
 import { registerSecret } from '../util/redact.mjs';
 import { CHANGED_FILES_TOKEN } from '../util/gate-token.mjs';
-import { NO_BLOCK_SCOPE, TEST_FILES_TOKEN, changedTestFiles, envOf, expandArgv, maskableEnvValues, scopeFields } from './expand.mjs';
+import { NO_BLOCK_SCOPE, TEST_FILES_TOKEN, changedTestFiles, envOf, expandArgv, maskableEnvValues, scopeFields, testsForRunner } from './expand.mjs';
 
 /** @typedef {import('./detect.mjs').Gate} Gate */
 /** @typedef {import('./detect.mjs').GateCommand} GateCommand */
@@ -42,12 +42,13 @@ import { NO_BLOCK_SCOPE, TEST_FILES_TOKEN, changedTestFiles, envOf, expandArgv,
  * @property {boolean} ok - true when skipped, or when the command exited with code 0 (and, for a
  *   `failOnStdout` gate, its stdout was empty).
  * @property {number | null} code
+ * @property {true} [timed_out] - the command exceeded its gate deadline, not a test failure.
  * @property {string} stdout
  * @property {string} stderr
  * @property {string} [message] - termination diagnostic with the last lines of both streams.
  * @property {'related'|'full'|'changed'} [scope] - only on a gate with a scope token.
  * @property {number} [test_count] - B60: with `scope: related`, how many test files it ran.
- * @property {'threshold'|'no_tests'|'no_baseline'|'unpaired'|'no_changes'|'flaky-test'|'timeout'|'prompt'|'spawn-error'|'terminated'|NodeJS.Signals|`not in gates.kinds.${string}`} [reason] - fallback, exclusion or gate failure.
+ * @property {'threshold'|'no_tests'|'runner-filter'|'no_baseline'|'unpaired'|'no_changes'|'flaky-test'|'timeout'|'prompt'|'spawn-error'|'terminated'|NodeJS.Signals|`not in gates.kinds.${string}`} [reason] - fallback, exclusion or gate failure.
  * @property {Repeats} [repeats]
  * @property {string[]} [env_keys] - B60: only on a gate given with a non-empty `env`: the variable
  *   NAMES, sorted (the values are never in a result).
@@ -239,11 +240,57 @@ function normalizeCommand(command) {
   return { argv: command.argv, failOnStdout: command.failOnStdout === true, env: envOf(command) }; // `env: {}` is no env
 }
 
+/** Node reports cancelled tests as failures after a timeout. Keep their diagnostics, but
+ * remove the failure markers consumed by TAP lists and shown by the spec reporter.
+ * @param {string} output @returns {string}
+ */
+function unfinishedOutput(output) {
+  const lines = output.split('\n');
+  /** @type {Map<number, {indent: number, tap: boolean, diagnostic: string}>} */
+  const failures = new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const tap = /^([ \t]*)not ok\s+\d+\s+- /.exec(lines[i]);
+    const spec = /^([ \t]*)✖ /.exec(lines[i]);
+    if (!tap && !spec) continue;
+    let diagnostic = lines[i];
+    const indent = (tap ?? spec)[1].length;
+    for (let j = i + 1; j < lines.length; j++) {
+      if (lines[j].trim() && lines[j].search(/\S/) <= indent) break;
+      if (/^\s*(?:not ok\s+\d+\s+- |✖ |# Subtest: |▶ )/.test(lines[j])) break;
+      diagnostic += `\n${lines[j]}`;
+      if (tap && lines[j].trim() === '...') break;
+    }
+    failures.set(i, { indent, tap: !!tap, diagnostic });
+  }
+  /** @type {Set<number>} */
+  const unfinished = new Set();
+  // Reporters normally close a suite after its children; also accept a parent-first list.
+  // Visit deeper entries first so unfinished status propagates through every ancestor.
+  for (const [i, { indent, diagnostic }] of [...failures].sort((a, b) => b[1].indent - a[1].indent)) {
+    const children = [];
+    for (const direction of [-1, 1]) {
+      for (let j = i + direction; j >= 0 && j < lines.length; j += direction) {
+        if (lines[j].trim() && lines[j].search(/\S/) <= indent) break;
+        if (failures.has(j)) children.push(j);
+      }
+    }
+    const pending = diagnostic.includes('Promise resolution is still pending but the event loop has already resolved');
+    const parent = /subtestsFailed|\b\d+ subtests? failed\b/.test(diagnostic) || diagnostic.trimEnd() === lines[i].trimEnd();
+    const allUnfinished = children.length > 0 && children.every((j) => unfinished.has(j));
+    if (children.length ? !allUnfinished || !(pending || parent) : !pending) continue;
+    unfinished.add(i);
+  }
+  for (const i of unfinished) {
+    lines[i] = failures.get(i).tap ? lines[i].replace('not ok', '# unfinished') : lines[i].replace('✖', 'ℹ unfinished:');
+  }
+  return lines.join('\n');
+}
+
 /** Interpret timeouts and unanswered prompts for every gate, including repeats.
  * @param {import('../util/exec.mjs').ExecResult} res
  * @param {number} timeoutMs
  * @param {boolean} [failOnStdout]
- * @returns {Pick<GateResult, 'ok'|'code'|'stdout'|'stderr'|'reason'|'message'>}
+ * @returns {Pick<GateResult, 'ok'|'code'|'stdout'|'stderr'|'reason'|'message'|'timed_out'>}
  */
 function gateOutcome(res, timeoutMs, failOnStdout = false) {
   const prompt = res.result === 'ok' && [res.stdout, res.stderr].some((stream) =>
@@ -255,18 +302,24 @@ function gateOutcome(res, timeoutMs, failOnStdout = false) {
     ? `gate timeout after ${timeoutMs / 1000} seconds; raise gates.timeout_s (or --timeout-ms)`
     : res.code === null ? `gate terminated: ${res.signal ?? res.error ?? 'no exit status (no signal reported)'}`
     : prompt ? 'gate ended on an interactive prompt; install the tool or make the command non-interactive' : '';
-  const tails = ['stdout', 'stderr'].flatMap((stream) => {
-    const tail = res[stream].trimEnd().split(/\r?\n/).slice(-10).join('\n');
+  const stdout = res.timedOut ? unfinishedOutput(res.stdout) : res.stdout;
+  const stderr = res.timedOut ? unfinishedOutput(res.stderr) : res.stderr;
+  const tails = [stdout, stderr].flatMap((output, index) => {
+    const stream = index === 0 ? 'stdout' : 'stderr';
+    const tail = output.trimEnd().split(/\r?\n/).slice(-10).join('\n');
     return tail ? [`${stream} tail:\n${tail}`] : [];
   });
-  const message = [diagnostic, ...tails].join('\n');
+  const message = [res.timedOut
+    ? `TIMEOUT after ${timeoutMs / 1000} s (not a test failure); rerun with --timeout-ms ${timeoutMs * 2} or raise gates.timeout_s`
+    : diagnostic, ...tails].join('\n');
   return {
     ok: res.result === 'ok' && !reason && (!failOnStdout || res.stdout.trim().length === 0),
     code: res.code,
-    stdout: res.stdout,
+    stdout,
     stderr: diagnostic
-      ? `${res.stderr}${res.stderr && !res.stderr.endsWith('\n') ? '\n' : ''}${diagnostic}\n`
-      : res.stderr,
+      ? `${stderr}${stderr && !stderr.endsWith('\n') ? '\n' : ''}${diagnostic}\n`
+      : stderr,
+    ...(res.timedOut ? { timed_out: /** @type {const} */ (true) } : {}),
     ...(reason ? { reason } : {}),
     ...(diagnostic ? { message } : {}),
   };
@@ -312,7 +365,10 @@ export async function runGates(gates, opts) {
     if (command === null || excluded(gate)) { planned.push({ gate, command: null }); continue; }
     const normalized = normalizeCommand(command);
     if (normalized.argv[0] === CHANGED_FILES_TOKEN) throw new TypeError(`gates.${gate}: '{changed_files}' cannot be the command (argv[0])`);
-    let { argv, scoped } = expandArgv(normalized.argv, scope);
+    let { argv, scoped, full, reason } = expandArgv(normalized.argv, scope);
+    const commandScope = full ? { scope: /** @type {const} */ ('full'), files: [], reason }
+      : scope.scope !== 'full' && normalized.argv.includes(TEST_FILES_TOKEN)
+        ? { ...scope, files: testsForRunner(normalized.argv, scope.files) } : scope;
     if (argv.length === 0 && normalized.argv.length > 0) throw new TypeError(`gates.${gate}: the argv is empty once ${normalized.argv.map((item) => `'${item}'`).join(' and ')} is dropped for the full suite — put the test command before it`);
     const formatter = gate === 'format' && !Array.isArray(command) ? command.formatter : undefined;
     let batches;
@@ -322,7 +378,7 @@ export async function runGates(gates, opts) {
       batches = formatBatches(argv, files, opts.formatArgvBudgetBytes ?? FORMAT_ARGV_BUDGET_BYTES);
       argv = argv.concat(files);
     }
-    planned.push({ gate, command: { argv, batches, originalArgv: normalized.argv, scoped, failOnStdout: normalized.failOnStdout, env: normalized.env } });
+    planned.push({ gate, command: { argv, batches, originalArgv: normalized.argv, scoped, full, scope: commandScope, failOnStdout: normalized.failOnStdout, env: normalized.env } });
   }
   /** @type {GateResult[]} */
   const results = [];
@@ -349,7 +405,7 @@ export async function runGates(gates, opts) {
     }
     // Retain the first failure's status and diagnostic even if later batches pass.
     const outcome = {
-      ...(outcomes.find((entry) => !entry.ok) ?? outcomes[0]),
+      ...(outcomes.find((entry) => entry.timed_out) ?? outcomes.find((entry) => !entry.ok) ?? outcomes[0]),
       stdout: outcomes.map((entry) => entry.stdout).join(''),
       stderr: outcomes.map((entry) => entry.stderr).join(''),
     };
@@ -358,7 +414,7 @@ export async function runGates(gates, opts) {
       duration_ms: 0,
       argv,
       skipped: false,
-      ...(scoped ? scopeFields(scope) : {}),
+      ...(scoped ? scopeFields(command.scope) : {}),
       ...outcome,
       ...(env ? { env_keys: Object.keys(env).sort() } : {}),
     });
@@ -366,8 +422,14 @@ export async function runGates(gates, opts) {
     if (gate === 'test' && outcome.ok && repeat) {
       if (!command.originalArgv.includes(TEST_FILES_TOKEN)) {
         repeat.onSkip?.('repeat_new_tests: skipped (gates.test has no {test_files})');
+      } else if (command.full) {
+        repeat.onSkip?.('repeat_new_tests: skipped (no changed tests for this runner)');
       } else {
-        const files = (await changedTestFiles({ cwd, ...repeat })).filter((file) => !gates.lightTestFiles || gates.lightTestFiles.includes(file));
+        const changedFiles = (await changedTestFiles({ cwd, ...repeat })).filter((file) => !gates.lightTestFiles || gates.lightTestFiles.includes(file));
+        const files = testsForRunner(command.originalArgv, changedFiles);
+        if (changedFiles.length > 0 && files.length === 0) {
+          repeat.onSkip?.('repeat_new_tests: skipped (no changed tests for this runner)');
+        }
         if (files.length > 0) {
           result.repeats = { n: repeat.n, files, failed: false };
           const repeatArgv = expandArgv(command.originalArgv, { scope: 'related', files }).argv;