mandrel 2.27.0 → 2.29.0

package/.agents/scripts/lib/config/quality.js

@@ -71,6 +71,19 @@ const DEFAULT_MI_FLOORS = Object.freeze({
   '*': Object.freeze({ min: 70 }),
 });
 
+/**
+ * Story #4981 — opt-in incremental coverage-capture + CRAP-join scoping.
+ * Disabled by default: `coverage-capture.js` and the CRAP join keep their
+ * pre-#4981 full-repo behaviour byte-for-byte until a consumer sets
+ * `enabled: true`. `baseRef: null` means "use the caller's own ref
+ * resolution" (the gate's `--ref` flag / `main`) rather than a second,
+ * possibly-conflicting default.
+ */
+const DEFAULT_INCREMENTAL_COVERAGE = Object.freeze({
+  enabled: false,
+  baseRef: null,
+});
+
 /** Framework defaults for the CRAP gate (post-1737 uniform shape). */
 export const CRAP_GATE_DEFAULTS = Object.freeze({
   enabled: true,
@@ -97,6 +110,7 @@ export const CRAP_GATE_DEFAULTS = Object.freeze({
   // run (a repo with fresh coverage resolves ~98%) and far below the 4–6%
   // signature of a coordinate-system mismatch.
   minMethodResolutionRate: 0.75,
+  incrementalCoverage: DEFAULT_INCREMENTAL_COVERAGE,
 });
 
 /** Framework defaults for the coverage gate. */
@@ -163,6 +177,7 @@ const CRAP_GATE_KEYS = new Set([
   'refreshTimeoutMs',
   'ignoreGlobs',
   'minMethodResolutionRate',
+  'incrementalCoverage',
 ]);
 
 const COVERAGE_GATE_KEYS = new Set([
@@ -240,6 +255,27 @@ function resolveResolutionRate(value, fallback) {
   return value;
 }
 
+/**
+ * Resolve `gates.crap.incrementalCoverage` (Story #4981). A malformed or
+ * absent user block resolves to the framework default (disabled), so a
+ * consumer that never sets the key gets the exact pre-#4981 shape back.
+ *
+ * @param {{ enabled?: boolean, baseRef?: string } | undefined} user
+ * @param {{ enabled: boolean, baseRef: string | null }} defaults
+ * @returns {{ enabled: boolean, baseRef: string | null }}
+ */
+function resolveIncrementalCoverage(user, defaults) {
+  if (user == null || typeof user !== 'object') return { ...defaults };
+  return {
+    enabled:
+      typeof user.enabled === 'boolean' ? user.enabled : defaults.enabled,
+    baseRef:
+      typeof user.baseRef === 'string' && user.baseRef.length > 0
+        ? user.baseRef
+        : defaults.baseRef,
+  };
+}
+
 export function resolveMaintainabilityCrap(
   userCrap,
   gateScoping,
@@ -267,6 +303,7 @@ export function resolveMaintainabilityCrap(
       refreshTag: defaults.refreshTag,
       refreshTimeoutMs: defaults.refreshTimeoutMs,
       ignoreGlobs: [...defaults.ignoreGlobs],
+      incrementalCoverage: { ...defaults.incrementalCoverage },
       defaultScope: scoping.defaultScope,
       diffRef: scoping.diffRef,
     };
@@ -297,6 +334,10 @@ export function resolveMaintainabilityCrap(
     ignoreGlobs: Array.isArray(userCrap.ignoreGlobs)
       ? userCrap.ignoreGlobs.slice()
       : [...defaults.ignoreGlobs],
+    incrementalCoverage: resolveIncrementalCoverage(
+      userCrap.incrementalCoverage,
+      defaults.incrementalCoverage,
+    ),
     defaultScope: scoping.defaultScope,
     diffRef: scoping.diffRef,
   };

package/.agents/scripts/lib/config-settings-schema-delivery.js

@@ -443,6 +443,12 @@ export const DELIVERY_SCHEMA = {
     deliverRunner: DELIVER_RUNNER_SCHEMA,
     worktreeIsolation: WORKTREE_ISOLATION_SCHEMA,
     signals: SIGNALS_SCHEMA,
+    // `quality.gates.crap.incrementalCoverage` (Story #4981) is declared in
+    // `config/gates/crap.schema.js` and reaches AJV validation through this
+    // property — QUALITY_SCHEMA → GATES_SCHEMA → CRAP_GATE. No separate
+    // declaration lives here; this is the composition point that makes the
+    // gate-level schema authoritative for the top-level `.agentrc.json`
+    // surface this module validates.
     quality: QUALITY_SCHEMA,
     mergeWatch: MERGE_WATCH_SCHEMA,
     codeReview: CODE_REVIEW_SCHEMA,

package/.agents/scripts/lib/coverage-capture-fullscope.js

@@ -0,0 +1,105 @@
+/**
+ * coverage-capture-fullscope.js — the full-scope (pre-#4981, and still the
+ * default) capture path for `coverage-capture.js`.
+ *
+ * Hoisted out of the CLI shell's `runCoverageCapture` verbatim (Story
+ * #4981) so that function's cyclomatic complexity does not grow with the
+ * incremental-mode branch alongside it — this is a relocation, not new
+ * logic; behaviour is byte-for-byte the pre-#4981 body.
+ */
+import path from 'node:path';
+import { anyChangedUnderTargets } from './coverage-capture.js';
+
+/**
+ * Run the `--skip-when-no-crap-files` check (when requested), the
+ * content-digest freshness probe, and — when stale — the full-repo
+ * `npm run test:coverage` capture + stamp write.
+ *
+ * @param {{
+ *   crap: object,
+ *   coverage: object,
+ *   args: { skipWhenNoCrapFiles: boolean, ref: string, cwd: string },
+ *   getChangedFilesImpl: Function,
+ *   isCoverageFreshImpl: Function,
+ *   runCaptureImpl: Function,
+ *   computeContentDigestImpl: Function,
+ *   writeCaptureStampImpl: Function,
+ *   logger: { info: Function, warn: Function, error: Function },
+ * }} opts
+ * @returns {number} process exit code
+ */
+export function runFullScopeCapture({
+  crap,
+  coverage,
+  args,
+  getChangedFilesImpl,
+  isCoverageFreshImpl,
+  runCaptureImpl,
+  computeContentDigestImpl,
+  writeCaptureStampImpl,
+  logger,
+}) {
+  if (args.skipWhenNoCrapFiles) {
+    let changed;
+    try {
+      changed = getChangedFilesImpl({ ref: args.ref, cwd: args.cwd });
+    } catch (err) {
+      // A bad ref must not silently relax the gate. Fall through to the
+      // freshness check so coverage still gets captured if needed.
+      logger.warn(
+        `[coverage-capture] ⚠ ${err?.message ?? err} — falling back to freshness check.`,
+      );
+      changed = null;
+    }
+    if (changed && !anyChangedUnderTargets(changed, crap.targetDirs)) {
+      logger.info(
+        `[coverage-capture] No changed files under [${crap.targetDirs.join(', ')}] — skipping capture.`,
+      );
+      return 0;
+    }
+  }
+
+  const freshness = isCoverageFreshImpl({
+    coveragePath: crap.coveragePath,
+    targetDirs: crap.targetDirs,
+    cwd: args.cwd,
+  });
+  if (freshness.fresh) {
+    logger.info(
+      `[coverage-capture] Coverage at ${path.resolve(args.cwd, crap.coveragePath)} is ${freshness.reason} — skipping capture.`,
+    );
+    return 0;
+  }
+
+  logger.info(
+    `[coverage-capture] Coverage at ${crap.coveragePath} is ${freshness.reason}; running npm run test:coverage…`,
+  );
+  const code = runCaptureImpl({
+    cwd: args.cwd,
+    timeoutMs: coverage?.timeoutMs,
+    log: (m) => logger.info(m),
+  });
+  if (code !== 0) {
+    logger.error(
+      `[coverage-capture] ✖ npm run test:coverage exited ${code}. Fix failing tests or coverage-threshold breaches before re-running the CRAP gate.`,
+    );
+    return code;
+  }
+
+  // Persist the content digest next to the fresh artifact so subsequent
+  // freshness checks are content-aware (mtime churn from branch switches no
+  // longer invalidates). Best-effort — a missing stamp just means the next
+  // check falls back to the mtime heuristic.
+  const digest = computeContentDigestImpl(args.cwd, crap.targetDirs);
+  if (
+    digest &&
+    writeCaptureStampImpl({
+      cwd: args.cwd,
+      coveragePath: crap.coveragePath,
+      digest,
+    })
+  ) {
+    logger.info('[coverage-capture] Wrote content-digest capture stamp.');
+  }
+  return code;
+}

package/.agents/scripts/lib/coverage-capture-incremental.js

@@ -0,0 +1,116 @@
+/**
+ * coverage-capture-incremental.js — the incremental-mode capture path for
+ * `coverage-capture.js` (Story #4981).
+ *
+ * Split into its own module (rather than added inline to the CLI shell) so
+ * the Story's opt-in branch lands as new code, not a same-file expansion of
+ * `runCoverageCapture`. Every collaborator is injected — no seam differs
+ * from the ones `coverage-capture.js` already exposes on its `deps`
+ * parameter (`.agents/rules/test-seams.md` rules 1-2, 4).
+ */
+import path from 'node:path';
+
+/**
+ * Run the incremental capture path when
+ * `delivery.quality.gates.crap.incrementalCoverage.enabled` is true.
+ *
+ * Returns the process exit code when incremental mode handled the run
+ * (skip, capture, or a capture failure), or `null` when the caller should
+ * fall through to the full-scope path — either incremental mode is
+ * disabled, or the changed-files ref could not be resolved (a
+ * misconfiguration must not silently relax the gate).
+ *
+ * @param {{
+ *   crap: object,
+ *   coverage: object,
+ *   args: { ref: string, cwd: string },
+ *   getChangedFilesImpl: Function,
+ *   filterFilesUnderTargetsImpl: Function,
+ *   isCoverageFreshImpl: Function,
+ *   runCaptureImpl: Function,
+ *   computeContentDigestImpl: Function,
+ *   writeCaptureStampImpl: Function,
+ *   logger: { info: Function, warn: Function, error: Function },
+ * }} opts
+ * @returns {number | null}
+ */
+export function tryIncrementalCapture({
+  crap,
+  coverage,
+  args,
+  getChangedFilesImpl,
+  filterFilesUnderTargetsImpl,
+  isCoverageFreshImpl,
+  runCaptureImpl,
+  computeContentDigestImpl,
+  writeCaptureStampImpl,
+  logger,
+}) {
+  if (crap.incrementalCoverage?.enabled !== true) return null;
+
+  const ref = crap.incrementalCoverage.baseRef || args.ref;
+  let changed = null;
+  try {
+    changed = getChangedFilesImpl({ ref, cwd: args.cwd });
+  } catch (err) {
+    logger.warn(
+      `[coverage-capture] ⚠ incremental mode: ${err?.message ?? err} — falling back to full-scope capture.`,
+    );
+    return null;
+  }
+
+  const scopedFiles = filterFilesUnderTargetsImpl(changed, crap.targetDirs);
+  if (scopedFiles.length === 0) {
+    logger.info(
+      `[coverage-capture] Incremental mode: no changed files under [${crap.targetDirs.join(', ')}] vs ${ref} — skipping capture.`,
+    );
+    return 0;
+  }
+
+  const freshness = isCoverageFreshImpl({
+    coveragePath: crap.coveragePath,
+    targetDirs: crap.targetDirs,
+    cwd: args.cwd,
+    requireScope: 'incremental',
+  });
+  if (freshness.fresh) {
+    logger.info(
+      `[coverage-capture] Coverage at ${path.resolve(args.cwd, crap.coveragePath)} is ${freshness.reason} (incremental) — skipping capture.`,
+    );
+    return 0;
+  }
+
+  logger.info(
+    `[coverage-capture] Incremental mode: capturing coverage scoped to ${scopedFiles.length} changed file(s) under [${crap.targetDirs.join(', ')}]…`,
+  );
+  const code = runCaptureImpl({
+    cwd: args.cwd,
+    timeoutMs: coverage?.timeoutMs,
+    log: (m) => logger.info(m),
+    files: scopedFiles,
+  });
+  if (code !== 0) {
+    logger.error(
+      `[coverage-capture] ✖ npm run test:coverage exited ${code}. Fix failing tests or coverage-threshold breaches before re-running the CRAP gate.`,
+    );
+    return code;
+  }
+
+  const digest = computeContentDigestImpl(args.cwd, crap.targetDirs);
+  if (
+    digest &&
+    writeCaptureStampImpl({
+      cwd: args.cwd,
+      coveragePath: crap.coveragePath,
+      digest,
+      scope: 'incremental',
+      files: scopedFiles,
+      ref,
+    })
+  ) {
+    logger.info(
+      '[coverage-capture] Wrote content-digest capture stamp (incremental scope).',
+    );
+  }
+  return code;
+}

package/.agents/scripts/lib/coverage-capture.js

@@ -151,10 +151,20 @@ export function computeContentDigest(cwd, targetDirs, io = {}) {
  * write failure returns `false` rather than throwing — the worst case is a
  * fall back to the mtime heuristic on the next freshness check.
  *
+ * `scope` / `files` / `ref` are Story #4981 additions for incremental-mode
+ * capture. They are written to the stamp **only when the caller supplies
+ * `scope`** — the default (full-scope) call sites never pass it, so the
+ * emitted JSON stays the exact `{ digest, capturedAt }` shape byte-for-byte
+ * (AC-5). `isCoverageFresh` reads `scope` back to refuse letting a scoped
+ * stamp satisfy a full-scope freshness probe (AC-4).
+ *
  * @param {{
  *   cwd: string,
  *   coveragePath: string,
  *   digest: string,
+ *   scope?: 'full' | 'incremental',
+ *   files?: string[],
+ *   ref?: string,
  *   writeFileSync?: typeof fs.writeFileSync,
  * }} opts
  * @returns {boolean} True when the stamp was written.
@@ -163,13 +173,20 @@ export function writeCaptureStamp({
   cwd,
   coveragePath,
   digest,
+  scope,
+  files,
+  ref,
   writeFileSync = fs.writeFileSync,
 }) {
   if (typeof digest !== 'string' || digest.length === 0) return false;
+  const payload = { digest, capturedAt: new Date().toISOString() };
+  if (scope !== undefined) payload.scope = scope;
+  if (Array.isArray(files)) payload.files = [...files].sort();
+  if (typeof ref === 'string' && ref.length > 0) payload.ref = ref;
   try {
     writeFileSync(
       captureStampPath(cwd, coveragePath),
-      `${JSON.stringify({ digest, capturedAt: new Date().toISOString() }, null, 2)}\n`,
+      `${JSON.stringify(payload, null, 2)}\n`,
     );
     return true;
   } catch {
@@ -177,6 +194,29 @@ export function writeCaptureStamp({
   }
 }
 
+/**
+ * Read a persisted capture stamp's digest and scope tag back into the shape
+ * `isCoverageFresh` needs, applying the Story #4981 scope-asymmetry rule
+ * (AC-4) in one place. Extracted so the parent function's own branching
+ * stays under the cyclomatic ceiling.
+ *
+ * @param {{digest?: unknown, scope?: unknown} | null} stamp
+ * @param {'full' | 'incremental'} requireScope
+ * @returns {{ digest: string } | { scopeMismatch: true } | null} `null`
+ *   means the stamp is missing/unreadable/digest-less — fall through to the
+ *   mtime heuristic.
+ */
+function readStampForScope(stamp, requireScope) {
+  if (typeof stamp?.digest !== 'string' || stamp.digest.length === 0) {
+    return null;
+  }
+  const stampScope = stamp.scope === 'incremental' ? 'incremental' : 'full';
+  if (stampScope === 'incremental' && requireScope !== 'incremental') {
+    return { scopeMismatch: true };
+  }
+  return { digest: stamp.digest };
+}
+
 /**
  * Decide whether the existing coverage artifact is "fresh".
  *
@@ -191,22 +231,32 @@ export function writeCaptureStamp({
  * under `targetDirs`. Missing files, missing target dirs, or any IO error
  * resolve to `false` so the caller captures rather than trusting stale data.
  *
+ * **Scope asymmetry (Story #4981, AC-4).** A stamp written by an incremental
+ * capture (`scope: 'incremental'`) only covers the files the diff touched —
+ * it must never satisfy a caller that requires the full-scope guarantee
+ * (`requireScope` defaults to `'full'`, matching every pre-existing caller
+ * byte-for-byte). A full-scope stamp (or a legacy stamp with no `scope`
+ * field, which predates this Story and is therefore full-scope by
+ * construction) satisfies either probe.
+ *
  * @param {{
  *   coveragePath: string,
  *   targetDirs: string[],
  *   cwd: string,
+ *   requireScope?: 'full' | 'incremental',
  *   statSync?: typeof fs.statSync,
  *   readdirSync?: typeof fs.readdirSync,
  *   existsSync?: typeof fs.existsSync,
  *   readFileSync?: typeof fs.readFileSync,
  *   computeDigest?: typeof computeContentDigest,
  * }} opts
- * @returns {{ fresh: boolean, reason: 'missing' | 'stale' | 'fresh' | 'no-sources' }}
+ * @returns {{ fresh: boolean, reason: 'missing' | 'stale' | 'fresh' | 'no-sources' | 'scope-mismatch' }}
  */
 export function isCoverageFresh({
   coveragePath,
   targetDirs,
   cwd,
+  requireScope = 'full',
   statSync = fs.statSync,
   readdirSync = fs.readdirSync,
   existsSync = fs.existsSync,
@@ -224,10 +274,14 @@ export function isCoverageFresh({
     } catch {
       // Corrupt/unreadable stamp → fall through to the mtime heuristic.
     }
-    if (typeof stamp?.digest === 'string' && stamp.digest.length > 0) {
+    const resolved = readStampForScope(stamp, requireScope);
+    if (resolved?.scopeMismatch) {
+      return { fresh: false, reason: 'scope-mismatch' };
+    }
+    if (resolved) {
       const current = computeDigest(cwd, targetDirs);
       if (typeof current === 'string' && current.length > 0) {
-        return current === stamp.digest
+        return current === resolved.digest
           ? { fresh: true, reason: 'fresh' }
           : { fresh: false, reason: 'stale' };
       }
@@ -251,28 +305,42 @@ export function isCoverageFresh({
     : { fresh: false, reason: 'stale' };
 }
 
+/**
+ * Narrow `changedFiles` to the subset that lives under one of `targetDirs`.
+ *
+ * Both inputs are forward-slash-normalised; `targetDirs` are matched as path
+ * prefixes followed by `/`. Shared by `anyChangedUnderTargets` (the pre-push
+ * fast-path boolean) and the incremental-coverage scope resolver (Story
+ * #4981), which needs the actual file list rather than a yes/no.
+ *
+ * @param {string[]} changedFiles
+ * @param {string[]} targetDirs
+ * @returns {string[]} Forward-slash-normalised matches, in `changedFiles` order.
+ */
+export function filterFilesUnderTargets(changedFiles, targetDirs) {
+  if (!Array.isArray(changedFiles) || changedFiles.length === 0) return [];
+  if (!Array.isArray(targetDirs) || targetDirs.length === 0) return [];
+  const norms = targetDirs
+    .filter((d) => typeof d === 'string' && d.length > 0)
+    .map((d) => d.replace(/\\/g, '/').replace(/\/+$/, ''));
+  return changedFiles
+    .map((file) => String(file).replace(/\\/g, '/'))
+    .filter((f) => norms.some((dir) => f === dir || f.startsWith(`${dir}/`)));
+}
+
 /**
  * Decide whether any of `changedFiles` lives under one of `targetDirs`.
  * Used by the pre-push fast-path so we can skip the (slow) coverage capture
  * when the push touches only files outside the CRAP scoring scope.
  *
- * Both inputs are forward-slash-normalised; `targetDirs` are matched as path
- * prefixes followed by `/`. An empty changed-file list returns `false`.
+ * An empty changed-file list returns `false`.
  *
  * @param {string[]} changedFiles
  * @param {string[]} targetDirs
  * @returns {boolean}
  */
 export function anyChangedUnderTargets(changedFiles, targetDirs) {
-  if (!Array.isArray(changedFiles) || changedFiles.length === 0) return false;
-  if (!Array.isArray(targetDirs) || targetDirs.length === 0) return false;
-  const norms = targetDirs
-    .filter((d) => typeof d === 'string' && d.length > 0)
-    .map((d) => d.replace(/\\/g, '/').replace(/\/+$/, ''));
-  return changedFiles.some((file) => {
-    const f = String(file).replace(/\\/g, '/');
-    return norms.some((dir) => f === dir || f.startsWith(`${dir}/`));
-  });
+  return filterFilesUnderTargets(changedFiles, targetDirs).length > 0;
 }
 
 /**
@@ -295,11 +363,20 @@ export const COVERAGE_TIMEOUT_EXIT_CODE = 124;
  * `timeout(1)` convention exit code 124 so callers can pattern-match a
  * runaway runner without inspecting signal names.
  *
+ * `files` (Story #4981) scopes the spawn to a file list — `npm run
+ * test:coverage -- <files...>`, the standard npm convention for forwarding
+ * argv to the underlying script (which most test runners, including Node's
+ * own, treat as positional file filters). Omitted or empty means the
+ * default full-scope invocation, byte-identical to the pre-#4981 argv
+ * (AC-5); a non-empty list makes the scope observable on the emitted
+ * command line (AC-1).
+ *
  * @param {{
  *   cwd: string,
  *   timeoutMs?: number,
  *   runner?: typeof spawnSync,
  *   log?: (m: string) => void,
+ *   files?: string[] | null,
  * }} opts
  * @returns {number}
  */
@@ -308,8 +385,15 @@ export function runCapture({
   timeoutMs,
   runner = spawnSync,
   log = () => {},
+  files = null,
 } = {}) {
-  log('[coverage-capture] ▶ npm run test:coverage');
+  const scopedFiles = Array.isArray(files) && files.length > 0 ? files : null;
+  const args = [
+    'run',
+    'test:coverage',
+    ...(scopedFiles ? ['--', ...scopedFiles] : []),
+  ];
+  log(`[coverage-capture] ▶ npm ${args.join(' ')}`);
   const spawnOpts = {
     cwd,
     stdio: 'inherit',
@@ -323,7 +407,7 @@ export function runCapture({
   ) {
     spawnOpts.timeout = timeoutMs;
   }
-  const res = runner('npm', ['run', 'test:coverage'], spawnOpts);
+  const res = runner('npm', args, spawnOpts);
   // A timeout-induced kill surfaces as `signal: 'SIGKILL'` (or, on some
   // platforms, as a non-numeric status). Either signal indicates the
   // watchdog tripped — surface the GNU `timeout` convention 124 so the

package/.agents/scripts/lib/crap-baseline-index.js

@@ -0,0 +1,46 @@
+/**
+ * crap-baseline-index.js — per-file method-identity indexing over a CRAP
+ * baseline's rows (Story #4981).
+ *
+ * Split out of `crap-engine.js` (rather than added inline) so the join
+ * support lands as a new file, not a same-file expansion of the module the
+ * scoring kernel already lives in. Deliberately dependency-free: both
+ * `crap-engine.js` (which needs `methodIdentityKey` inside
+ * `finalizeMethodRowsWithBaseline`) and `baselines/kinds/crap.js` (which
+ * needs the file-scoped index) import FROM here, and this module imports
+ * from neither — the only shape that keeps the edge one-directional.
+ */
+
+/**
+ * Per-file half of the method-identity key `baselines/kinds/crap.js`'s
+ * `crapRowKey` composes with the file path (`${path}::${method}@${startLine}`).
+ * The path component is redundant once a row set is already narrowed to one
+ * file, which is exactly what `indexBaselineRowsByFile` does below.
+ *
+ * @param {{method: string, startLine: number}} row
+ * @returns {string}
+ */
+export function methodIdentityKey(row) {
+  return `${row.method}@${row.startLine}`;
+}
+
+/**
+ * Index baseline rows (accepts either the `{file, method, startLine, crap}`
+ * legacy shape `compareCrap`/`scanAndScore` use, or the on-disk `{path, ...}`
+ * shape) by file, then by `methodIdentityKey`, for O(1) per-method lookup —
+ * exactly the shape `crap-engine.js#finalizeMethodRowsWithBaseline`'s
+ * `baselineByKey` expects.
+ *
+ * @param {Array<{file?: string, path?: string, method: string, startLine: number, crap: number}>} baselineRows
+ * @returns {Map<string, Map<string, {crap: number}>>} file → (method@startLine → row)
+ */
+export function indexBaselineRowsByFile(baselineRows) {
+  const byFile = new Map();
+  for (const row of baselineRows ?? []) {
+    const file = row?.file ?? row?.path;
+    if (typeof file !== 'string' || file.length === 0) continue;
+    if (!byFile.has(file)) byFile.set(file, new Map());
+    byFile.get(file).set(methodIdentityKey(row), row);
+  }
+  return byFile;
+}