@opengsd/gsd-core 1.10.0 → 1.12.0

package/scripts/lib/drift-scan.cjs

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Shared anti-divergence scanner machinery (epic #3180, ADR-3180 Decision 4).
+ *
+ * Extracted from `scripts/lint-plan-count-drift.cjs` (#3183) so that
+ * `scripts/lint-milestone-window-drift.cjs` (#3184) and any future
+ * `scripts/lint-<derivation>-drift.cjs` guard consume ONE tree-walk /
+ * root-confinement / literal-tokenizer / sanitizer implementation instead of
+ * each copying it verbatim — the exact generative-fix-divergence class this
+ * epic exists to remove, now applied to the guards themselves (see
+ * `.gsd/phase/refactor-3184-milestone-window-single-owner/40-design.md`,
+ * "Rejected: let the new drift guard copy Phase 1's tree-walk /
+ * root-confinement / sanitizer").
+ *
+ * `lint-plan-count-drift.cjs` re-exports every symbol it exported before this
+ * extraction (`readRegexLiteralAt`, `MAX_REGEX_LITERAL_LEN`, `isInsideRoot`,
+ * `sanitizeForReport`), so `tests/plan-count-single-owner.test.cjs` — the
+ * ReDoS and root-confinement regression net for this exact machinery —
+ * continues to pass unchanged and is the regression net for this move too.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+// Longest regex literal this scanner will consider, in characters. Real
+// plan/summary filename filters (and milestone-window regex literals) are far
+// shorter; the bound is what keeps the scan linear. The tokenizer restarts at
+// every `/` on the line (so that a literal preceded by a stray unpaired `/`
+// is still found, matching the previous regex's "find anywhere" behaviour),
+// which without a per-literal bound would be quadratic on a pathological
+// line. With it the whole-line cost is O(n * MAX_REGEX_LITERAL_LEN) with no
+// backtracking at all.
+const MAX_REGEX_LITERAL_LEN = 400;
+
+// Directory names this scanner never descends into or reports out of —
+// `.git` (repo internals, e.g. a persisted CI token in `.git/config`),
+// `node_modules` (thousands of third-party files, none of them authored
+// source), `dist` (build output). Named once and used at BOTH skip sites
+// below: the cheap `entry.name` fast path in `walk`, and the resolved-path
+// component check in `isUnderSkippedDir` — a symlink whose OWN name is not
+// in this set but whose target resolves through a directory that IS (e.g.
+// `src/g -> ../.git`, `src/nm -> ../node_modules`) must still be skipped, or
+// the name-only check is a trivial bypass.
+const SKIP_DIR_NAMES = new Set(['node_modules', 'dist', '.git']);
+
+/**
+ * Read the JS regex literal starting at `line[start]` (which must be `/`).
+ * Returns `{ text, end }` — `text` includes the delimiters and any trailing
+ * flags, `end` is the index one past the literal — or null if no literal
+ * closes within MAX_REGEX_LITERAL_LEN characters.
+ *
+ * Single left-to-right pass, no backtracking. It models the two constructs a
+ * backtracking pattern gets wrong, which is why this is a tokenizer and not a
+ * regex:
+ *   - `\x` escapes consume BOTH characters, so an escaped `\/` never
+ *     terminates the literal;
+ *   - inside a `[...]` character class a bare `/` does NOT terminate, so
+ *     `/PLAN[\\/].*\.md$/` is one literal rather than two fragments. The
+ *     previous regex silently MISSED every re-derivation using a
+ *     cross-platform path-separator class for exactly this reason.
+ */
+// Deterministic regression seam for the MAJOR-2 bound (issue #3951/#3987): a
+// counter of how many characters this tokenizer has actually examined, so a
+// test can assert the bound HOLDS (total work stays a small linear multiple
+// of the number of scan attempts × MAX_REGEX_LITERAL_LEN) without resorting
+// to a wall-clock elapsed-time assertion, which this repo's test rules ban
+// ("Clock Seams: Do not assert on wall-clock time.") and which is exactly
+// what flaked on a slow shared CI runner. `resetRegexScanStats`/
+// `getRegexScanStats` are read-modify-reset around a single scan under test;
+// they are process-global and NOT safe under concurrent scans, which is fine
+// for this synchronous, single-threaded CLI tool and its tests.
+let regexScanStats = { calls: 0, charsExamined: 0 };
+
+function resetRegexScanStats() {
+  regexScanStats = { calls: 0, charsExamined: 0 };
+}
+
+function getRegexScanStats() {
+  return { ...regexScanStats };
+}
+
+function readRegexLiteralAt(line, start) {
+  if (line[start] !== '/') return null;
+  regexScanStats.calls++;
+  const limit = Math.min(line.length, start + MAX_REGEX_LITERAL_LEN);
+  let inClass = false;
+  let i = start + 1;
+  for (; i < limit; i++) {
+    const ch = line[i];
+    if (ch === '\\') {
+      i++; // escape consumes the next character, whatever it is
+      continue;
+    }
+    if (ch === '\r' || ch === '\n') {
+      // a literal cannot span lines
+      regexScanStats.charsExamined += i - start;
+      return null;
+    }
+    if (ch === '[') {
+      inClass = true;
+    } else if (ch === ']') {
+      inClass = false;
+    } else if (ch === '/' && !inClass) {
+      // Trailing flags are bounded by the SAME `limit` as the literal body
+      // itself (not `line.length`) — a literal followed by an unbounded run
+      // of lowercase letters must not make `text` grow past
+      // MAX_REGEX_LITERAL_LEN either.
+      let end = i + 1;
+      while (end < limit && line[end] >= 'a' && line[end] <= 'z') end++;
+      regexScanStats.charsExamined += end - start;
+      return { text: line.slice(start, end), end };
+    }
+  }
+  regexScanStats.charsExamined += limit - start;
+  return null;
+}
+
+// Symlinks report `isDirectory()`/`isFile()` as false on the Dirent from
+// `readdirSync`, so a symlinked `.cts` (or a symlinked directory containing
+// one) was previously invisible to this scanner — an evasion of a guard
+// whose stated design principle (ADR-3180 Decision 4a) is whole-repo
+// discovery with no allowlist. Resolve each entry with `fs.statSync` (which
+// follows symlinks) to classify it, skipping broken links. `ctx.visitedRealDirs`
+// guards against a symlink cycle sending `walk` into infinite recursion.
+//
+// Every sibling drift guard in `scripts/` that does NOT import this module
+// (`lint-phase-id-drift.cjs`, `lint-package-identity-drift.cjs`,
+// `lint-portable-timeout.cjs`, `lint-test-file-count.cjs`,
+// `lint-allow-test-rule-refs.cjs`) uses the `Dirent` classification straight
+// off `readdirSync` and does NOT follow symlinks at all. This scanner follows
+// them so a symlinked source file cannot evade ADR-3180 Decision 4a's
+// whole-repo discovery — root confinement (`isInsideRoot` below) is the price
+// of doing so: without it, a symlink planted anywhere under a scan directory
+// could walk this scanner out to read and report arbitrary files elsewhere on
+// disk.
+//
+// DIRECTORY vs FILE symlinks are confined to two DIFFERENT roots, tracked as
+// `ctx.scanDirRoot` (the realpath of the current top-level scan-dir entry,
+// e.g. `<realRoot>/src`) vs `ctx.realRoot` (the whole repo):
+//   - a DIRECTORY symlink is descended ONLY if its resolved realpath is
+//     inside `ctx.scanDirRoot` — NOT merely inside `ctx.realRoot`. Without
+//     this, `src/up -> ..` (or `-> <realRoot>`) resolves inside the repo
+//     root and `walk` descends the ENTIRE repo, reporting violations under
+//     paths like `tests/not-src.cts` or `docs/other.cts` — files the caller's
+//     scan-dir list scopes it OUT of. This is a deliberate, fail-CLOSED
+//     trade-off: a directory symlink pointing elsewhere INSIDE the repo (but
+//     outside the scan directory) is simply not followed. The alternative —
+//     descending it — is exactly the whole-repo sweep this rule exists to
+//     prevent, and a fork PR could use that sweep to redden `lint:ci` on
+//     files this guard was never meant to read. The narrower rule is worth
+//     more than the missed edge case.
+//   - a FILE symlink is still scanned if its resolved realpath is inside
+//     `ctx.realRoot` (the whole repo, not just the scan directory) — this is
+//     what keeps `src/alias.cts -> vendor/real.cts` covered (test (f)): an
+//     aliased file genuinely is part of the compiled surface even when its
+//     real target lives outside `src/`, and it is still reported under its
+//     canonical (real) path.
+//
+// A resolved path is inside a root only if it IS that root or begins with
+// root + separator — a plain `startsWith(root)` would also accept a sibling
+// directory whose name merely starts with the root's name (`/repo-evil`).
+function isInsideRoot(realPath, realRoot) {
+  return realPath === realRoot || realPath.startsWith(realRoot + path.sep);
+}
+
+// True when `realPath` (already confirmed inside `realRoot` by `isInsideRoot`)
+// resolves THROUGH a skip-list directory anywhere along its path relative to
+// the root — not just when `realPath` itself IS one. This is what closes the
+// symlink bypass the `entry.name` fast path alone cannot: `walk` tests
+// `entry.name` (the symlink's OWN name in its parent directory), but a
+// symlink named something innocuous can still RESOLVE into `.git` /
+// `node_modules` / `dist` (`src/g -> ../.git`, `src/leak.cts ->
+// ../.git/config`, `src/nm -> ../node_modules`) — `isInsideRoot` alone admits
+// all three, because every one of those real paths is still under the root.
+function isUnderSkippedDir(realPath, realRoot) {
+  const rel = path.relative(realRoot, realPath);
+  return rel.split(path.sep).some((segment) => SKIP_DIR_NAMES.has(segment));
+}
+
+// `ctx.scanExt` is a `Set` of file extensions (e.g. `.cts`/`.ts`/`.mts`) the
+// caller wants reported — threaded through `ctx` rather than as a positional
+// parameter so recursive `walk(full, acc, ctx)` calls stay unchanged.
+function walk(dir, acc, ctx) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return acc;
+  }
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (SKIP_DIR_NAMES.has(entry.name)) continue; // cheap fast path
+    let stat;
+    try {
+      stat = entry.isSymbolicLink() ? fs.statSync(full) : entry;
+    } catch {
+      continue; // broken symlink target
+    }
+    let realPath;
+    try {
+      realPath = fs.realpathSync(full);
+    } catch {
+      continue; // broken symlink target (race, or a link stat() followed but realpath cannot)
+    }
+    if (stat.isDirectory()) {
+      // Directories (symlinked or real) are confined to the CURRENT scan
+      // directory root, not merely the repo root — see the comment above
+      // `isInsideRoot` for why (`src/up -> ..` whole-repo sweep).
+      if (!isInsideRoot(realPath, ctx.scanDirRoot)) continue;
+      if (isUnderSkippedDir(realPath, ctx.realRoot)) continue; // symlink resolves through a skipped dir
+      if (ctx.visitedRealDirs.has(realPath)) continue; // symlink cycle guard
+      ctx.visitedRealDirs.add(realPath);
+      walk(full, acc, ctx);
+    } else if (stat.isFile() && ctx.scanExt.has(path.extname(entry.name))) {
+      // Files are confined to the whole repo root — a symlinked FILE whose
+      // real target lives outside the scan directory but inside the repo
+      // (e.g. `src/alias.cts -> vendor/real.cts`) is still part of the
+      // compiled surface and must be scanned.
+      if (!isInsideRoot(realPath, ctx.realRoot)) continue;
+      if (isUnderSkippedDir(realPath, ctx.realRoot)) continue; // symlink resolves through a skipped dir
+      if (ctx.visitedRealFiles.has(realPath)) continue; // two symlinks, same real file
+      ctx.visitedRealFiles.add(realPath);
+      acc.push(realPath);
+    }
+  }
+  return acc;
+}
+
+/**
+ * Whole-repo tree-walk driver shared by every `lint-<derivation>-drift.cjs`
+ * guard. Resolves `root`, walks each of `scanDirs` filtered to `scanExt`
+ * (symlink-following, root-confined, cycle-guarded — see `walk` above), reads
+ * each discovered file, and calls `onFile(relPath, text)` for it — `relPath`
+ * is repo-relative and already the file's canonical (real) path, so a
+ * per-file exemption keyed on `relPath` matches consistently regardless of
+ * which symlink reached it.
+ *
+ * `onFile` returns an array of violation objects (or an empty array / null /
+ * undefined for "no violations in this file"); `scanTree` flattens them all
+ * into one returned array. Pure I/O orchestration — detection logic lives
+ * entirely in the caller's `onFile`.
+ */
+function scanTree({ root, scanDirs, scanExt, onFile }) {
+  const violations = [];
+  let realRoot;
+  try {
+    realRoot = fs.realpathSync(root);
+  } catch {
+    return violations; // root itself does not exist / is unreadable
+  }
+  for (const dir of scanDirs) {
+    const scanDirPath = path.join(root, dir);
+    let scanDirRoot;
+    try {
+      scanDirRoot = fs.realpathSync(scanDirPath);
+    } catch {
+      continue; // scan directory itself does not exist / is unreadable
+    }
+    const ctx = { realRoot, scanDirRoot, scanExt, visitedRealDirs: new Set(), visitedRealFiles: new Set() };
+    for (const file of walk(scanDirPath, [], ctx)) {
+      const rel = path.relative(realRoot, file);
+      let text;
+      try {
+        text = fs.readFileSync(file, 'utf8');
+      } catch {
+        continue;
+      }
+      const found = onFile(rel, text);
+      if (found && found.length > 0) violations.push(...found);
+    }
+  }
+  return violations;
+}
+
+// A reported fragment AND a reported file path are both attacker-controlled
+// source text on a fork PR (a repo can legally track a filename containing
+// control bytes, so the path is exactly as attacker-controlled as the
+// fragment), and both are written straight to a CI log. Replace C0/C1
+// control bytes (ANSI escapes included) with a visible \xNN, AND the
+// non-Latin-1 formatting/bidi/line-separator codepoints below with \uNNNN, so
+// a crafted literal or filename cannot rewrite the terminal rendering of the
+// report or hide/reorder its own text:
+//   - U+200B-U+200F: zero-width space/joiners and directional marks
+//   - U+2028/U+2029: Unicode LINE SEPARATOR / PARAGRAPH SEPARATOR (line
+//     breaks a `\n`-only log scan would not catch)
+//   - U+202A-U+202E: bidi embedding/override controls (RLO etc.)
+//   - U+2066-U+2069: bidi isolate controls
+function sanitizeForReport(text) {
+  return text
+    // eslint-disable-next-line no-control-regex -- the control range IS the target
+    .replace(/[\x00-\x1f\x7f-\x9f]/g, (c) => '\\x' + c.charCodeAt(0).toString(16).padStart(2, '0'))
+    .replace(/[\u200B-\u200F\u2028\u2029\u202A-\u202E\u2066-\u2069]/g, (c) => '\\u' + c.charCodeAt(0).toString(16).padStart(4, '0'));
+}
+
+module.exports = {
+  SKIP_DIR_NAMES,
+  isInsideRoot,
+  isUnderSkippedDir,
+  walk,
+  readRegexLiteralAt,
+  MAX_REGEX_LITERAL_LEN,
+  sanitizeForReport,
+  scanTree,
+  resetRegexScanStats,
+  getRegexScanStats,
+};

package/scripts/lib/exit-code-registry.cjs

@@ -0,0 +1,98 @@
+'use strict';
+
+// GENERATED FILE — DO NOT EDIT BY HAND.
+// Source of truth: gsd-core/bin/shared/exit-codes.json. Regenerate with:
+//   node scripts/gen-exit-code-registry.cjs --write
+// This exact content is emitted to THREE locations — gsd-core/bin/lib/exit-code-registry.cjs,
+// scripts/lib/exit-code-registry.cjs, and hooks/lib/exit-code-registry.js (the latter two
+// committed so scripts/ and hooks/ consumers work on an unbuilt clone) — all byte-compared by
+// `npm run lint:generated-sync` (#3905 ADR-3889 Phase 1; #3906 Phase 2 added the second copy;
+// #3911 ADR-3889 Phase 7 added the hooks/lib/ copy).
+//
+// exitCodeFor(name) / nameForExitCode(code) are pure and total over this
+// closed table — each throws for anything not registered here.
+
+const EXIT_CODES = Object.freeze([
+  Object.freeze({
+    code: 2,
+    name: "HOOK_DENY",
+    meaning: "Hook protocol deny — the harness blocks the tool call",
+    owner: "hook-adapter",
+    authorizedBy: "ADR-3889",
+  }),
+  Object.freeze({
+    code: 64,
+    name: "USAGE",
+    meaning: "Caller error — bad argv, unknown subcommand, missing argument",
+    owner: "generic",
+    authorizedBy: "ADR-3889",
+  }),
+  Object.freeze({
+    code: 66,
+    name: "NO_INPUT",
+    meaning: "Ran; zero units were in scope, and that emptiness is known to be genuine",
+    owner: "generic",
+    authorizedBy: "ADR-3889",
+  }),
+  Object.freeze({
+    code: 69,
+    name: "UNAVAILABLE",
+    meaning: "Could not run — prerequisite absent, input unreadable, scope unestablished",
+    owner: "generic",
+    authorizedBy: "ADR-3889",
+  }),
+  Object.freeze({
+    code: 70,
+    name: "INTERNAL",
+    meaning: "Self-failure — crash, timeout, killed subprocess",
+    owner: "generic",
+    authorizedBy: "ADR-3889",
+  }),
+  Object.freeze({
+    code: 80,
+    name: "DEGRADED",
+    meaning: "Ran to completion and is reporting a condition through its result payload rather than as a process failure",
+    owner: "gsd-tools",
+    authorizedBy: "ADR-3889 + ADR-2980",
+  })
+]);
+
+const NAME_TO_CODE = new Map(EXIT_CODES.map((entry) => [entry.name, entry.code]));
+const CODE_TO_NAME = new Map(EXIT_CODES.map((entry) => [entry.code, entry.name]));
+
+/**
+ * Resolve the registered exit code for a symbolic name. Pure, total: throws
+ * for anything not an exact, registered, exact-case key — including
+ * non-strings, the empty string, untrimmed strings, wrong case, and
+ * prototype-chain names like `__proto__`/`constructor`/`toString` (a Map
+ * lookup never touches the prototype chain, so these are indistinguishable
+ * from any other unregistered name).
+ *
+ * @param {string} name
+ * @returns {number}
+ */
+function exitCodeFor(name) {
+  if (typeof name !== 'string' || name.length === 0) {
+    throw new Error(`exitCodeFor: name must be a non-empty string, received ${JSON.stringify(name)}`);
+  }
+  if (!NAME_TO_CODE.has(name)) {
+    throw new Error(`exitCodeFor: unregistered exit code name: ${JSON.stringify(name)}`);
+  }
+  return NAME_TO_CODE.get(name);
+}
+
+/**
+ * Reverse of exitCodeFor: resolve the symbolic name for a registered exit
+ * code. Pure, total: throws for anything not an exact, registered code.
+ *
+ * @param {number} code
+ * @returns {string}
+ */
+function nameForExitCode(code) {
+  if (!CODE_TO_NAME.has(code)) {
+    throw new Error(`nameForExitCode: unregistered exit code: ${JSON.stringify(code)}`);
+  }
+  return CODE_TO_NAME.get(code);
+}
+
+module.exports = { EXIT_CODES, exitCodeFor, nameForExitCode };

package/scripts/lib/ndjson-reporter.cjs

@@ -0,0 +1,119 @@
+'use strict';
+
+// Machine-readable companion reporter for scripts/run-tests.cjs (#3889).
+//
+// node:test's built-in reporters (spec/tap) are human-formatted and
+// scripts/run-tests.cjs spawns the child with `stdio: 'inherit'` — by design,
+// per #3597/#1051, to avoid the maxBuffer and live-output risks of piping —
+// so the parent process has no way to see WHICH file was executing when a
+// per-chunk timeout kills the child. This reporter runs ALONGSIDE the normal
+// human reporter (a second `--test-reporter` on the same invocation, per
+// Node's documented multi-reporter pairing) and appends one JSON object per
+// line to a path supplied via the GSD_RUN_TESTS_EVENTS_FILE env var. On a
+// timeout, run-tests.cjs reads that file back to name the file(s) still
+// in flight (a `test:dequeue` with no matching `test:pass`/`test:fail`).
+//
+// Durability, not `--test-reporter-destination` (#3889 root cause): a
+// reporter that YIELDS strings has them piped by Node into a
+// `fs.WriteStream` targeting the destination path, and that stream buffers.
+// The parent's `execFileSync` timeout SIGKILLs the child on a hang, and
+// SIGKILL is uncatchable and gives the process zero chance to flush — so a
+// yield-based reporter can lose every event still sitting in the stream's
+// buffer, which is exactly the case this feature exists to diagnose (proven
+// live: a chunk killed at 2006ms produced a `killed after 2006ms` line from
+// the TIMER, which lives in the parent, but zero usable events from the
+// reporter, which lives in the child and never flushed). Writing each event
+// with `fs.appendFileSync` — synchronous and unbuffered — makes it durable
+// the instant it happens, before the process can be killed out from under
+// it. The reporter therefore yields NOTHING; it is a pure side-effecting
+// sink. Node still requires a `--test-reporter-destination` to pair with
+// this `--test-reporter` (see run-tests.cjs's reporterArgsFor), but that
+// destination is a throwaway sink that stays empty by design — the durable
+// path is GSD_RUN_TESTS_EVENTS_FILE, not the destination Node manages.
+//
+// Contract targeted: Node's "Custom reporters" contract
+// (https://nodejs.org/api/test.html#custom-reporters) — a reporter module's
+// default export is a function receiving the test runner's event stream (an
+// AsyncIterable of `{ type, data }` objects). Node feeds that function to
+// `stream.compose` as the stream's "body". When the body is an async
+// FUNCTION (not an `async function*` generator), `stream.compose`'s own
+// contract (https://nodejs.org/api/stream.html#streamcomposestreams)
+// requires it to return nully (undefined/null) — returning anything else,
+// including an array, throws `ERR_INVALID_RETURN_VALUE` ("Expected nully to
+// be returned from the 'body' function but got an instance of Array")
+// exactly once the promise resolves. Verified directly against
+// `stream.compose` in this repo's Node: calling it with a body that
+// `return`s `[]` reproduces that same TypeError. A generator form
+// (`async function*`) is the one that yields an iterable; the plain
+// `async function` form used here is the one that must return nully. This
+// repo's `engines.node` requires >=24.0.0 (package.json), where both
+// contracts have been stable since Node 20.
+//
+// Kept intentionally tiny: only the five event types run-tests.cjs needs are
+// handled — `test:enqueue`/`test:dequeue` (emitted by the RUNNER as it queues
+// and begins each spawned test-file child, independent of whether anything
+// inside that file ever completes) plus `test:start`/`test:pass`/`test:fail`
+// (emitted per-subtest, once the child reports it). `test:dequeue` is the
+// event that actually means "in flight": a subtest inside a file that hangs
+// forever never reaches `test:start`/`test:pass`/`test:fail` at all, because
+// node:test only surfaces those to the parent once the child COMPLETES that
+// test — a hang, by definition, never completes. Recording `test:dequeue`
+// closes that gap: it fires the moment the runner begins the file, so a
+// killed hang still leaves a durable "this file was running" record.
+// Everything else (diagnostics, plans, coverage) is ignored so a truncated
+// events file (the process is SIGKILLed mid-`appendFileSync` on timeout — an
+// individual write is unbuffered but not atomic, so the OS can still
+// interleave a partial write with the kill) never leaves more than one
+// dangling unparsable trailing line.
+module.exports = async function ndjsonEventReporter(source) {
+  const eventsPath = process.env.GSD_RUN_TESTS_EVENTS_FILE;
+  // #3889: an init marker, written as this reporter's FIRST action — before
+  // the `for await` loop even begins consuming the event stream — so the
+  // events file's mere existence (and its exact contents) can distinguish
+  // "the reporter module never loaded in the child at all" (file absent)
+  // from "it loaded fine but no test:start reached it before the kill"
+  // (file contains only this one line) from "it's working" (file contains
+  // more than this line). Same appendFileSync durability rationale as every
+  // other write in this file: synchronous and unbuffered, so it survives an
+  // uncatchable SIGKILL landing a moment later.
+  if (eventsPath) {
+    try {
+      require('fs').appendFileSync(eventsPath, `${JSON.stringify({ type: 'reporter:init', ts: Date.now() })}\n`);
+    } catch {
+      // Best-effort, same as every other write below — must never crash the
+      // test run this reporter is only observing.
+    }
+  }
+  for await (const event of source) {
+    if (!eventsPath) continue; // no destination configured — nothing to record
+    if (
+      event.type === 'test:enqueue' ||
+      event.type === 'test:dequeue' ||
+      event.type === 'test:start' ||
+      event.type === 'test:pass' ||
+      event.type === 'test:fail'
+    ) {
+      const { file, name, nesting, testNumber } = event.data || {};
+      const line = `${JSON.stringify({
+        type: event.type,
+        file,
+        name,
+        nesting,
+        testNumber,
+        ts: Date.now(),
+      })}\n`;
+      try {
+        require('fs').appendFileSync(eventsPath, line);
+      } catch {
+        // Best-effort: a write failure here (e.g. the events dir vanished)
+        // must never crash the test run this reporter is only observing.
+      }
+    }
+  }
+  // Falls through to an implicit `return undefined` (nully): this reporter is
+  // a pure side-effecting sink (see the durability note above), never a
+  // source of reporter OUTPUT, and `stream.compose` requires its async
+  // FUNCTION body to return nully — returning an iterable (e.g. `[]`) here
+  // raises `ERR_INVALID_RETURN_VALUE` (observed live: this exact `return []`
+  // crashed every chunk on the real remote run this regresses).
+};

package/scripts/lint-allow-test-rule-refs.allowlist.json

@@ -2,7 +2,6 @@
   "tests/agent-classification-parity.test.cjs :: source-text-is-the-product",
   "tests/agent-frontmatter.test.cjs :: source-text-is-the-product",
   "tests/agent-required-reading-consistency.test.cjs :: source-text-is-the-product",
-  "tests/agent-size-budget.test.cjs :: source-text-is-the-product",
   "tests/agent-skills-awareness.test.cjs :: source-text-is-the-product",
   "tests/ai-evals.test.cjs :: source-text-is-the-product",
   "tests/analyze-dependencies.test.cjs :: source-text-is-the-product",
@@ -16,9 +15,7 @@
   "tests/autonomous-to-flag.test.cjs :: source-text-is-the-product",
   "tests/chain-flag-plan-phase.test.cjs :: source-text-is-the-product",
   "tests/changeset-cli.test.cjs :: source-text-is-the-product",
-  "tests/check-update-config-dir.test.cjs :: structural-regression-guard",
   "tests/claude-md.test.cjs :: source-text-is-the-product",
-  "tests/claude-skills-migration.test.cjs :: source-text-is-the-product",
   "tests/cleanup-branch-pruning.test.cjs :: source-text-is-the-product",
   "tests/cline-install.test.cjs :: source-text-is-the-product",
   "tests/cline-support.test.cjs :: source-text-is-the-product",
@@ -30,7 +27,6 @@
   "tests/codex-config.test.cjs :: source-text-is-the-product",
   "tests/command-contract.test.cjs :: source-text-is-the-product",
   "tests/commands.test.cjs :: source-text-is-the-product",
-  "tests/concurrency-safety.test.cjs :: source-text-is-the-product",
   "tests/config-field-docs.test.cjs :: docs-parity",
   "tests/context-enrichment.test.cjs :: source-text-is-the-product",
   "tests/contributor-standards.test.cjs :: source-text-is-the-product",
@@ -38,9 +34,7 @@
   "tests/cursor-hooks.test.cjs :: source-text-is-the-product",
   "tests/cursor-reviewer.test.cjs :: source-text-is-the-product",
   "tests/debug-session-management.test.cjs :: source-text-is-the-product",
-  "tests/discuss-all-flag.test.cjs :: source-text-is-the-product",
   "tests/discuss-checkpoint.test.cjs :: source-text-is-the-product",
-  "tests/discuss-mode.test.cjs :: structural-implementation-guard",
   "tests/discuss-phase-power.test.cjs :: source-text-is-the-product",
   "tests/docs-parity-live-registry.test.cjs :: source-text-is-the-product",
   "tests/drift-detection.test.cjs :: source-text-is-the-product",
@@ -48,9 +42,6 @@
   "tests/edge-probe-planner-contract.test.cjs :: source-text-is-the-product",
   "tests/edge-probe-spec-phase-contract.test.cjs :: source-text-is-the-product",
   "tests/edit-phase.test.cjs :: source-text-is-the-product",
-  "tests/eslint-rules.test.cjs :: <source-grep reason> must still error",
-  "tests/eslint-rules.test.cjs :: pending migration",
-  "tests/eslint-rules.test.cjs :: source-text-is-the-product",
   "tests/execute-phase-active-flags.test.cjs :: source-text-is-the-product",
   "tests/execute-phase-step-5-5-deviation-doc.test.cjs :: source-text-is-the-product",
   "tests/execute-phase-wave.test.cjs :: source-text-is-the-product",
@@ -65,26 +56,16 @@
   "tests/gsd-researcher-app-aware.test.cjs :: source-text-is-the-product",
   "tests/gsd-researcher-flow-diagram.test.cjs :: source-text-is-the-product",
   "tests/gsd-settings-advanced.test.cjs :: source-text-is-the-product",
-  "tests/gsd2-import.test.cjs :: source-text-is-the-product",
+  "tests/helpers/live-command-registry.cjs :: source-text-is-the-product",
   "tests/hermes-skills-migration.test.cjs :: source-text-is-the-product",
   "tests/import-command.test.cjs :: source-text-is-the-product",
   "tests/ingest-docs.test.cjs :: source-text-is-the-product",
   "tests/inline-plan-threshold.test.cjs :: source-text-is-the-product",
-  "tests/install-minimal-hooks.test.cjs :: source-text-is-the-product",
   "tests/install-nested-layout.test.cjs :: source-text-is-the-product",
   "tests/install-runtime-artifacts.test.cjs :: source-text-is-the-product",
-  "tests/install.test.cjs :: source-text-is-the-product",
   "tests/intel.test.cjs :: source-text-is-the-product",
   "tests/inventory-headings-countfree.test.cjs :: source-text-is-the-product",
   "tests/ios-scaffold-safety.test.cjs :: source-text-is-the-product",
-  "tests/issue-2639-codex-toml-neutralization.test.cjs :: source-text-is-the-product",
-  "tests/issue-429-comment-text-gate.test.cjs :: source-text-is-the-product",
-  "tests/issue-498-update-backup-runtime-dir.test.cjs :: source-text-is-the-product",
-  "tests/issue-57-runtime-install-no-drift.test.cjs :: structural-regression-guard",
-  "tests/issue-607-installer-dry-run.install.test.cjs :: integration-test-input",
-  "tests/issue-607-legacy-cleanup.test.cjs :: integration-test-input",
-  "tests/issue-787-cline-hooks-agents.test.cjs :: source-text-is-the-product",
-  "tests/issue-815-update-next-channel.test.cjs :: source-text-is-the-product",
   "tests/locking-bugs-1909-1916-1925-1927.test.cjs :: architectural-invariant",
   "tests/mcp-tool-inheritance.test.cjs :: source-text-is-the-product",
   "tests/milestone-summary.test.cjs :: source-text-is-the-product",
@@ -93,13 +74,10 @@
   "tests/next-safety-gates.test.cjs :: source-text-is-the-product",
   "tests/next-up-clear-order.test.cjs :: source-text-is-the-product",
   "tests/no-hardcoded-home-gsd-tools.test.cjs :: source-text-is-the-product",
-  "tests/opencode-permissions.test.cjs :: architectural-invariant",
-  "tests/orphan-worktree-detection.test.cjs :: architectural-invariant",
   "tests/orphaned-hooks.test.cjs :: structural-regression-guard",
   "tests/package-legitimacy-gate.test.cjs :: source-text-is-the-product",
   "tests/parallel-dependent-plans.test.cjs :: source-text-is-the-product",
   "tests/path-replacement.test.cjs :: source-text-is-the-product",
-  "tests/phase-dependency-levels.test.cjs :: source-text-is-the-product",
   "tests/phase.test.cjs :: source-text-is-the-product",
   "tests/phase6-capability-docs.test.cjs :: source-text-is-the-product",
   "tests/phase6-capstone-conformance.test.cjs :: source-text-is-the-product",
@@ -117,7 +95,6 @@
   "tests/profile-output.test.cjs :: source-text-is-the-product",
   "tests/progress-forensic.test.cjs :: source-text-is-the-product",
   "tests/prompt-thinning.test.cjs :: source-text-is-the-product",
-  "tests/quick-session-management.test.cjs :: source-text-is-the-product",
   "tests/qwen-skills-migration.test.cjs :: source-text-is-the-product",
   "tests/read-guard.test.cjs :: source-text-is-the-product",
   "tests/reapply-patches.test.cjs :: source-text-is-the-product",
@@ -126,7 +103,6 @@
   "tests/release-tarball-smoke-workflow.test.cjs :: source-text-is-the-product",
   "tests/release-tarball-smoke.install.test.cjs :: integration-test-input",
   "tests/research-agent-profiles.test.cjs :: source-text-is-the-product",
-  "tests/review-default-reviewers-workflow.test.cjs :: source-text-is-the-product",
   "tests/roadmap.test.cjs :: source-text-is-the-product",
   "tests/runtime-launcher-parity.test.cjs :: structural-regression-guard",
   "tests/runtime-name-policy.test.cjs :: source-text-is-the-product",
@@ -144,7 +120,6 @@
   "tests/subagent-timeout.test.cjs :: source-text-is-the-product",
   "tests/template.test.cjs :: source-text-is-the-product",
   "tests/thinking-partner.test.cjs :: source-text-is-the-product",
-  "tests/thread-session-management.test.cjs :: source-text-is-the-product",
   "tests/ultraplan-phase.test.cjs :: source-text-is-the-product",
   "tests/verify-health.test.cjs :: source-text-is-the-product",
   "tests/verify-test-quality.test.cjs :: source-text-is-the-product",

package/scripts/lint-allow-test-rule-refs.effective-ceiling.json

@@ -0,0 +1,4 @@
+{
+  "maxSites": 10,
+  "grace": 2
+}

package/scripts/lint-allow-test-rule-refs.unverified-ceiling.json

@@ -0,0 +1,3 @@
+{
+  "maxFiles": 282
+}