refactor(layering): one retired-paths rule for src/utils and src/replay

R14 (src-utils-retirement) and R71 (replay-ownership) were the same
path-prefix denylist instantiated in two modules. Fold both into
scripts/layering/retired-paths-policy.ts, driven by a table keyed by rule
id; ids, messages, inputs (tracked src/utils paths vs production sources)
and check.ts wiring are unchanged.

Author: thymikee

scripts/layering/check.ts

@@ -112,11 +112,10 @@ import {
 import { runtimeExecutionIntegrityViolations } from './runtime-execution-policy.ts';
 import { sourceExecutionCompatibilityViolations } from './source-execution-policy.ts';
 import { sessionResourceOwnershipViolations } from './session-resource-ownership.ts';
-import { replayOwnershipViolations } from './replay-ownership.ts';
 import { applicationLifecycleOwnershipViolations } from './application-lifecycle-policy.ts';
 import { iosSnapshotEngineOwnershipViolations } from './ios-snapshot-engine-policy.ts';
 import { providerSnapshotPresentationViolations } from './provider-snapshot-presentation-policy.ts';
-import { SRC_UTILS_RETIREMENT_RULE, srcUtilsRetirementViolations } from './src-utils-retirement.ts';
+import { RETIRED_PATH_RULES, retiredPathRuleViolations } from './retired-paths-policy.ts';
 
 const repoRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
   encoding: 'utf8',
@@ -488,7 +487,7 @@ function report(
       `Layering guard: OK — ${files.length} source files satisfy R2 and contain no ` +
         `value-import cycles (both checked globally); the ranked target spine contains no ` +
         `back-edges; the ranked spine's type-only inversions match the R6 ratchet (${Object.values(TYPE_INVERSION_BASELINE).reduce((sum, count) => sum + count, 0)} remaining); ` +
-        `${SRC_UTILS_RETIREMENT_RULE} permits no tracked paths under retired src/utils; ` +
+        `${RETIRED_PATH_RULES.R14.rule} permits no tracked paths under retired src/utils; ` +
         `all ${sessionStateFieldCount()} SessionState fields are classified and every write is ` +
         `inside its declared owner (R7); the largest type-level cycle is ${typeCycle} files ` +
         `(R9); ${daemonModularitySummary()}; ` +
@@ -611,8 +610,9 @@ export const LAYERING_RULES: Readonly<Record<LayeringRuleId, LayeringRule>> = {
       { untrackedProductionFiles: listUntrackedProductionTypeScriptFiles(repoRoot) },
     ),
   'retired-platforms-zone': () => checkRetiredPlatformsZone(listTrackedPlatformZoneFiles(repoRoot)),
-  'src-utils-retirement': (context) => srcUtilsRetirementViolations(context.trackedSrcUtilsFiles),
-  'replay-ownership': (context) => replayOwnershipViolations(context.sourceFiles),
+  'src-utils-retirement': (context) =>
+    retiredPathRuleViolations('R14', context.trackedSrcUtilsFiles),
+  'replay-ownership': (context) => retiredPathRuleViolations('R71', context.sourceFiles),
   'ios-snapshot-engine-ownership': (context) =>
     iosSnapshotEngineOwnershipViolations(
       [...context.sources].map(([path, source]) => ({ path, source })),

scripts/layering/replay-ownership.test.ts

@@ -10,52 +10,95 @@ import {
   listTrackedSrcUtilsFiles,
   listTrackedTypeScriptFiles,
 } from './tracked-sources.ts';
-import { SRC_UTILS_RETIREMENT_RULE, srcUtilsRetirementViolations } from './src-utils-retirement.ts';
+import { RETIRED_PATH_RULES, retiredPathRuleViolations } from './retired-paths-policy.ts';
 
 const repoRoot = path.resolve(import.meta.dirname, '../..');
 
-function contextWithTrackedSrcUtilsFiles(trackedSrcUtilsFiles: readonly string[]): LayeringContext {
+function contextWithFiles(
+  files: Partial<Pick<LayeringContext, 'sourceFiles' | 'trackedSrcUtilsFiles'>>,
+): LayeringContext {
   return {
     sourceFiles: [],
     sources: new Map(),
     allTypeScriptSources: new Map(),
-    trackedSrcUtilsFiles,
+    trackedSrcUtilsFiles: [],
     edges: [],
     typeCycleMembers: [],
+    ...files,
   };
 }
 
 test('R14 rejects every tracked path under the retired src/utils zone', () => {
   const trackedFiles = ['src/utils', 'src/utils/regrown.ts', 'src/utils/__fixtures__/capture.json'];
-  const violations = srcUtilsRetirementViolations(trackedFiles);
+  const violations = retiredPathRuleViolations('R14', trackedFiles);
 
-  assert.equal(SRC_UTILS_RETIREMENT_RULE, 'R14 src-utils-retirement');
+  assert.equal(RETIRED_PATH_RULES.R14.rule, 'R14 src-utils-retirement');
   assert.deepEqual(
-    violations.map(({ rule, file }) => ({ rule, file })),
-    trackedFiles.map((file) => ({ rule: SRC_UTILS_RETIREMENT_RULE, file })),
+    violations,
+    trackedFiles.map((file) => ({
+      rule: 'R14 src-utils-retirement',
+      file,
+      line: 1,
+      message: 'src/utils is retired; move this path to its owning package or command zone',
+    })),
   );
   assert.deepEqual(
-    LAYERING_RULES['src-utils-retirement'](contextWithTrackedSrcUtilsFiles(trackedFiles)),
+    LAYERING_RULES['src-utils-retirement'](
+      contextWithFiles({ trackedSrcUtilsFiles: trackedFiles, sourceFiles: trackedFiles }),
+    ),
     violations,
   );
-  for (const violation of violations) {
-    assert.match(violation.message, /src\/utils is retired; move this path/);
-  }
 });
 
 test('R14 ignores paths outside the retired zone', () => {
   assert.deepEqual(
-    srcUtilsRetirementViolations([
+    retiredPathRuleViolations('R14', [
       'src/snapshot/scroll-edge-state.ts',
       'src/utils-next.ts',
+      'src/replay/planted.ts',
       'test/fixtures/src/utils/example.json',
     ]),
     [],
   );
 });
 
+test('R71 rejects a planted production file under retired src/replay by name', () => {
+  const violations = retiredPathRuleViolations('R71', ['src/replay/planted-production-file.ts']);
+
+  assert.equal(RETIRED_PATH_RULES.R71.rule, 'R71 replay-ownership');
+  assert.deepEqual(violations, [
+    {
+      rule: 'R71 replay-ownership',
+      file: 'src/replay/planted-production-file.ts',
+      line: 1,
+      message:
+        'src/replay/ is retired; caller source acquisition belongs under src/commands/replay/ ' +
+        'and replay-test presentation belongs under src/cli/replay-test/.',
+    },
+  ]);
+  assert.deepEqual(
+    LAYERING_RULES['replay-ownership'](
+      contextWithFiles({ sourceFiles: ['src/replay/planted-production-file.ts'] }),
+    ),
+    violations,
+  );
+});
+
+test('R71 accepts the current replay owners and ignores the src/utils zone', () => {
+  assert.deepEqual(
+    retiredPathRuleViolations('R71', [
+      'src/commands/replay/script-source-bundle.ts',
+      'src/cli/replay-test/reporting.ts',
+      'src/daemon/replay-script-source.ts',
+      'src/replay-next.ts',
+      'src/utils/regrown.ts',
+    ]),
+    [],
+  );
+});
+
 test('tracked-path discovery includes top-level and nested retired paths', () => {
-  const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'src-utils-retirement-'));
+  const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'retired-paths-policy-'));
   fs.mkdirSync(path.join(repo, 'src/utils/nested'), { recursive: true });
   fs.mkdirSync(path.join(repo, 'packages/example/src'), { recursive: true });
   fs.mkdirSync(path.join(repo, 'src/snapshot'), { recursive: true });
@@ -84,18 +127,18 @@ test('tracked-path discovery includes top-level and nested retired paths', () =>
   assert.deepEqual(listTrackedPackageManifests(repo), ['packages/example/package.json']);
   assert.deepEqual(
     LAYERING_RULES['src-utils-retirement'](
-      contextWithTrackedSrcUtilsFiles(listTrackedSrcUtilsFiles(repo)),
+      contextWithFiles({ trackedSrcUtilsFiles: listTrackedSrcUtilsFiles(repo) }),
     ).map(({ rule, file }) => ({ rule, file })),
     [
-      { rule: SRC_UTILS_RETIREMENT_RULE, file: 'src/utils/café.ts' },
-      { rule: SRC_UTILS_RETIREMENT_RULE, file: 'src/utils/nested/capture.json' },
-      { rule: SRC_UTILS_RETIREMENT_RULE, file: 'src/utils/regrown.ts' },
+      { rule: 'R14 src-utils-retirement', file: 'src/utils/café.ts' },
+      { rule: 'R14 src-utils-retirement', file: 'src/utils/nested/capture.json' },
+      { rule: 'R14 src-utils-retirement', file: 'src/utils/regrown.ts' },
     ],
   );
 });
 
 test('tracked-path discovery includes an exact retired root entry', () => {
-  const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'src-utils-retirement-root-'));
+  const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'retired-paths-policy-root-'));
   fs.mkdirSync(path.join(repo, 'src'), { recursive: true });
   fs.writeFileSync(path.join(repo, 'src/utils'), 'retired root\n');
   execFileSync('git', ['init', '-q'], { cwd: repo });
@@ -104,10 +147,10 @@ test('tracked-path discovery includes an exact retired root entry', () => {
   assert.deepEqual(listTrackedSrcUtilsFiles(repo), ['src/utils']);
 });
 
-test('the committed tree has no tracked src/utils path', () => {
+test('the committed tree has no tracked path under a retired directory', () => {
   assert.deepEqual(
     LAYERING_RULES['src-utils-retirement'](
-      contextWithTrackedSrcUtilsFiles(listTrackedSrcUtilsFiles(repoRoot)),
+      contextWithFiles({ trackedSrcUtilsFiles: listTrackedSrcUtilsFiles(repoRoot) }),
     ),
     [],
   );

scripts/layering/replay-ownership.ts

@@ -0,0 +1,38 @@
+import type { LayeringViolation } from './model.ts';
+import { retiredPathViolations } from './retired-zone-policy.ts';
+
+export type RetiredPathRuleId = 'R14' | 'R71';
+
+type RetiredPathRule = Readonly<{ rule: string; prefix: string; guidance: string }>;
+
+/**
+ * Retired source directories, keyed by layering rule id. A path is rejected when it is the
+ * prefix itself or lives under it; the message names the prefix and points at the owner.
+ */
+export const RETIRED_PATH_RULES: Readonly<Record<RetiredPathRuleId, RetiredPathRule>> = {
+  R14: {
+    rule: 'R14 src-utils-retirement',
+    prefix: 'src/utils',
+    guidance: 'move this path to its owning package or command zone',
+  },
+  R71: {
+    rule: 'R71 replay-ownership',
+    prefix: 'src/replay/',
+    guidance:
+      'caller source acquisition belongs under src/commands/replay/ and replay-test ' +
+      'presentation belongs under src/cli/replay-test/.',
+  },
+};
+
+export function retiredPathRuleViolations(
+  id: RetiredPathRuleId,
+  files: readonly string[],
+): LayeringViolation[] {
+  const { rule, prefix, guidance } = RETIRED_PATH_RULES[id];
+  return retiredPathViolations(
+    files,
+    prefix.replace(/\/$/, ''),
+    rule,
+    `${prefix} is retired; ${guidance}`,
+  );
+}