@boxxy/rules 0.1.0 → 0.1.3

package/README.md

@@ -11,8 +11,9 @@
   </p>
 </div>
 
-boxxy's rules loader. `loadRules` checks a rules checkout's `rules.yaml` against the concepts boxxy
-compiles in, builds the plug-in registry, and gives the loaded rules a version.
+boxxy's rules loader. `loadRules` checks a rules checkout's `rules.yaml` against the concepts and
+the phase kinds boxxy compiles in, builds the plug-in registry, and gives the loaded rules a
+version. [`example/`](./example/) holds the v1 rules file and its prompts.
 
 The package does no I/O: the caller reads the checkout and passes in its commit hash and its files'
 bytes.
@@ -30,12 +31,12 @@ The package runs on [Bun](https://bun.sh) 1.3 or newer.
 ## Features
 
 - `loadRules`, which returns the loaded rules, or every rejection with its file, its path in the
-  file and its reason ([rules for slice 1](../../docs/design/boxxy/slice-1.md#rules-for-slice-1)).
-- The rules version, a content hash of the commit, the files the loader read and each concept pin
-  ([the rules version](../../docs/design/boxxy/rules.md#the-rules-version)).
+  file and its reason ([the pipeline](../../docs/design/boxxy/v1.md#the-pipeline)).
+- The rules version, a content hash of the commit, the files the loader read, each concept pin and
+  each phase kind ([the rules version](../../docs/design/boxxy/rules.md#the-rules-version)).
 
 ## Documentation
 
 The [rules design](../../docs/design/boxxy/rules.md) says why rules live in git, and
-[`01-registries.ts`](../../docs/design/boxxy/sketches/01-registries.ts) gives the shape of the
-loaded rules.
+[`02-types.ts`](../../docs/design/boxxy/sketches/v1/core/02-types.ts) gives the shape of the loaded
+rules.

package/dist/dry-run/dry-run-rules.d.ts

@@ -0,0 +1,9 @@
+import type { LoadedRules } from '@boxxy/model';
+import type { DryRunItem, RulesDryRunLine } from '../types.ts';
+interface DryRunInput {
+    readonly current: LoadedRules;
+    readonly proposed: LoadedRules;
+    readonly items: readonly DryRunItem[];
+}
+export declare function dryRunRules(input: DryRunInput): RulesDryRunLine[];
+export {};

package/dist/index.d.ts

@@ -1 +1,4 @@
-export { loadRules } from './load-rules.ts';
+export { rulesFileName } from './constants.ts';
+export { loadRules } from './loading/load-rules.ts';
+export { dryRunRules } from './dry-run/dry-run-rules.ts';
+export type { DryRunItem, RulesDryRunLine } from './types.ts';

package/dist/loading/collect-filter-rejections.d.ts

@@ -0,0 +1,3 @@
+import type { LoadRejection, Registry } from '@boxxy/model';
+import type { ParsedRulesFile } from '../parse/rules-file-schema.ts';
+export declare function collectFilterRejections(file: ParsedRulesFile, registry: Registry): LoadRejection[];

package/dist/loading/collect-recipe-rejections.d.ts

@@ -0,0 +1,3 @@
+import type { LoadRejection } from '@boxxy/model';
+import type { ParsedRulesFile } from '../parse/rules-file-schema.ts';
+export declare function collectRecipeRejections(file: ParsedRulesFile): LoadRejection[];

package/dist/loading/collect-step-rejections.d.ts

@@ -0,0 +1,3 @@
+import type { LoadRejection, PhaseKind, PhaseName } from '@boxxy/model';
+import type { ParsedRulesFile } from '../parse/rules-file-schema.ts';
+export declare function collectStepRejections(file: ParsedRulesFile, phases: ReadonlyMap<PhaseName, PhaseKind>): LoadRejection[];

package/dist/{load-rules.d.ts → loading/load-rules.d.ts}

@@ -1,4 +1,4 @@
-import type { Concept, ConceptName, ConceptPin, LoadResult } from '@boxxy/model';
+import type { Concept, ConceptName, ConceptPin, LoadResult, PhaseKind } from '@boxxy/model';
 interface LoadRulesInput {
     readonly checkout: {
         readonly commit: string;
@@ -6,6 +6,7 @@ interface LoadRulesInput {
     };
     readonly concepts: readonly Concept[];
     readonly pins: ReadonlyMap<ConceptName, ConceptPin>;
+    readonly phases: readonly PhaseKind[];
 }
 export declare function loadRules(input: LoadRulesInput): LoadResult;
 export {};

package/dist/loading/to-filter.d.ts

@@ -0,0 +1,3 @@
+import type { Filter } from '@boxxy/model';
+import type { ParsedRulesFile } from '../parse/rules-file-schema.ts';
+export declare function toFilter(filter: ParsedRulesFile['pools'][number]['takes']): Filter;

package/dist/parse/rules-file-schema.d.ts

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+declare const stepSchema: z.ZodObject<{
+    phase: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+    maxAttempts: z.ZodInt;
+    timeoutMinutes: z.ZodOptional<z.ZodInt>;
+    on: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"next">, z.ZodLiteral<"again">, z.ZodObject<{
+        to: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+        max: z.ZodExactOptional<z.ZodInt>;
+        resume: z.ZodExactOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        end: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        hold: z.core.$ZodBranded<z.ZodString, "RulesHoldReason", "out">;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export declare const rulesFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    concepts: z.ZodArray<z.ZodTemplateLiteral<`${string}@${number}`>>;
+    pipelines: z.ZodRecord<z.core.$ZodBranded<z.ZodString, "PipelineName", "out">, z.ZodArray<z.ZodObject<{
+        phase: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+        maxAttempts: z.ZodInt;
+        timeoutMinutes: z.ZodOptional<z.ZodInt>;
+        on: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"next">, z.ZodLiteral<"again">, z.ZodObject<{
+            to: z.core.$ZodBranded<z.ZodString, "PhaseName", "out">;
+            max: z.ZodExactOptional<z.ZodInt>;
+            resume: z.ZodExactOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            end: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            hold: z.core.$ZodBranded<z.ZodString, "RulesHoldReason", "out">;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>>;
+    kinds: z.ZodRecord<z.core.$ZodBranded<z.ZodString, "ItemKindName", "out">, z.ZodObject<{
+        pipeline: z.core.$ZodBranded<z.ZodString, "PipelineName", "out">;
+        recipes: z.ZodRecord<z.ZodString, z.core.$ZodBranded<z.ZodString, "RecipeName", "out">>;
+    }, z.core.$strict>>;
+    skills: z.ZodOptional<z.ZodObject<{
+        source: z.core.$ZodBranded<z.ZodString, "RepoName", "out">;
+        ref: z.core.$ZodBranded<z.ZodString, "CommitSha", "out">;
+    }, z.core.$strict>>;
+    relationTypes: z.ZodArray<z.core.$ZodBranded<z.ZodString, "RelationTypeName", "out">>;
+    recipes: z.ZodRecord<z.core.$ZodBranded<z.ZodString, "RecipeName", "out">, z.ZodObject<{
+        agent: z.ZodString;
+        model: z.ZodString;
+        effort: z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            xhigh: "xhigh";
+        }>;
+        prompt: z.ZodString;
+        source: z.core.$ZodBranded<z.ZodString, "SourceName", "out">;
+        skills: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    limits: z.ZodArray<z.ZodObject<{
+        name: z.core.$ZodBranded<z.ZodString, "LimitName", "out">;
+        max: z.ZodInt;
+        counts: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    }, z.core.$strict>>;
+    pools: z.ZodArray<z.ZodObject<{
+        name: z.core.$ZodBranded<z.ZodString, "PoolName", "out">;
+        slots: z.ZodOptional<z.ZodNever>;
+        takes: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+        order: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>]>>;
+    }, z.core.$strict>>;
+    lead: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>]>>>;
+    propagation: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        over: z.core.$ZodBranded<z.ZodString, "RelationTypeName", "out">;
+        toward: z.ZodEnum<{
+            source: "source";
+            target: "target";
+        }>;
+    }, z.core.$strict>>>;
+    sleep: z.ZodObject<{
+        afterIdleMinutes: z.ZodInt;
+        afterQuietMinutes: z.ZodInt;
+        afterUnattendedMinutes: z.ZodInt;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ParsedRulesFile = z.output<typeof rulesFileSchema>;
+export type ParsedStep = z.output<typeof stepSchema>;
+export {};

package/dist/{build-registry.d.ts → registry/build-registry.d.ts}

@@ -1,5 +1,5 @@
 import type { ConceptPin, LoadRejection, Registry } from '@boxxy/model';
-import type { PinnedConcept } from './types.ts';
+import type { PinnedConcept } from '../types.ts';
 export declare function buildRegistry(pinned: readonly PinnedConcept[], pins: readonly ConceptPin[]): {
     readonly value: Registry;
     readonly rejections: readonly LoadRejection[];

package/dist/{resolve-plugin.d.ts → registry/resolve-plugin.d.ts}

@@ -1,4 +1,4 @@
 import type { JsonValue } from '@boxxy/content-hash';
 import type { ParamKindName, Registered, Resolved } from '@boxxy/model';
-import type { Checked } from './types.ts';
+import type { Checked } from '../types.ts';
 export declare function resolvePlugin<K extends ParamKindName>(registered: Registered<K>, params: JsonValue, key: string, path: readonly PropertyKey[]): Checked<Resolved<K>>;

package/dist/{resolve-signal-ref.d.ts → registry/resolve-signal-ref.d.ts}

@@ -1,3 +1,3 @@
 import type { Registry, SignalRef } from '@boxxy/model';
-import type { Checked, ResolvedSignal } from './types.ts';
+import type { Checked, ResolvedSignal } from '../types.ts';
 export declare function resolveSignalRef(ref: SignalRef, path: readonly PropertyKey[], registry: Registry): Checked<ResolvedSignal>;

package/dist/test-utils/build-example-load-input.d.ts

@@ -0,0 +1,11 @@
+import type { Concept, ConceptName, ConceptPin } from '@boxxy/model';
+interface ExampleLoadInput {
+    readonly checkout: {
+        readonly commit: string;
+        readonly files: ReadonlyMap<string, Uint8Array>;
+    };
+    readonly concepts: readonly Concept[];
+    readonly pins: ReadonlyMap<ConceptName, ConceptPin>;
+}
+export declare function buildExampleLoadInput(): ExampleLoadInput;
+export {};

package/dist/test-utils/load-mock-rules.d.ts

@@ -0,0 +1,7 @@
+import type { JsonValue, LoadedRules } from '@boxxy/model';
+interface MockRulesInput {
+    readonly steps: readonly JsonValue[];
+    readonly kinds?: Readonly<Record<string, string>>;
+}
+export declare function loadMockRules(input: MockRulesInput): LoadedRules;
+export {};

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { Concept, LoadRejection, Resolved, SignalKey } from '@boxxy/model';
+import type { Concept, ItemId, ItemView, LoadRejection, Position, Resolved, RetryLever, Settled, SignalKey } from '@boxxy/model';
 export interface Checked<T> {
     readonly value: T | null;
     readonly rejections: readonly LoadRejection[];
@@ -11,3 +11,14 @@ export interface PinnedConcept {
     readonly concept: Concept;
     readonly entryIndex: number;
 }
+export interface RulesDryRunLine {
+    readonly item: ItemId;
+    readonly now: Position;
+    readonly then: Position;
+    readonly moved: boolean;
+}
+export interface DryRunItem {
+    readonly item: ItemView;
+    readonly attempts: readonly Settled[];
+    readonly retries: readonly RetryLever[];
+}

package/example/prompts/build-v1.md

@@ -0,0 +1,4 @@
+Build the item {{title}} to its design and acceptance list, and open a pull request.
+
+Run the checks that the repo's own agent instructions name. Close out `built`, `blocked` with the
+question the owner must answer, or `abandoned`.

package/example/prompts/design-attended-v1.md

@@ -0,0 +1,4 @@
+Design the item {{title}} with the owner, who works in this session with you.
+
+Ask the owner what you need to know. When the owner is done, close out `designed` with the design,
+`blocked` with the open question, or `abandoned`.

package/example/prompts/design-v1.md

@@ -0,0 +1,4 @@
+Design the item {{title}} against its acceptance list.
+
+Close out `designed` with the design, `blocked` with the question the owner must answer, or
+`abandoned`.

package/example/prompts/review-v1.md

@@ -0,0 +1,4 @@
+Review the pull request of the item {{title}} against its acceptance list.
+
+Run `noslop review --report json`. Close out `passed`, or `changes-requested` with each finding as
+text.

package/example/prompts/triage-v1.md

@@ -0,0 +1,5 @@
+Triage the item {{title}}.
+
+Decide whether boxxy takes it on: close out `accepted`, `duplicate` with the other item, or
+`declined` with the reason. An accepted item needs an acceptance list. Accept no criterion that only
+a release or a live run can prove.

package/example/rules.yaml

@@ -0,0 +1,110 @@
+# The v1 rules file: four phases, two limits, five pools and the sleep times.
+version: 1
+concepts: [pool@2, defer@1, expedite@1] # pool@2 adds the filter field `designMode`
+
+pipelines:
+  standard:
+    - phase: triage
+      maxAttempts: 2
+      timeoutMinutes: 20
+      on: # every outcome of the phase kind, or the load fails
+        accepted: next
+        duplicate: { hold: duplicate } # the owner confirms with `boxxy item close`,
+        declined: { hold: declined } # or sends the item on with `boxxy item retry`
+    - phase: design
+      maxAttempts: 2
+      timeoutMinutes: 90 # the clock of an agent-mode attempt; an attended one sleeps instead
+      on:
+        designed: next
+        blocked: { hold: blocked } # the agent's question; the owner answers with `boxxy item note`
+        abandoned: again # the same phase again, counted against maxAttempts
+    - phase: build
+      maxAttempts: 2
+      timeoutMinutes: 180
+      on:
+        built: next
+        blocked: { hold: blocked }
+        abandoned: again
+    - phase: review
+      maxAttempts: 2
+      timeoutMinutes: 45
+      on:
+        passed: { end: reviewed }
+        changes-requested: { to: build, max: 3, resume: true } # wakes the build's kept session
+
+kinds:
+  core.idea:
+    pipeline: standard
+    recipes:
+      triage: triage-v1
+      design: design-v1
+      design/attended: design-attended-v1
+      build: build-v1
+      review: review-v1
+  core.issue:
+    pipeline: standard
+    recipes:
+      triage: triage-v1
+      design: design-v1
+      design/attended: design-attended-v1
+      build: build-v1
+      review: review-v1
+
+skills: # one commit of the skills repo, for every recipe
+  source: example/skills
+  ref: 4f1c9e07a2b35d68c0e1f7a9b3d5c2e8f6a4b1d0
+
+relationTypes: [blocks, duplicate-of, relates-to]
+
+recipes: # the pin and each recipe's skills are part of the recipe hash
+  triage-v1:
+    agent: claude
+    model: claude-opus-5-5
+    effort: medium
+    prompt: prompts/triage-v1.md
+    source: subscription
+    skills: []
+  design-v1:
+    agent: claude
+    model: claude-opus-5-5
+    effort: medium
+    prompt: prompts/design-v1.md
+    source: subscription
+    skills: [bake-off]
+  design-attended-v1:
+    agent: claude
+    model: claude-opus-5-5
+    effort: medium
+    prompt: prompts/design-attended-v1.md
+    source: subscription
+    skills: [bake-off]
+  build-v1:
+    agent: claude
+    model: claude-opus-5-5
+    effort: medium
+    prompt: prompts/build-v1.md
+    source: subscription
+    skills: []
+  review-v1:
+    agent: claude
+    model: claude-opus-5-5
+    effort: medium
+    prompt: prompts/review-v1.md
+    source: subscription
+    skills: []
+
+limits:
+  - { name: workers, max: 7, counts: {} }
+  - { name: owner-design, max: 1, counts: { phase: design, designMode: attended } }
+
+pools: # a filter and a sort; a limit caps the attempts
+  - { name: triage, takes: { phase: triage }, order: [oldest] }
+  - { name: design-with-owner, takes: { phase: design, designMode: attended }, order: [oldest] }
+  - { name: design, takes: { phase: design, designMode: agent }, order: [oldest] }
+  - { name: review, takes: { phase: review }, order: [oldest] }
+  - { name: build, takes: { phase: build }, order: [oldest] }
+
+sleep:
+  afterIdleMinutes: 30 # a session that waits for the owner this long sleeps
+  afterQuietMinutes: 60 # an attended session with no activity this long counts as waiting
+  afterUnattendedMinutes: 240 # an attended session the owner has not attached to this long sleeps

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boxxy/rules",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "boxxy's rules loader: checks a rules checkout and builds the plug-in registry",
   "homepage": "https://github.com/zgeoff/boxxy/tree/main/modules/rules#readme",
   "bugs": "https://github.com/zgeoff/boxxy/issues",
@@ -13,6 +13,7 @@
   "files": [
     "src",
     "!src/**/*.test.ts",
+    "example",
     "dist"
   ],
   "type": "module",
@@ -20,7 +21,9 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./src/index.ts"
-    }
+    },
+    "./example/*": "./example/*",
+    "./test-utils/*": "./src/test-utils/*.ts"
   },
   "publishConfig": {
     "access": "public"
@@ -30,8 +33,8 @@
     "typecheck": "tsrs --noEmit"
   },
   "dependencies": {
-    "@boxxy/content-hash": "0.1.0",
-    "@boxxy/model": "0.1.1",
+    "@boxxy/content-hash": "0.1.3",
+    "@boxxy/model": "0.1.3",
     "tiny-invariant": "1.3.3",
     "ts-pattern": "5.9.2",
     "yaml": "2.9.1",

package/src/dry-run/dry-run-rules.ts

@@ -0,0 +1,53 @@
+import type { LoadedRules, Position } from '@boxxy/model';
+import { findPosition } from '@boxxy/model';
+import type { DryRunItem, RulesDryRunLine } from '../types.ts';
+
+interface DryRunInput {
+  // the rules the server runs
+  readonly current: LoadedRules;
+
+  // a rules file that passed the loader
+  readonly proposed: LoadedRules;
+
+  // the open items only
+  readonly items: readonly DryRunItem[];
+}
+
+// Folds the position of each item twice over the same attempts and levers, once under each rules
+// set. It writes nothing. A live attempt is not touched by a rules change, so the line of an item
+// with a live attempt says where the item stands after that attempt settles as stored so far.
+export function dryRunRules(input: DryRunInput): RulesDryRunLine[] {
+  return input.items.map((entry) => {
+    const now = foldPosition(input.current, entry);
+    const next = foldPosition(input.proposed, entry);
+
+    // oxlint-disable-next-line unicorn/no-thenable -- the wire name of the contract; never awaited
+    return { item: entry.item.id, now, then: next, moved: !isSamePosition(now, next) };
+  });
+}
+
+function foldPosition(rules: LoadedRules, entry: DryRunItem): Position {
+  return findPosition({
+    pipeline: rules.kinds.get(entry.item.kind)?.pipeline ?? null,
+    attempts: entry.attempts,
+    retries: entry.retries,
+  });
+}
+
+function isSamePosition(left: Position, right: Position): boolean {
+  if (left.kind === 'phase' && right.kind === 'phase') {
+    return left.phase === right.phase && left.round === right.round;
+  }
+
+  if (left.kind === 'end' && right.kind === 'end') {
+    return left.reason === right.reason;
+  }
+
+  return (
+    left.kind === 'hold' &&
+    right.kind === 'hold' &&
+    left.reason === right.reason &&
+    left.then === right.then &&
+    left.round === right.round
+  );
+}

package/src/index.ts

@@ -1 +1,4 @@
-export { loadRules } from './load-rules.ts';
+export { rulesFileName } from './constants.ts';
+export { loadRules } from './loading/load-rules.ts';
+export { dryRunRules } from './dry-run/dry-run-rules.ts';
+export type { DryRunItem, RulesDryRunLine } from './types.ts';

package/src/{build-rejection.ts → loading/build-rejection.ts}

@@ -1,6 +1,6 @@
 import type { LoadRejection, LoadRejectionReason } from '@boxxy/model';
 import { formatKeyPath } from '@boxxy/model';
-import { rulesFileName } from './constants.ts';
+import { rulesFileName } from '../constants.ts';
 
 export function buildRejection(
   path: readonly PropertyKey[],

package/src/loading/collect-filter-rejections.ts

@@ -0,0 +1,44 @@
+import type { Filter, LoadRejection, Registry } from '@boxxy/model';
+import type { ParsedRulesFile } from '../parse/rules-file-schema.ts';
+import { buildRejection } from './build-rejection.ts';
+import { toFilter } from './to-filter.ts';
+
+export function collectFilterRejections(
+  file: ParsedRulesFile,
+  registry: Registry,
+): LoadRejection[] {
+  const fields = registry['filter-field'];
+  const limitCounts = file.limits.map((limit) => toFilter(limit.counts));
+
+  const unknownFields = [
+    ...file.limits.map((limit, index) => ({
+      filter: limit.counts,
+      path: ['limits', index, 'counts'],
+    })),
+    ...file.pools.map((pool, index) => ({ filter: pool.takes, path: ['pools', index, 'takes'] })),
+  ].flatMap((entry) =>
+    Object.keys(entry.filter)
+      .filter((field) => !fields.has(field))
+      .map((field) =>
+        buildRejection([...entry.path, field], { kind: 'unknown-filter-field', field }),
+      ),
+  );
+
+  const unbounded = file.pools.flatMap((pool, index) =>
+    limitCounts.some((counts) => isSureToCount(counts, toFilter(pool.takes)))
+      ? []
+      : [buildRejection(['pools', index], { kind: 'pool-without-limit', pool: pool.name })],
+  );
+
+  return [...unknownFields, ...unbounded];
+}
+
+// A limit counts every attempt of a pool only when each field it filters on is one the pool takes
+// on too, with no value the limit leaves out.
+function isSureToCount(counts: Filter, takes: Filter): boolean {
+  return Object.entries(counts).every(([field, counted]) => {
+    const taken = Object.hasOwn(takes, field) ? takes[field] : undefined;
+
+    return taken !== undefined && taken.every((value) => counted.includes(value));
+  });
+}

package/src/loading/collect-recipe-rejections.ts

@@ -0,0 +1,60 @@
+import type { LoadRejection } from '@boxxy/model';
+import { brandSchemas } from '@boxxy/model';
+import invariant from 'tiny-invariant';
+import type { ParsedRulesFile } from '../parse/rules-file-schema.ts';
+import { buildRejection } from './build-rejection.ts';
+
+export function collectRecipeRejections(file: ParsedRulesFile): LoadRejection[] {
+  return [
+    ...collectUnmappedSteps(file),
+    ...collectUndefinedRecipes(file),
+    ...collectSkillsRejections(file),
+  ];
+}
+
+function collectUnmappedSteps(file: ParsedRulesFile): LoadRejection[] {
+  return Object.entries(file.kinds).flatMap(([itemKind, kind]) => {
+    const steps = file.pipelines[kind.pipeline];
+
+    invariant(
+      steps,
+      `the rules file schema refuses the kind ${itemKind}, whose pipeline is missing`,
+    );
+
+    return steps
+      .filter((step) => !Object.hasOwn(kind.recipes, step.phase))
+      .map((step) =>
+        buildRejection(['kinds', itemKind, 'recipes', step.phase], {
+          kind: 'step-without-recipe',
+          itemKind: brandSchemas.itemKindName.parse(itemKind),
+          phase: step.phase,
+        }),
+      );
+  });
+}
+
+function collectUndefinedRecipes(file: ParsedRulesFile): LoadRejection[] {
+  return Object.entries(file.kinds).flatMap(([itemKind, kind]) =>
+    Object.entries(kind.recipes)
+      .filter(([, recipe]) => !Object.hasOwn(file.recipes, recipe))
+      .map(([phase]) =>
+        buildRejection(['kinds', itemKind, 'recipes', phase], {
+          kind: 'missing-recipe',
+          itemKind,
+          phase,
+        }),
+      ),
+  );
+}
+
+function collectSkillsRejections(file: ParsedRulesFile): LoadRejection[] {
+  if (file.skills !== undefined) {
+    return [];
+  }
+
+  return Object.entries(file.recipes)
+    .filter(([, recipe]) => recipe.skills.length > 0)
+    .map(([recipe]) =>
+      buildRejection(['recipes', recipe, 'skills'], { kind: 'skills-without-pin', recipe }),
+    );
+}