@starci/hfs 2.0.2 → 4.0.0

package/runtime/scripts/lib/hfs-rules/contract.mjs

@@ -1,9 +1,7 @@
-// contract.mjs - HFS_CONTRACT_SNAPSHOT_DRIFT (R23): the contract is committed and the front-end copy equals the back end's.
-//   back end   a repository with a GraphQL transport commits `contracts/<app>/schema.graphql` for each api app, and an api app with
-//              an operation table commits `contracts/<app>/openapi.json`
-//   front end  every `apps/<app>/src/modules/api/contract/<be-app>.{graphql,json}` is hash-equal to the sibling back end's
-//              `contracts/<be-app>/schema.graphql` (openapi.json for .json); hfs.json `stacks` names the sibling
-//              repository, and a sibling that is not checked out is reported (info), not compared
+// contract.mjs - HFS_CONTRACT_SNAPSHOT_DRIFT (R23): the back end commits its contract.
+//   a be side with a GraphQL transport commits `contracts/<app>/schema.graphql` for each api app, and an api app with an operation table
+//   commits `contracts/<app>/openapi.json`. The fe side of the same app reads those snapshots where they are (`be/contracts/`, the one
+//   cross-side read of hfs.json sides.fe.reads) for its codegen: there is no copy to keep equal.
 // The snapshots are generated by `npm run contract:emit` (`hfs emit-contracts`, packages/hfs/emit/contracts.mjs): printSchema of the
 // resolvers the app root composes, and the OpenAPI 3.1 document of the typed operation table `apps/<app>/src/operations.ts`.
 // That the committed snapshot equals what the app emits now is contractEmitFindings (full pass only, never --fast): it emits every
@@ -17,7 +15,6 @@ import { safeRemoveTree } from '../safe-remove.mjs';
 
 export const CONTRACT_SNAPSHOT_DRIFT = 'HFS_CONTRACT_SNAPSHOT_DRIFT';
 export const GRAPHQL_TRANSPORT_SLOT = 'be.transport.graphql';
-const COPY = /^apps\/([^/]+)\/src\/modules\/api\/contract\/([^/]+)\.(graphql|json)$/;
 const SNAPSHOT_OF = { graphql: 'schema.graphql', json: 'openapi.json' };
 
 /** sha256 of a file's text with line endings folded, or null when it cannot be read. */
@@ -25,42 +22,18 @@ export function contractHash(file) {
   try { return createHash('sha256').update(fs.readFileSync(file, 'utf8').replace(/\r\n/g, '\n')).digest('hex'); } catch { return null; }
 }
 
-/** The findings of R23 for the repository at `repoRoot`. `stacks` is hfs.json's sibling back-end path (front end only). */
-export function contractFindings({ repoRoot, files, repo, resolver, stacks }) {
+/** The findings of R23 for the be side at `repoRoot` (a side of another profile has none). */
+export function contractFindings({ files, repo, resolver }) {
   const findings = [];
-  if (repo.profile === 'be') {
-    const serves = files.some((file) => resolver.classifyPath(file).slot === GRAPHQL_TRANSPORT_SLOT);
-    const tracked = new Set(files);
-    for (const app of repo.apps.filter((a) => a.kind === 'api')) {
-      const operations = `contracts/${app.name}/${SNAPSHOT_OF.json}`;
-      if (tracked.has(`apps/${app.name}/src/operations.ts`) && !tracked.has(operations)) findings.push(found(CONTRACT_SNAPSHOT_DRIFT, operations, `${app.name} declares an operation table (apps/${app.name}/src/operations.ts) but ${operations} is not committed; declare be.contract.openapi in hfs.json optionalSlots, run \`npm run contract:emit\` and commit the snapshot`, { app: app.name }));
-      if (!serves) continue;
-      const snapshot = `contracts/${app.name}/${SNAPSHOT_OF.graphql}`;
-      if (!tracked.has(snapshot)) findings.push(found(CONTRACT_SNAPSHOT_DRIFT, snapshot, `${app.name} serves GraphQL but ${snapshot} is not committed; declare be.contract.graphql in hfs.json optionalSlots, run \`npm run contract:emit\` and commit the snapshot`, { app: app.name }));
-    }
-    return findings;
-  }
-  for (const file of files) {
-    const match = COPY.exec(file);
-    if (!match) continue;
-    const [, app, beApp, ext] = match;
-    if (!stacks) {
-      findings.push(found(CONTRACT_SNAPSHOT_DRIFT, file, `${file} is a contract copy but hfs.json names no sibling back end (stacks), so it cannot be compared with the back end's snapshot`, { app }));
-      continue;
-    }
-    const sibling = path.resolve(repoRoot, stacks);
-    if (!fs.existsSync(sibling)) {
-      findings.push(found(CONTRACT_SNAPSHOT_DRIFT, file, `${file} was not compared: the sibling back end ${stacks} is not checked out here`, { app, level: 'info' }));
-      continue;
-    }
-    const snapshot = `contracts/${beApp}/${SNAPSHOT_OF[ext]}`;
-    const theirs = contractHash(path.join(sibling, snapshot));
-    if (theirs === null) {
-      findings.push(found(CONTRACT_SNAPSHOT_DRIFT, file, `${stacks}/${snapshot} does not exist, so ${file} copies nothing; the back end commits its contract first`, { app, snapshot }));
-      continue;
-    }
-    const ours = contractHash(path.join(repoRoot, file));
-    if (ours !== theirs) findings.push(found(CONTRACT_SNAPSHOT_DRIFT, file, `${file} (${String(ours).slice(0, 12)}) differs from ${stacks}/${snapshot} (${theirs.slice(0, 12)}); run \`npm run contract:pull\``, { app, snapshot }));
+  if (repo.profile !== 'be') return findings;
+  const serves = files.some((file) => resolver.classifyPath(file).slot === GRAPHQL_TRANSPORT_SLOT);
+  const tracked = new Set(files);
+  for (const app of repo.apps.filter((a) => a.kind === 'api')) {
+    const operations = `contracts/${app.name}/${SNAPSHOT_OF.json}`;
+    if (tracked.has(`apps/${app.name}/src/operations.ts`) && !tracked.has(operations)) findings.push(found(CONTRACT_SNAPSHOT_DRIFT, operations, `${app.name} declares an operation table (apps/${app.name}/src/operations.ts) but ${operations} is not committed; declare be.contract.openapi in hfs.json sides.be.optionalSlots, run \`npm run contract:emit\` and commit the snapshot`, { app: app.name }));
+    if (!serves) continue;
+    const snapshot = `contracts/${app.name}/${SNAPSHOT_OF.graphql}`;
+    if (!tracked.has(snapshot)) findings.push(found(CONTRACT_SNAPSHOT_DRIFT, snapshot, `${app.name} serves GraphQL but ${snapshot} is not committed; declare be.contract.graphql in hfs.json sides.be.optionalSlots, run \`npm run contract:emit\` and commit the snapshot`, { app: app.name }));
   }
   return findings;
 }

package/runtime/scripts/lib/hfs-rules/frontend.mjs

@@ -1,12 +1,13 @@
-// frontend.mjs - the front-end tree checks of hfs check, per app (`apps/<app>`, kind next):
-//   FE_WIRE_GENERATED (R52)     wire types come from the contract copy: an app that keeps `modules/api/contract/*` declares the
-//                               `codegen` script and runs it before `build` and `typecheck` (prebuild, pretypecheck), and its
-//                               generated types on disk (`modules/api/__generated__/`, never tracked) are not older than the copy
-//   FE_I18N_PLACEMENT (R59)     next-intl with the `[locale]` segment: `next-intl` is a dependency (of the app, the root or the shared
-//                               i18n package under `packages/`), every route file sits under
-//                               `src/app/[locale]/` (the root redirect page, global-error and health probes excepted), locale
-//                               routing is `src/proxy.ts` and never `middleware.ts`, and the default locale's catalog `vi.json` exists
+// frontend.mjs - the front-end tree checks of hfs check. Per app of the fe side (`apps/<app>`, kind next, side-relative paths):
+//   FE_I18N_PLACEMENT (R59)     next-intl with the `[locale]` segment: every route file sits under `src/app/[locale]/` (the root
+//                               redirect page, global-error and health probes excepted), locale routing is `src/proxy.ts` and never
+//                               `middleware.ts`, and the default locale's catalog `vi.json` exists
 //   FE_I18N_CATALOG (R60)       every `modules/i18n/messages/<locale>.json` has the same key set
+// Over the whole app (the root scope, app-relative paths: the one package.json and the be contract snapshots sit outside the fe side):
+//   FE_WIRE_GENERATED (R52)     wire types come from the be contract snapshots the fe side reads in place (its declared reads,
+//                               `be/contracts/`): the root package.json declares the `codegen` script, and each fe app's generated
+//                               types on disk (`modules/api/__generated__/`, never tracked) are not older than any snapshot
+//   FE_I18N_PLACEMENT (R59)     `next-intl` is a dependency of the root package.json or of a shared i18n package under fe/packages/
 // The files each app must hold (routing.ts, navigation.ts, request.ts, messages/, the [locale] layout) are the slot manifest's requires
 // (HFS_SLOT_REQUIRED_MISSING); which source may hold display text and how copy resolves is eslint-fe's.
 import fs from 'node:fs';
@@ -46,42 +47,35 @@ function newestBelow(dir) {
 
 const scriptsOf = (repoRoot, file) => readJson(repoRoot, file)?.scripts ?? {};
 
-function wireFindings({ repoRoot, app, tracked }) {
-  const base = `apps/${app}`;
-  const copies = tracked.filter((file) => file.startsWith(`${base}/src/modules/api/contract/`));
-  if (!copies.length) return [];
+/** R52 over the app: the codegen script of the root and the age of each fe app's generated types against the be snapshots. */
+function wireFindings({ repoRoot, files, apps, reads }) {
+  const snapshots = files.filter((file) => reads.some((read) => file.startsWith(read)));
+  if (!snapshots.length) return [];
   const findings = [];
-  const manifest = `${base}/package.json`;
-  const scripts = scriptsOf(repoRoot, manifest);
-  const rootScripts = scriptsOf(repoRoot, 'package.json');
-  // A root script that only fans out to the workspaces (`npm run x --workspaces`, the managed FE root) is not this app's
-  // script: the app's own manifest must declare it.
-  const delegates = (script) => /(?:^|\s)--workspaces?(?:\s|=|$)/.test(String(script ?? ''));
-  const wired = (name) => scripts[name] ?? (delegates(rootScripts[name]) ? undefined : rootScripts[name]);
-  if (typeof wired('codegen') !== 'string') findings.push(found(WIRE_GENERATED, manifest, `${app} keeps a contract copy but declares no \`codegen\` script; wire types are generated from the copy, never typed by hand`, { app }));
-  else for (const hook of ['prebuild', 'pretypecheck']) {
-    if (!/\bcodegen\b/.test(String(wired(hook) ?? ''))) findings.push(found(WIRE_GENERATED, manifest, `${app} does not run codegen in \`${hook}\`; generate the wire types before build and typecheck`, { app, script: hook }));
-  }
-  const generated = `${base}/src/modules/api/__generated__`;
-  const built = newestBelow(path.join(repoRoot, generated));
-  if (built !== null) {
-    for (const copy of copies) {
+  if (typeof scriptsOf(repoRoot, 'package.json').codegen !== 'string') findings.push(found(WIRE_GENERATED, 'package.json', `the app keeps contract snapshots (${reads.join(', ')}) but its package.json declares no \`codegen\` script; wire types are generated from the snapshots, never typed by hand`));
+  for (const app of apps) {
+    const generated = `fe/apps/${app}/src/modules/api/__generated__`;
+    const built = newestBelow(path.join(repoRoot, generated));
+    if (built === null) continue;
+    for (const snapshot of snapshots) {
       let changed;
-      try { changed = fs.statSync(path.join(repoRoot, copy)).mtimeMs; } catch { continue; }
-      if (built + STALE_MS < changed) findings.push(found(WIRE_GENERATED, generated, `${generated} is older than ${copy}; run \`npm run codegen\` so the wire types match the contract copy`, { app, copy }));
+      try { changed = fs.statSync(path.join(repoRoot, snapshot)).mtimeMs; } catch { continue; }
+      if (built + STALE_MS < changed) findings.push(found(WIRE_GENERATED, generated, `${generated} is older than ${snapshot}; run \`npm run codegen\` so the wire types match the contract snapshot`, { app, snapshot }));
     }
   }
   return findings;
 }
 
+/** R59 over the app: next-intl is a dependency of the one package.json or of a shared fe/packages/* manifest. */
+function intlDependencyFindings({ repoRoot, files }) {
+  const declares = (file) => { const pkg = readJson(repoRoot, file); return pkg ? ['dependencies', 'devDependencies'].some((section) => pkg[section]?.['next-intl'] !== undefined) : false; };
+  const shared = files.filter((file) => /^fe\/packages\/[^/]+\/package\.json$/.test(file));
+  return ['package.json', ...shared].some(declares) ? [] : [found(I18N_PLACEMENT, 'package.json', 'the app does not depend on next-intl (nor does a shared fe package); every fe app uses next-intl with the [locale] segment')];
+}
+
 function placementFindings({ repoRoot, app, tracked }) {
   const base = `apps/${app}`;
   const findings = [];
-  const declares = (file) => { const pkg = readJson(repoRoot, file); return pkg ? ['dependencies', 'devDependencies'].some((section) => pkg[section]?.['next-intl'] !== undefined) : false; };
-  const manifest = `${base}/package.json`;
-  // The next-intl stack is written once per repository: in the app, or in the shared `packages/<family>-i18n` the apps call.
-  const shared = tracked.filter((file) => /^packages\/[^/]+\/package\.json$/.test(file));
-  if (tracked.includes(manifest) && ![manifest, 'package.json', ...shared].some(declares)) findings.push(found(I18N_PLACEMENT, manifest, `${app} does not depend on next-intl (nor does the root or a shared package); every app uses next-intl with the [locale] segment`, { app }));
   if (!tracked.includes(`${base}/src/proxy.ts`)) findings.push(found(I18N_PLACEMENT, `${base}/src/proxy.ts`, `${app} has no src/proxy.ts; locale routing lives in proxy.ts`, { app }));
   for (const file of tracked.filter((f) => new RegExp(`^${base}/src/middleware\.[cm]?[jt]s$`).test(f))) findings.push(found(I18N_PLACEMENT, file, `${file} is a middleware file; Next 16 routes through src/proxy.ts`, { app }));
   const appDir = `${base}/src/app/`;
@@ -118,7 +112,14 @@ function catalogFindings({ repoRoot, app, tracked }) {
   return findings;
 }
 
-/** The front-end tree findings of R52, R59 and R60 for every `next` app of the repository. */
+/** The fe side's tree findings of R59 and R60 for every `next` app; `repoRoot` is the fe side folder, `files` side-relative. */
 export function frontendFindings({ repoRoot, files, repo }) {
-  return repo.apps.filter((a) => a.kind === 'next').flatMap((a) => [wireFindings, placementFindings, catalogFindings].flatMap((check) => check({ repoRoot, app: a.name, tracked: files })));
+  return repo.apps.filter((a) => a.kind === 'next').flatMap((a) => [placementFindings, catalogFindings].flatMap((check) => check({ repoRoot, app: a.name, tracked: files })));
+}
+
+/** The app's front-end findings that read the root (R52, R59's dependency); `repoRoot` is the app root, `files` app-relative. */
+export function appFrontendFindings({ repoRoot, files, repo }) {
+  const apps = repo.sides.fe.apps.filter((a) => a.kind === 'next').map((a) => a.name);
+  // The snapshots are the paths the fe side declares it reads of the be side (hfs.json sides.fe.reads: be/contracts/).
+  return [...wireFindings({ repoRoot, files, apps, reads: repo.sides.fe.reads }), ...intlDependencyFindings({ repoRoot, files })];
 }

package/runtime/scripts/lib/hfs-rules/peer-integrations.mjs

@@ -0,0 +1,44 @@
+// peer-integrations.mjs - HFS_PEER_INTEGRATION_MISSING (R111): an app declares the runtime peer a driver integration needs.
+// The catalog knowledge/hfs/peer-integrations.yaml says "if the app depends on every package of `when` (at the named major,
+// when one is named), it must declare `requires`". npm does not install such a peer for the integration, the type checker and
+// the unit specs never load it, and the api fails only when it boots (@nestjs/apollo on @nestjs/platform-express 11, Express 5,
+// needs @as-integrations/express5). The app root package.json is the one manifest of both sides: a `when` package counts in its
+// dependencies or devDependencies, the peer counts only in its dependencies (a production install omits devDependencies).
+import fs from 'node:fs';
+import { parseYaml } from '../../../engine/yaml.mjs';
+import { found, readJson } from './read.mjs';
+
+export const PEER_INTEGRATION_MISSING = 'HFS_PEER_INTEGRATION_MISSING';
+const MANIFEST = 'package.json';
+const CATALOG_FILE = new URL('../../../knowledge/hfs/peer-integrations.yaml', import.meta.url);
+
+/** The pairs of the catalog: [{ id, when: [{ package, major? }], requires, why }]. */
+export function peerIntegrationPairs() {
+  const catalog = parseYaml(fs.readFileSync(CATALOG_FILE, 'utf8'));
+  if (catalog?.schema !== 'starci/hfs-peer-integrations@1' || !Array.isArray(catalog.pairs)) throw new Error('knowledge/hfs/peer-integrations.yaml is not a starci/hfs-peer-integrations@1 catalog');
+  return catalog.pairs;
+}
+
+/** The major a dependency spec allows (`11.2.5`, `^11.0.0`, `~11.1`, `>=11 <12`), or null when the spec names none (a tag, a link, `*`). */
+export function majorOf(spec) {
+  const match = /^\s*(?:[\^~]|>=?|=)?\s*v?(\d+)(?:\.|\s|$)/.exec(String(spec));
+  return match ? Number(match[1]) : null;
+}
+
+/** The findings of R111 over the app root package.json of `repoRoot`; `pairs` defaults to the catalog. */
+export function peerIntegrationFindings({ repoRoot, files, pairs = peerIntegrationPairs() }) {
+  if (!files.includes(MANIFEST)) return [];
+  const pkg = readJson(repoRoot, MANIFEST);
+  if (!pkg) return [];
+  const runtime = pkg.dependencies ?? {};
+  const declared = { ...(pkg.devDependencies ?? {}), ...runtime };
+  const findings = [];
+  for (const pair of pairs) {
+    const applies = pair.when.every((entry) => typeof declared[entry.package] === 'string' && (entry.major === undefined || majorOf(declared[entry.package]) === entry.major));
+    if (!applies || typeof runtime[pair.requires] === 'string') continue;
+    const because = pair.when.map((entry) => `${entry.package} ${declared[entry.package]}`).join(' with ');
+    const where = typeof declared[pair.requires] === 'string' ? ` (it is only a devDependency, which a production install omits)` : '';
+    findings.push(found(PEER_INTEGRATION_MISSING, MANIFEST, `${MANIFEST} depends on ${because} but does not declare ${pair.requires} in its dependencies${where}: ${pair.why.trim()} Add ${pair.requires} to the dependencies.`, { pair: pair.id, requires: pair.requires }));
+  }
+  return findings;
+}

package/runtime/scripts/lib/hfs-rules/pipeline.mjs

@@ -1,8 +1,9 @@
-// pipeline.mjs - HFS_CI_MISSING_CANON (R13): CI runs the pinned `hfs check`; pre-push runs typecheck and lint.
-//   .github/workflows/ci.yml   a `run:` step that runs `hfs check` as a whole (not `--fast`): `npx hfs check`, `npx @starci/hfs[@<version>]
-//                              check`, or `npm run <script>` of the root package.json whose command is `hfs check`; a version named in
-//                              the step is the @starci/hfs pin of canon-pins.yaml (an installed one is pinned by the pin check, R15)
-//   .husky/pre-push            `npm run typecheck` and `npm run lint:check`, each on a line of its own
+// pipeline.mjs - HFS_CI_MISSING_CANON (R13): CI runs the pinned `hfs lint`; pre-push runs typecheck and lint.
+//   .github/workflows/ci.yml   a `run:` step that runs `hfs lint` (the one lint entry: eslint, the repository check, stylelint): `npx hfs lint`,
+//                              `npx @starci/hfs[@<version>] lint`, or `npm run <script>` of the root package.json whose command runs `hfs lint`
+//                              (`npm run lint`, arguments after `--` allowed); a version named in the step is the @starci/hfs pin of
+//                              canon-pins.yaml (an installed one is pinned by the pin check, R15)
+//   .husky/pre-push            `npm run typecheck` and `npm run lint`, each on a line of its own
 // A missing file is the slot manifest's finding (HFS_SLOT_REQUIRED_MISSING); a file that is present and lacks the step is this rule's.
 // The redirect of `core.hooksPath` away from husky is the architecture machine's (HFS_HOOKS_PATH_REDIRECTED).
 import { found, readJson, readText } from './read.mjs';
@@ -12,9 +13,8 @@ export const CI_FILE = '.github/workflows/ci.yml';
 export const PRE_PUSH_FILE = '.husky/pre-push';
 export const hfsPackage = '@starci/hfs';
 const RUN_LINE = /^\s*(?:-\s+)?run:\s*(.+?)\s*$/;
-const HFS_CHECK = /^(?:npx\s+(?:--no-install\s+|-y\s+)?)?(?:@starci\/hfs|hfs)(?:@(\S+))?\s+check(\s.*)?$/;
+const HFS_LINT = /^(?:npx\s+(?:--no-install\s+|-y\s+)?)?(?:@starci\/hfs|hfs)(?:@(\S+))?\s+lint(\s.*)?$/;
 const NPM_RUN = /^npm run ([\w:.-]+)(?:\s+--\s+(.*))?$/;
-const FAST = /(^|\s)--fast(\s|$)/;
 
 const commandsOf = (text) => text.split(/\r?\n/).map((line) => RUN_LINE.exec(line)?.[1]).filter(Boolean).map((command) => command.replace(/^["']|["']$/g, ''));
 
@@ -33,17 +33,16 @@ export function pipelineFindings({ repoRoot, files, pins }) {
   const ci = files.includes(CI_FILE) ? readText(repoRoot, CI_FILE) : null;
   if (ci !== null) {
     const scripts = readJson(repoRoot, 'package.json')?.scripts ?? {};
-    const checks = commandsOf(ci).map((command) => HFS_CHECK.exec(expanded(command, scripts))).filter(Boolean);
-    const whole = checks.filter((match) => !FAST.test(match[2] ?? ''));
-    if (!whole.length) findings.push(found(CI_MISSING_CANON, CI_FILE, `${CI_FILE} has no step that runs \`hfs check\` (\`npx hfs check\`, or an npm script that is exactly that); CI must run the whole pinned hfs check, not --fast`, { step: 'hfs check' }));
-    else if (pinned && !whole.some((match) => match[1] === undefined || match[1] === pinned)) {
-      findings.push(found(CI_MISSING_CANON, CI_FILE, `${CI_FILE} runs hfs check at ${whole[0][1]}, but ${hfsPackage} is pinned at ${pinned}; run the pinned version`, { step: 'hfs check', pinned }));
+    const lints = commandsOf(ci).flatMap((command) => expanded(command, scripts).split(/\s*&&\s*/)).map((command) => HFS_LINT.exec(command)).filter(Boolean);
+    if (!lints.length) findings.push(found(CI_MISSING_CANON, CI_FILE, `${CI_FILE} has no step that runs \`hfs lint\` (\`npm run lint\`, or \`npx hfs lint\`); CI runs the one lint entry, which includes the repository check`, { step: 'hfs lint' }));
+    else if (pinned && !lints.some((match) => match[1] === undefined || match[1] === pinned)) {
+      findings.push(found(CI_MISSING_CANON, CI_FILE, `${CI_FILE} runs hfs lint at ${lints[0][1]}, but ${hfsPackage} is pinned at ${pinned}; run the pinned version`, { step: 'hfs lint', pinned }));
     }
   }
   const prePush = files.includes(PRE_PUSH_FILE) ? readText(repoRoot, PRE_PUSH_FILE) : null;
   if (prePush !== null) {
     const lines = prePush.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith('#'));
-    for (const step of ['typecheck', 'lint:check']) {
+    for (const step of ['typecheck', 'lint']) {
       if (!runsStep(lines, step)) findings.push(found(CI_MISSING_CANON, PRE_PUSH_FILE, `${PRE_PUSH_FILE} does not run \`npm run ${step}\`; pre-push runs typecheck and lint`, { step }));
     }
   }

package/runtime/scripts/lib/hfs-rules/proof-commands.mjs

@@ -4,13 +4,13 @@
 // keeps one goes quietly false (nivo-backend, 2026-09-30: `node --test scripts/provision-keycloak.spec.mjs` after the script was deleted).
 // Every argument of the command that is a repository-relative file path (an extension, no glob, no variable, not absolute, not a `..`
 // path into another repository) must be a tracked file or an existing one; a path an ignored slot owns (dist/, coverage/) is a build
-// product and is not judged. One finding per record, kind and missing path. A back end's `.starciwork` also holds the records of the
-// implementations that live in another repository (`repository: nivo-fe`); their commands run there, so only a record of this repository
-// (its `repository` names it, or names none) is judged.
+// product and is not judged. One finding per record, kind and missing path. The `.starciwork` of an app sits at the app root, and a
+// record names the side its implementation lives in (`repository: be` or `repository: fe`, the repositories of workspace.yaml, the
+// sides of hfs.json); a proof command runs from the app root, so every record of a side, or naming none, is judged against the app root.
+// A record naming a repository that is not a side of this app runs elsewhere and is not judged.
 import fs from 'node:fs';
 import path from 'node:path';
 import { parseYaml } from '../../../engine/yaml.mjs';
-import { repositoryName } from '../repo-identity.mjs';
 import { found, readText } from './read.mjs';
 
 export const PROOF_COMMAND_FILE_MISSING = 'HFS_PROOF_COMMAND_FILE_MISSING';
@@ -39,18 +39,21 @@ function proofCommands(record) {
   return Object.entries(demands).flatMap(([kind, demand]) => (typeof demand?.command === 'string' ? [{ kind, command: demand.command }] : []));
 }
 
-/** The findings of R105 over the tracked paths `files` of the repository at `repoRoot`; `resolver` names the ignored slots. */
-export function proofCommandFindings({ repoRoot, files, resolver }) {
+/**
+ * The findings of R105 over the tracked paths `files` of the app at `repoRoot`; `resolver` names the ignored slots and `sides` the side
+ * names of hfs.json (be, fe), the repositories a record of this app names.
+ */
+export function proofCommandFindings({ repoRoot, files, resolver, sides }) {
   const findings = [];
   const tracked = new Set(files);
-  const own = repositoryName(repoRoot);
+  const own = new Set(sides);
   for (const file of files) {
     if (!RECORD.test(file)) continue;
     const text = readText(repoRoot, file);
     if (text === null || !text.includes('requiresProof')) continue;
     let record;
     try { record = parseYaml(text); } catch { continue; }
-    if (typeof record?.repository === 'string' && record.repository !== own) continue;
+    if (typeof record?.repository === 'string' && !own.has(record.repository)) continue;
     for (const { kind, command } of proofCommands(record)) {
       for (const target of commandFiles(command)) {
         if (tracked.has(target) || fs.existsSync(path.join(repoRoot, target))) continue;

package/runtime/scripts/lib/hfs-rules/spec-placement.mjs

@@ -2,8 +2,6 @@
 //   - a unit spec is `<name>.service.spec.ts` beside its service, in a slot whose `tests` is `unit-beside` (the slot and the lint rule
 //     `unit-test-colocated` judge the name);
 //   - integration, e2e and contract specs are `src/tests/{integration,e2e,contract}/...`, the slots whose `tests` is `e2e`;
-//   - an app's own folder (`apps/<app>/src/`, the slots that name an `appKind`) holds the app's composition spec, which the architecture
-//     machine's app-composition check judges.
 // Every other tracked `*.spec.*`, `*.test.*` or `*-spec.*` file is a finding, `scripts/` and `tools/` included: an operational script
 // carries no spec, and a spec that guards one moves into a layer or goes. A file no slot owns (`tools/x.spec.ts`) is judged too, so the
 // finding names the rule rather than only the missing slot. Which folder is a layer is read from the slot manifest, never spelled here.
@@ -23,7 +21,7 @@ export function specPlacementFindings({ files, resolver }) {
     if (!isSpecFile(file) || file.includes('node_modules/')) continue;
     const classified = resolver.classifyPath(file);
     const slot = classified.status === 'owned' ? resolver.slot(classified.slot) : null;
-    if (slot && (TEST_SLOT_TESTS.has(slot.tests) || slot.appKind !== undefined)) continue;
+    if (slot && TEST_SLOT_TESTS.has(slot.tests)) continue;
     const where = slot ? `slot ${slot.id}` : 'no slot';
     findings.push(found(SPEC_PLACEMENT, file, `${file} is a spec outside the test layers (${where}); a unit spec is <name>.service.spec.ts beside its service and an integration, e2e or contract spec sits under src/tests/{integration,e2e,contract}; an operational script or a tool carries no spec`));
   }