@mmnto/cli 1.118.1 → 1.119.0

package/dist/authored-rule-intake-prewindow.test.js

@@ -16,26 +16,39 @@ const artifact = {
     split: { trainPrs: [447, 601], heldOutPrs: [602, 697] },
 };
 let root;
+let totemDir;
+// Prop 310 § Design 1: the rule half lives in a record file the envelope
+// REFERENCES. The §5.2 gate reads `positiveFixtures[].pr`, which is unchanged.
+const RECORD_REF = '.totem/rules/no-console-log.rule.yaml';
 beforeEach(() => {
     root = fs.mkdtempSync(path.join(os.tmpdir(), 'totem-intake-prewindow-'));
-    fs.mkdirSync(path.join(root, 'spine'), { recursive: true });
+    totemDir = path.join(root, '.totem');
+    fs.mkdirSync(path.join(totemDir, 'spine'), { recursive: true });
+    fs.mkdirSync(path.join(totemDir, 'rules'), { recursive: true });
+    fs.writeFileSync(path.join(totemDir, 'rules', 'no-console-log.rule.yaml'), yamlStringify({
+        schemaVersion: 1,
+        severity: 'warning',
+        message: 'console.log is banned in production code.',
+        target: {
+            type: 'regex',
+            pattern: 'console\\.log',
+            scope: { fileGlobs: ['src/**/*.rs'] },
+        },
+        examples: [{ bad: 'console.log("dbg")', good: 'logger.debug("dbg")' }],
+    }), 'utf-8');
 });
 afterEach(() => {
     fs.rmSync(root, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
 });
 const fixture = (pr) => ({
     pr,
-    preimageSource: {
-        kind: 'commit',
-        preimageCommitSha: 'b'.repeat(40),
-        mergeCommitSha: 'a'.repeat(40),
-    },
     filePath: 'src/x.rs',
     matchedSpan: 'L1',
     contentHash: 'h'.repeat(8),
+    example: 0,
 });
 const writeYaml = (fixturePr) => {
-    fs.writeFileSync(path.join(root, 'spine', 'authored-rules.yaml'), yamlStringify({
+    fs.writeFileSync(path.join(totemDir, 'spine', 'authored-rules.yaml'), yamlStringify({
         splitRef: SPLIT_REF,
         freezeCommitment: COMMITMENT,
         authoredAfterSplit: true,
@@ -45,15 +58,14 @@ const writeYaml = (fixturePr) => {
                 author: 'alice',
                 authoredAt: '2026-07-04',
                 targetDefect: 'forbidden console.log',
-                declaredEngine: 'regex',
                 structuralClass: 'forbidden-literal-token',
-                dslSource: 'console\\.log',
+                record: RECORD_REF,
                 positiveFixtures: [fixture(fixturePr)],
             },
         ],
     }), 'utf-8');
 };
-const run = (verified) => runRuleAuthor(root, {
+const run = (verified) => runRuleAuthor(totemDir, {
     judgedBy: 'static-whitelist@cert-1',
     freezeBinding: { artifact },
     ...(verified !== undefined ? { verifiedPreWindowFixturePrs: verified } : {}),

package/dist/authored-rule-intake-prewindow.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"authored-rule-intake-prewindow.test.js","sourceRoot":"","sources":["../src/authored-rule-intake-prewindow.test.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"authored-rule-intake-prewindow.test.js","sourceRoot":"","sources":["../src/authored-rule-intake-prewindow.test.ts"],"names":[],"mappings":"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"}

package/dist/authored-rule-intake.d.ts

@@ -1,6 +1,55 @@
-import { type AuthoredRuleRecord, type FrozenSplitArtifact } from '@mmnto/totem';
+import { type AuthoredFixture, type AuthoredRuleInput, type AuthoredRuleRecord, type FrozenSplitArtifact, type ParsedRuleRecord } from '@mmnto/totem';
 /** `.totem`-relative path to the authoring input. */
 export declare const AUTHORED_RULES_REL: string;
+/** One ingested record: the resolved path, its LF-admitted content hash, and slice 1's parse. */
+export interface IngestedRecord {
+    /** The reference exactly as the envelope wrote it — informational, never identity. */
+    path: string;
+    /** sha256 of the LF-admitted bytes — what every §8 attestation binds to. */
+    contentHash: string;
+    parsed: ParsedRuleRecord;
+}
+/**
+ * The closed set of § Design 1 shape rules an envelope `record:` reference can
+ * violate. A runtime value, not a bare union, so the test table can assert every
+ * rule has a negative fixture — the same discipline `GLOB_DIALECT_RULES` applies
+ * on the record-grammar side.
+ */
+export declare const RECORD_REFERENCE_RULES: readonly ["separator", "absolute-path", "drive-letter", "unc-path", "empty-segment", "current-segment", "parent-segment", "records-dir-prefix", "suffix", "is-the-records-dir"];
+export type RecordReferenceRule = (typeof RECORD_REFERENCE_RULES)[number];
+/**
+ * LEXICAL validation of a `record:` reference — pure string rules over the value
+ * as written, run BEFORE any path resolution.
+ *
+ * Why lexical and why first (falsification leg MIN-2): `path.resolve` +
+ * `path.relative` reach the same verdict for a POSIX-clean reference on every
+ * platform, but they DIVERGE on the malformed ones. On win32 a backslash is a
+ * separator and on linux it is a filename character; a drive-letter absolute that
+ * happens to land inside the root passes containment; `//` collapses; and the
+ * default filesystem case-insensitivity lets `.totem/Rules/x.rule.yaml` resolve
+ * into the real directory on Windows and fail on linux. The reference is also
+ * recorded VERBATIM in the tracked `authoring-ledger.ndjson`, so an accepted
+ * absolute or backslashed form would commit a machine-specific path into a shared
+ * attestation. These rules give one verdict on both platforms, on the text.
+ *
+ * Returns the violated rule, or `null` when the reference is well-formed. The
+ * resolved-containment check in `resolveRecordPath` stays as the second line of
+ * defence.
+ */
+export declare function checkRecordReference(totemDirName: string, reference: string): RecordReferenceRule | null;
+/**
+ * Prop 310 § Design 10 / Amendment 1 — DERIVE each positive fixture's
+ * `preimageSource` from the record's `examples[ordinal]`, keyed `(ruleId, ordinal)`
+ * with the CR-blind pair hash as drift sensor.
+ *
+ * Called AFTER the identity is resolved, because the derived key carries the real
+ * minted `ruleId` — deriving before the mint would anchor the pair to a placeholder.
+ * A dangling ordinal and a duplicate ordinal both fail LOUD naming the rule and the
+ * ordinal ("a dangling, duplicate, or hash-mismatched reference fails loud at
+ * intake — never a silent re-pair"); the hash-mismatch leg is the ledger's own
+ * `contentHash` comparison, which needs no second mechanism.
+ */
+export declare function deriveRecordFixtures(rule: AuthoredRuleInput, ingested: IngestedRecord, ruleId: string): AuthoredFixture[];
 /** A rule the whitelist could not decide — recorded, not minted, not ledgered (no record reaches compile). */
 export interface RejectedAuthoredRule {
     author: string;

package/dist/authored-rule-intake.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authored-rule-intake.d.ts","sourceRoot":"","sources":["../src/authored-rule-intake.ts"],"names":[],"mappings":"AAwBA,OAAO,EAGL,KAAK,kBAAkB,EAOvB,KAAK,mBAAmB,EAOzB,MAAM,cAAc,CAAC;AAItB,qDAAqD;AACrD,eAAO,MAAM,kBAAkB,QAA4C,CAAC;AA2C5E,8GAA8G;AAC9G,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,sFAAsF;IACtF,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,wFAAwF;IACxF,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,SAAS,EAAE,MAAM,CAAC;IAClB,wFAAwF;IACxF,QAAQ,EAAE,oBAAoB,EAAE,CAAC;CAClC;AAUD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE;QAAE,QAAQ,EAAE,mBAAmB,CAAA;KAAE,CAAC;IAClD;;;;;;;OAOG;IACH,2BAA2B,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACnD,GACA,gBAAgB,CA2TlB"}
+{"version":3,"file":"authored-rule-intake.d.ts","sourceRoot":"","sources":["../src/authored-rule-intake.ts"],"names":[],"mappings":"AAkCA,OAAO,EAEL,KAAK,eAAe,EAEpB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EAOvB,KAAK,mBAAmB,EAGxB,KAAK,gBAAgB,EAQtB,MAAM,cAAc,CAAC;AAItB,qDAAqD;AACrD,eAAO,MAAM,kBAAkB,QAA4C,CAAC;AAkG5E,iGAAiG;AACjG,MAAM,WAAW,cAAc;IAC7B,sFAAsF;IACtF,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,gBAAgB,CAAC;CAC1B;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,iLAWzB,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;AAS1E;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,GAChB,mBAAmB,GAAG,IAAI,CAwB5B;AAoFD;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,iBAAiB,EACvB,QAAQ,EAAE,cAAc,EACxB,MAAM,EAAE,MAAM,GACb,eAAe,EAAE,CAqDnB;AAED,8GAA8G;AAC9G,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,sFAAsF;IACtF,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,wFAAwF;IACxF,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,SAAS,EAAE,MAAM,CAAC;IAClB,wFAAwF;IACxF,QAAQ,EAAE,oBAAoB,EAAE,CAAC;CAClC;AAUD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE;QAAE,QAAQ,EAAE,mBAAmB,CAAA;KAAE,CAAC;IAClD;;;;;;;OAOG;IACH,2BAA2B,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACnD,GACA,gBAAgB,CA8VlB"}

package/dist/authored-rule-intake.js

@@ -8,6 +8,15 @@
 // is the lazy-loaded surface (the `.coderabbit.yaml` lazy-load rule targets CLI
 // *commands* — CR's own suggested split for the synchronous producer).
 //
+// PROP 310 slice 3 (§ Design 1, OQ-1 records-only): an entry no longer carries the
+// rule inline. It carries a `record:` reference to `.totem/rules/<slug>.rule.yaml`,
+// which this module resolves, reads through the LF admit hop, content-hashes, and
+// parses with the V1 grammar. The engine the whitelist judges is DERIVED from the
+// record's `target.type`; each positive fixture's certification `preimageSource` is
+// DERIVED from `examples[<its ordinal>]` under the § Design 10 `(ruleId, ordinal)`
+// key. An `dslSource` / `declaredEngine` / `preimageSource` key anywhere in the
+// envelope is a MIGRATION error rejected by name.
+//
 // The author may set ONLY author-owned fields (`AuthoredRuleInput` is `.strict()`,
 // and a recursive scan rejects producer-owned keys at ANY depth). The reader re-runs
 // `evaluateStructuralEligibility` over the DI whitelist (never in core, Tenet 5) and
@@ -16,10 +25,11 @@
 // rule throws before a single byte is written; pass 2 appends ledger rows (fail-loud
 // + read-back). SLICE B: the records are produced + ledgered but not yet fed to the
 // certifying corpus (B2 / C/D), which must key on `ruleId`, not `lessonHash`.
+import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { parse as parseYaml } from 'yaml';
-import { appendAuthoringLedgerEntry, AuthoredRuleRecordSchema, AuthoredRulesFileSchema, authoringContentHash, buildAuthoredIdentityIndex, evaluateStructuralEligibility, identityKey, mintAuthoredRuleId, readAuthoringLedger, sanitizeForTerminal, SPLIT_REF_RE, TotemError, } from '@mmnto/totem';
+import { appendAuthoringLedgerEntry, AuthoredRuleRecordSchema, AuthoredRulesFileSchema, authoringContentHash, buildAuthoredIdentityIndex, evaluateStructuralEligibility, identityKey, mintAuthoredRuleId, parseRuleRecord, readAuthoringLedger, RECORD_FILE_SUFFIX, RECORDS_DIR_REL, sanitizeForTerminal, SPLIT_REF_RE, TotemError, } from '@mmnto/totem';
 import { authoredWhitelist } from './commands/authored-whitelist.js';
 /** `.totem`-relative path to the authoring input. */
 export const AUTHORED_RULES_REL = path.join('spine', 'authored-rules.yaml');
@@ -43,9 +53,46 @@ const RESERVED_PRODUCER_KEYS = new Set([
     'routing',
     'unverified',
 ]);
-function assertNoReservedProducerKeys(value, at = '<root>') {
+/**
+ * Prop 310 § Design 1 (OQ-1 ruling, records-only) — keys the PRE-slice-3 envelope
+ * carried that the record grammar now owns. Rejected BY NAME rather than as a
+ * generic unknown key, so the author is told WHERE the value went instead of that
+ * they typo'd a field:
+ *
+ *   - `dslSource` / `declaredEngine` — the rule half moved into the record file;
+ *     the engine is DERIVED there from `target.type` (§ Design 3/R17) and is never
+ *     author-mirrored.
+ *   - `preimageSource` — Amendment 1 makes the record's `examples` block the
+ *     EDITABLE home and the envelope's side DERIVED, so hand-writing it would be
+ *     the second copy the ruling exists to remove. The fixture references a pair by
+ *     `example: <ordinal>` instead.
+ *
+ * Scanned at every depth for the same reason the producer set is: Zod `.strict()`
+ * is not recursive, so a nested occurrence would be STRIPPED rather than rejected.
+ */
+const MIGRATED_RECORD_KEYS = new Map([
+    [
+        'dslSource',
+        'the rule itself now lives in a record file — move the matcher into `target:` there',
+    ],
+    [
+        'declaredEngine',
+        'the engine is DERIVED from the record’s `target.type` (Prop 310 § Design 3/R17), never declared on the envelope',
+    ],
+    [
+        'preimageSource',
+        'the bad/good pair now lives in the record’s `examples:` block and the envelope’s `preimageSource` is DERIVED from it (Prop 310 Amendment 1) — reference a pair with `example: <ordinal>` instead',
+    ],
+]);
+/**
+ * `recordForm` is the reference shape THIS repo uses — derived from the caller's
+ * actual `totemDir`, never the hardcoded `.totem/`. A repo whose config names a
+ * different totem directory would otherwise be handed a migration instruction
+ * that does not resolve there (MIN-6).
+ */
+function assertNoReservedProducerKeys(value, recordForm, at = '<root>') {
     if (Array.isArray(value)) {
-        value.forEach((v, i) => assertNoReservedProducerKeys(v, `${at}[${i}]`));
+        value.forEach((v, i) => assertNoReservedProducerKeys(v, recordForm, `${at}[${i}]`));
         return;
     }
     if (value === null || typeof value !== 'object')
@@ -54,8 +101,218 @@ function assertNoReservedProducerKeys(value, at = '<root>') {
         if (RESERVED_PRODUCER_KEYS.has(k)) {
             throw new TotemError('CONFIG_INVALID', `authored-rules.yaml carries a producer-owned key '${k}' at ${at} — the producer establishes it, not the author (ADR-112 §3 / FM(d))`, 'Remove the field; the structural-eligibility verdict, rule id, and disposition are minted by the producer.');
         }
-        assertNoReservedProducerKeys(v, `${at}.${k}`);
+        const migrated = MIGRATED_RECORD_KEYS.get(k);
+        if (migrated !== undefined) {
+            // The FULL key path, not just the parent: a migration message is an
+            // instruction to go edit one line, so it names the line.
+            throw new TotemError('CONFIG_INVALID', `authored-rules.yaml carries '${k}' at ${at}.${k} — ${migrated}. Since Prop 310 slice 3 an authored entry carries ONLY a \`record:\` reference to \`${recordForm}\` (Prop 310 § Design 1, OQ-1 records-only).`, `Move the rule into a record file at \`${recordForm}\` and replace the key with \`record: ${recordForm}\`.`);
+        }
+        assertNoReservedProducerKeys(v, recordForm, `${at}.${k}`);
+    }
+}
+/** The `record:` reference shape for a given `.totem` dir, as the author must write it. */
+function recordReferenceForm(totemDir) {
+    return `${path.basename(totemDir)}/${RECORDS_DIR_REL}/<slug>${RECORD_FILE_SUFFIX}`;
+}
+/**
+ * The closed set of § Design 1 shape rules an envelope `record:` reference can
+ * violate. A runtime value, not a bare union, so the test table can assert every
+ * rule has a negative fixture — the same discipline `GLOB_DIALECT_RULES` applies
+ * on the record-grammar side.
+ */
+export const RECORD_REFERENCE_RULES = [
+    'separator',
+    'absolute-path',
+    'drive-letter',
+    'unc-path',
+    'empty-segment',
+    'current-segment',
+    'parent-segment',
+    'records-dir-prefix',
+    'suffix',
+    'is-the-records-dir',
+];
+// Vocabulary deliberately MIRRORS `checkGlobDialect`'s (rule-record.ts): a
+// backslash is a `separator` violation, a leading `/` an `absolute-path`, a
+// `C:` prefix a `drive-letter`, and so on, so an author who has met one surface
+// reads the other without relearning it. `checkGlobDialect` itself is NOT called
+// here — it bans `[ ( ) ? + | ^ $`, which are perfectly legal in a FILENAME.
+const DRIVE_LETTER_RE = /^[A-Za-z]:/;
+/**
+ * LEXICAL validation of a `record:` reference — pure string rules over the value
+ * as written, run BEFORE any path resolution.
+ *
+ * Why lexical and why first (falsification leg MIN-2): `path.resolve` +
+ * `path.relative` reach the same verdict for a POSIX-clean reference on every
+ * platform, but they DIVERGE on the malformed ones. On win32 a backslash is a
+ * separator and on linux it is a filename character; a drive-letter absolute that
+ * happens to land inside the root passes containment; `//` collapses; and the
+ * default filesystem case-insensitivity lets `.totem/Rules/x.rule.yaml` resolve
+ * into the real directory on Windows and fail on linux. The reference is also
+ * recorded VERBATIM in the tracked `authoring-ledger.ndjson`, so an accepted
+ * absolute or backslashed form would commit a machine-specific path into a shared
+ * attestation. These rules give one verdict on both platforms, on the text.
+ *
+ * Returns the violated rule, or `null` when the reference is well-formed. The
+ * resolved-containment check in `resolveRecordPath` stays as the second line of
+ * defence.
+ */
+export function checkRecordReference(totemDirName, reference) {
+    if (reference.includes('\\'))
+        return 'separator';
+    if (reference.startsWith('//'))
+        return 'unc-path';
+    if (reference.startsWith('/'))
+        return 'absolute-path';
+    if (DRIVE_LETTER_RE.test(reference))
+        return 'drive-letter';
+    const requiredPrefix = `${totemDirName}/${RECORDS_DIR_REL}/`;
+    // CASE-SENSITIVE by construction (plain `startsWith`): the record class is the
+    // git-tracked path NAME, which is case-sensitive, and accepting a case variant
+    // here would admit a reference that resolves on a case-folding filesystem and
+    // dangles everywhere else.
+    if (!reference.startsWith(requiredPrefix))
+        return 'records-dir-prefix';
+    if (reference === requiredPrefix)
+        return 'is-the-records-dir';
+    for (const segment of reference.split('/')) {
+        if (segment.length === 0)
+            return 'empty-segment';
+        if (segment === '.')
+            return 'current-segment';
+        if (segment === '..')
+            return 'parent-segment';
+    }
+    // Last: a well-shaped path pointing at the wrong FILE CLASS is the most
+    // specific defect, so it reads after the structural ones.
+    if (!reference.endsWith(RECORD_FILE_SUFFIX))
+        return 'suffix';
+    return null;
+}
+/** Why each rule fired, in the author's terms. */
+const RECORD_REFERENCE_DETAIL = {
+    separator: 'contains a backslash — records use `/` exclusively, on every platform',
+    'absolute-path': 'is an absolute path — the reference is repo-relative',
+    'drive-letter': 'carries a drive letter — the reference is repo-relative',
+    'unc-path': 'is a UNC path — the reference is repo-relative',
+    'empty-segment': 'contains an empty path segment',
+    'current-segment': 'contains a `.` segment — write the path without it',
+    'parent-segment': 'contains a `..` segment — a reference never navigates upward',
+    'records-dir-prefix': 'does not begin with the records directory, compared CASE-SENSITIVELY against the git-tracked path name',
+    suffix: `does not end in '${RECORD_FILE_SUFFIX}'`,
+    'is-the-records-dir': 'names the records directory itself rather than a record file',
+};
+/**
+ * Resolve an envelope `record:` reference to an absolute path.
+ *
+ * Two gates, in order: the platform-independent LEXICAL rules above, then the
+ * resolved-containment check as defence in depth.
+ *
+ * The reference is repo-relative (§ Design 1) and this library is git-free, so the
+ * repo root it resolves against is `dirname(totemDir)` — the layout `.totem/` and
+ * every fixture use. A nested `totemDir` would put the containment check out of
+ * reach of a repo-relative reference; that fails LOUD with the path named rather
+ * than silently resolving somewhere else.
+ */
+function resolveRecordPath(totemDir, reference) {
+    const rulesRoot = path.resolve(totemDir, RECORDS_DIR_REL);
+    const totemDirName = path.basename(totemDir);
+    const expectedForm = recordReferenceForm(totemDir);
+    const reject = (rule, why) => {
+        throw new TotemError('CONFIG_INVALID', `authored-rules.yaml record reference '${reference}' ${why} [${rule}] — a record is referenced as \`${expectedForm}\` (Prop 310 § Design 1)`, `Write \`record: ${expectedForm}\` with forward slashes, no leading \`./\` or \`/\`, and the directory name exactly as it appears in git.`);
+    };
+    const violation = checkRecordReference(totemDirName, reference);
+    if (violation !== null)
+        reject(violation, RECORD_REFERENCE_DETAIL[violation]);
+    const resolved = path.resolve(path.dirname(totemDir), reference);
+    const relative = path.relative(rulesRoot, resolved);
+    // `..` as a whole SEGMENT, not as a prefix: a bare `startsWith('..')` also
+    // rejects `..hidden/x.rule.yaml` and `..a.rule.yaml`, which are ordinary file
+    // names that resolve INSIDE the root. The escape this guards is a path that
+    // steps OUT, and only a leading `..` segment does that.
+    const escapes = relative === '..' || relative.startsWith(`..${path.sep}`);
+    if (relative === '' || escapes || path.isAbsolute(relative)) {
+        reject('containment', `does not resolve inside ${rulesRoot}`);
     }
+    return resolved;
+}
+/** Read + parse one referenced record. A `RuleRecordParseError` propagates UNWRAPPED (§ Failure modes). */
+function ingestRecord(totemDir, reference) {
+    const file = resolveRecordPath(totemDir, reference);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf-8');
+    }
+    catch (err) {
+        throw new TotemError('CONFIG_MISSING', `rule record not found: ${file} (referenced as '${reference}' in authored-rules.yaml)`, `Create the record, or correct the \`record:\` reference (Prop 310 § Design 1).`, err);
+    }
+    // The LF image is the ONE representation everything downstream sees: the parse,
+    // the content hash, and the derived exemplars. That is the shipped admit hop
+    // (Amendment 1 item 2's `serialization-admit` class), and it is what makes a
+    // CRLF-authored record hash and derive identically to its LF twin.
+    const text = lf(raw);
+    const contentHash = createHash('sha256').update(text).digest('hex');
+    // NOT wrapped: `RuleRecordParseError` already names the file AND the offending
+    // record key path, and § Failure modes requires it reach the author intact rather
+    // than flattened into a generic reject.
+    const parsed = parseRuleRecord(text, reference);
+    return { path: reference, contentHash, parsed };
+}
+/**
+ * Prop 310 § Design 10 / Amendment 1 — DERIVE each positive fixture's
+ * `preimageSource` from the record's `examples[ordinal]`, keyed `(ruleId, ordinal)`
+ * with the CR-blind pair hash as drift sensor.
+ *
+ * Called AFTER the identity is resolved, because the derived key carries the real
+ * minted `ruleId` — deriving before the mint would anchor the pair to a placeholder.
+ * A dangling ordinal and a duplicate ordinal both fail LOUD naming the rule and the
+ * ordinal ("a dangling, duplicate, or hash-mismatched reference fails loud at
+ * intake — never a silent re-pair"); the hash-mismatch leg is the ledger's own
+ * `contentHash` comparison, which needs no second mechanism.
+ */
+export function deriveRecordFixtures(rule, ingested, ruleId) {
+    const examples = ingested.parsed.record.examples;
+    const who = `${sanitizeForTerminal(rule.author)} · ${sanitizeForTerminal(rule.targetDefect)}`;
+    const seenOrdinals = new Set();
+    return rule.positiveFixtures.map((fixture) => {
+        const ordinal = fixture.example;
+        const example = examples[ordinal];
+        if (example === undefined) {
+            throw new TotemError('CONFIG_INVALID', `authored rule (${who}) declares a positive fixture referencing example ordinal ${ordinal}, but its record '${sanitizeForTerminal(ingested.path)}' carries ${examples.length} example pair(s) — the reference is DANGLING (Prop 310 § Design 10)`, `Use an ordinal in 0..${examples.length - 1}, or add the missing pair to the record's \`examples:\` block.`);
+        }
+        if (seenOrdinals.has(ordinal)) {
+            throw new TotemError('CONFIG_INVALID', `authored rule (${who}) declares two positive fixtures referencing the SAME example ordinal ${ordinal} — one exemplar pair cannot serve two corpus loci (Prop 310 § Design 10)`, "Author a second bad/good pair in the record's `examples:` block and point the second fixture at its ordinal.");
+        }
+        seenOrdinals.add(ordinal);
+        // Looked up by the `ordinal` FIELD, not by array position: `examplePairHashes`
+        // is a list of `{ordinal, hash}` records, so indexing it would silently bind a
+        // fixture to the wrong pair the moment the list is ever filtered or reordered —
+        // a wrong drift sensor is worse than none, because it reads as intact.
+        const pairHash = ingested.parsed.examplePairHashes.find((h) => h.ordinal === ordinal);
+        if (pairHash === undefined) {
+            // A PRODUCER bug, not an authoring defect: `parseRuleRecord` emits one hash
+            // per example. Reaching here means a hand-built `ParsedRuleRecord`, and
+            // recomputing the hash to paper over it would mint a § Design 10 drift sensor
+            // from a value nothing attested. Fail loud, in the incumbent idiom.
+            throw new Error(`[Totem Error] deriveRecordFixtures: rule '${ruleId}' has no example-pair hash for ordinal ${ordinal} — the parser emits one per \`examples[i]\` (Prop 310 Amendment 1 item 3), so a missing hash means the ParsedRuleRecord was hand-built or a producer dropped it; deriving the fixture anyway would give it a drift sensor nothing computed from the record.`);
+        }
+        return {
+            pr: fixture.pr,
+            filePath: fixture.filePath,
+            matchedSpan: fixture.matchedSpan,
+            contentHash: fixture.contentHash,
+            preimageSource: {
+                kind: 'record',
+                ruleId,
+                ordinal,
+                // The parser's own per-pair hash, never recomputed here: one home for the
+                // Amendment 1 item 3 basis (Tenet 20).
+                pairHash: pairHash.hash,
+                badExample: example.bad,
+                goodExample: example.good,
+            },
+        };
+    });
 }
 /**
  * ADR-112 §8 — ingest `.totem/spine/authored-rules.yaml` into authored records +
@@ -88,7 +345,7 @@ export function runRuleAuthor(totemDir, opts) {
     }
     // FM(d): reject reserved producer keys at ANY depth (codex — `.strict()` is not recursive),
     // THEN strict-parse the top level (any unknown top-level/rule key also fails, never stripped).
-    assertNoReservedProducerKeys(doc);
+    assertNoReservedProducerKeys(doc, recordReferenceForm(totemDir));
     const parsed = AuthoredRulesFileSchema.safeParse(doc);
     if (!parsed.success) {
         throw new TotemError('CONFIG_INVALID', `authored-rules.yaml is invalid: ${parsed.error.message}`, 'The file may set only author-owned fields; producer fields (structuralEligibility, ruleId, decidable, disposition, …) are established by the producer, not the author (ADR-112 §3 / FM(d)).', parsed.error);
@@ -165,27 +422,56 @@ export function runRuleAuthor(totemDir, opts) {
     const pending = [];
     const rejected = [];
     for (const r of fileDoc.rules) {
+        // Prop 310 § Design 1: read + parse the referenced record FIRST — the engine the
+        // whitelist judges is DERIVED from it (§ Design 3/R17), so nothing downstream can
+        // run before the record is in hand. A grammar failure propagates as the parser's
+        // own typed error, naming the file and the offending key path.
+        const ingested = ingestRecord(totemDir, r.record);
+        const declaredEngine = ingested.parsed.derivedEngine;
         // Re-run the INDEPENDENT eligibility check; the author's structuralClass is a CLAIM.
-        const structuralEligibility = evaluateStructuralEligibility({ declaredEngine: r.declaredEngine, structuralClass: r.structuralClass }, authoredWhitelist(), judgedBy);
+        const structuralEligibility = evaluateStructuralEligibility({ declaredEngine, structuralClass: r.structuralClass }, authoredWhitelist(), judgedBy);
         if (!structuralEligibility.decidable) {
             rejected.push({
                 author: r.author,
                 targetDefect: r.targetDefect,
                 structuralClass: r.structuralClass,
-                declaredEngine: r.declaredEngine,
-                reason: `no unambiguous whitelist match for (${r.declaredEngine}, ${r.structuralClass}) — not structurally decidable (ADR-112 §3)`,
+                declaredEngine,
+                reason: `no unambiguous whitelist match for (${declaredEngine}, ${r.structuralClass}) — not structurally decidable (ADR-112 §3)`,
             });
             continue;
         }
         const origin = r.origin ?? FROM_SCRATCH;
-        const dslSource = lf(r.dslSource);
+        // ── Identity BEFORE the material hash (Prop 310 slice 3 reorder) ──
+        // The derived `preimageSource` carries the minted `ruleId` as half of the
+        // § Design 10 join key, and the derived fixtures are material — so the identity
+        // has to be resolved first. The DECISION is unchanged: an existing identity
+        // reuses its persisted id and is judged by hash equality; only a genuinely new
+        // one mints. `ruleId` is stable per identity, so putting it inside the material
+        // cannot churn a rule that did not change.
+        const key = identityKey(r.author, r.targetDefect);
+        const existing = byIdentity.get(key);
+        let ruleId;
+        if (existing) {
+            ruleId = existing.ruleId; // reuse the persisted id — NEVER re-mint an existing identity
+        }
+        else {
+            ruleId = mintAuthoredRuleId(r.author, r.targetDefect, mintedIds);
+            mintedIds.add(ruleId);
+        }
+        const positiveFixtures = deriveRecordFixtures(r, ingested, ruleId);
         // The file-level attestations are part of the revision fingerprint (greptile-P1 + CR): an
         // attestation-only change (e.g. a re-frozen split) must append a fresh row, never read `unchanged`.
         const contentHash = authoringContentHash({
-            declaredEngine: r.declaredEngine,
+            declaredEngine,
             structuralClass: r.structuralClass,
-            dslSource,
-            positiveFixtures: r.positiveFixtures,
+            // § Design 1: the record's BYTES are the material, its path is not — a rename
+            // changes no identity and must not force a re-attestation.
+            recordContentHash: ingested.contentHash,
+            // The DERIVED fixtures, not the author's ordinal references: the derivation
+            // carries the pair's text and its CR-blind hash, so an `examples` edit flips
+            // this fingerprint through the § Design 10 drift sensor as well as through
+            // the record's own content hash.
+            positiveFixtures,
             negativeFixtures: r.negativeFixtures,
             origin,
             splitRef: fileDoc.splitRef,
@@ -200,17 +486,11 @@ export function runRuleAuthor(totemDir, opts) {
             // Absent (legacy free-text splitRef) ⇒ dropped by canonicalStringify, hash unchanged.
             ...(binding !== undefined ? { freezeCommitment: binding.artifact.freezeCommitment } : {}),
         });
-        const key = identityKey(r.author, r.targetDefect);
-        const existing = byIdentity.get(key);
-        let ruleId;
         let action;
         if (existing) {
-            ruleId = existing.ruleId; // reuse the persisted id — NEVER re-mint an existing identity
             action = existing.contentHash === contentHash ? 'unchanged' : 'revised';
         }
         else {
-            ruleId = mintAuthoredRuleId(r.author, r.targetDefect, mintedIds);
-            mintedIds.add(ruleId);
             action = 'minted';
         }
         // Construct + validate the record. `authoredAt` calendar validity is enforced at intake
@@ -226,14 +506,18 @@ export function runRuleAuthor(totemDir, opts) {
                     author: r.author,
                     authoredAt: r.authoredAt,
                     targetDefect: r.targetDefect,
-                    positiveFixtures: r.positiveFixtures,
+                    positiveFixtures,
                     ...(r.negativeFixtures ? { negativeFixtures: r.negativeFixtures } : {}),
                 },
                 structuralEligibility,
                 origin,
-                declaredEngine: r.declaredEngine,
+                declaredEngine,
                 authoringLedgerRef: ruleId, // the ledger lineage for this ruleId; the latest entry is effective
-                dslSource,
+                record: {
+                    path: ingested.path,
+                    contentHash: ingested.contentHash,
+                    parsed: ingested.parsed,
+                },
                 unverified: true,
             });
         }
@@ -245,12 +529,17 @@ export function runRuleAuthor(totemDir, opts) {
             author: r.author,
             targetDefect: r.targetDefect,
             authoredAt: r.authoredAt,
-            declaredEngine: r.declaredEngine,
+            declaredEngine,
             splitRef: fileDoc.splitRef,
             authoredAfterSplit: fileDoc.authoredAfterSplit,
             heldOutNonInspectionAttestation: fileDoc.heldOutNonInspectionAttestation,
             structuralEligibility,
             origin,
+            // § Design 1 attestation relocation: the entry records WHICH bytes were
+            // ingested, so the §5 embargo proof stays content-addressed to the exact
+            // record set rather than weakening to an ambient claim. `path` rides along
+            // for diagnosis only — it is not in the material hash.
+            record: { path: ingested.path, contentHash: ingested.contentHash },
             positiveFixturePrs: r.positiveFixtures.map((f) => f.pr),
             // No negativeFixturePrs: §6 near-misses are silence-only with no `pr` (strategy#770 +
             // Q-C ruling); only positiveFixtures are train-side-attested (§5(2)).