@polydeukes/core 0.5.0 → 0.6.0

package/dist/catalogue.d.ts

@@ -0,0 +1,69 @@
+/**
+ * `catalogue.ts` — the eighteen judgment-mechanism names and the shape each one admits.
+ *
+ * A mechanism name is a coordinate the machine checks, not a label: {@link deriveShape}
+ * reads a declaration's shape from its syntax alone — which sources its `source` steps
+ * name, which relations its body relates, whether it carries a witness block — and
+ * {@link validateMechanism} refuses a declaration whose derived shape falls outside the
+ * spec of the name it carries. Nothing here runs an extraction or opens a world.
+ */
+import type { AlgebraDeclaration, RelationName } from './algebra.ts';
+/** The four axes a declaration can read, closed. This tuple is the single source of the list. */
+export declare const AXIS_NAMES: readonly ['change', 'actor', 'world', 'history'];
+/** One of the four axes — the closed vocabulary of the axis position. */
+export type Axis = (typeof AXIS_NAMES)[number];
+/** The judgment mechanisms, closed. A name outside this tuple is refused, never coerced. */
+export declare const MECHANISM_NAMES: readonly ['pairing', 'companion', 'monotonic-order', 'fingerprint-sync', 'producer-owned', 'self-absolution-ban', 'actor-scope', 'precedent', 'phase-order', 'turn-locality', 'stated-ground', 'controlled-vocabulary', 'naming', 'added-only', 'one-way-marker', 'delegated-scope', 'scoped-valve', 'forbidden-command'];
+/** One of the eighteen mechanism names. */
+export type MechanismName = (typeof MECHANISM_NAMES)[number];
+/**
+ * What one mechanism name admits: the axes it may read, the relations it may relate, and
+ * the structural markers it requires.
+ *
+ * `requiresWitness` asks for the valve block; `scopeSource` pins what the declaration may
+ * scope on; `reserved` names what will define the name, and stands in place of a
+ * shape — a reserved name admits no declaration at all.
+ */
+export type MechanismShape = {
+    axes: ReadonlySet<Axis>;
+    relations: ReadonlySet<RelationName>;
+    requiresWitness?: true;
+    scopeSource?: 'target.path' | 'command';
+    reserved?: string;
+};
+/**
+ * The blocks {@link deriveShape} reads. A declaration names itself with its `discipline`,
+ * and an entry under `declare` names itself with the entry id instead — the shape is the
+ * same either way, so the derivation takes the blocks rather than the whole document.
+ */
+export type DerivableDeclaration = Pick<AlgebraDeclaration, 'extract' | 'relate' | 'sources' | 'witness'>;
+/** The derived shape of one declaration: what its syntax says it reads and relates. */
+export type DerivedShape = {
+    axes: ReadonlySet<Axis>;
+    relations: ReadonlySet<RelationName>;
+    witness: boolean;
+};
+/** Every name's spec. The `Record` type pins the keys to {@link MECHANISM_NAMES}. */
+export declare const MECHANISM_SHAPES: Record<MechanismName, MechanismShape>;
+/**
+ * Read one declaration's shape from its syntax (pure).
+ *
+ * The axis of a source name is where the name comes from: the fixed name `actor` is the
+ * actor axis and the other six fixed names the change axis, a name the declaration's own
+ * `sources` block binds is the world axis unless the binding is of the transcript kind,
+ * which is the history axis. A name that is neither is refused by
+ * {@link validateMechanism} — skipping it would derive the empty set, which is a subset of
+ * every spec, and an axis-restricted name would load on a typo. The witness block's
+ * `extract` reads a world too, so its source steps count; its `relate` does not, because the
+ * valve's relation is not the judgment's.
+ */
+export declare function deriveShape(declaration: DerivableDeclaration): DerivedShape;
+/**
+ * Check the declaration's `mechanism` against the catalogue (throws on a mismatch).
+ *
+ * The order is the author's repair order: an unknown name first (nothing else is
+ * meaningful without a spec), then the reserved name, then the structural markers, then
+ * the axes and relations the derived shape must stay inside. Membership is subset, not
+ * equality — a name admitting two relations accepts a declaration using one of them.
+ */
+export declare function validateMechanism(declaration: AlgebraDeclaration, location: string): void;

package/dist/catalogue.js

@@ -0,0 +1,191 @@
+/**
+ * `catalogue.ts` — the eighteen judgment-mechanism names and the shape each one admits.
+ *
+ * A mechanism name is a coordinate the machine checks, not a label: {@link deriveShape}
+ * reads a declaration's shape from its syntax alone — which sources its `source` steps
+ * name, which relations its body relates, whether it carries a witness block — and
+ * {@link validateMechanism} refuses a declaration whose derived shape falls outside the
+ * spec of the name it carries. Nothing here runs an extraction or opens a world.
+ */
+import { isPlainObject } from './is-plain-object.js';
+import { FIXED_SOURCE_NAMES } from './source-names.js';
+import { ConfigValidationError } from './validation.js';
+/** The four axes a declaration can read, closed. This tuple is the single source of the list. */
+export const AXIS_NAMES = ['change', 'actor', 'world', 'history'];
+/** The judgment mechanisms, closed. A name outside this tuple is refused, never coerced. */
+export const MECHANISM_NAMES = [
+    'pairing',
+    'companion',
+    'monotonic-order',
+    'fingerprint-sync',
+    'producer-owned',
+    'self-absolution-ban',
+    'actor-scope',
+    'precedent',
+    'phase-order',
+    'turn-locality',
+    'stated-ground',
+    'controlled-vocabulary',
+    'naming',
+    'added-only',
+    'one-way-marker',
+    'delegated-scope',
+    'scoped-valve',
+    'forbidden-command',
+];
+const CHANGE = new Set(['change']);
+const WORLD = new Set(['world']);
+const ACTOR = new Set(['actor']);
+const HISTORY = new Set(['history']);
+const HISTORY_WORLD = new Set(['history', 'world']);
+const CHANGE_WORLD = new Set(['change', 'world']);
+/** The one fixed source name whose value is the actor rather than the change. */
+const ACTOR_SOURCE = 'actor';
+/** Every name's spec. The `Record` type pins the keys to {@link MECHANISM_NAMES}. */
+export const MECHANISM_SHAPES = {
+    pairing: { axes: WORLD, relations: new Set(['equal']) },
+    companion: { axes: CHANGE_WORLD, relations: new Set(['implies']) },
+    'monotonic-order': { axes: CHANGE_WORLD, relations: new Set(['ordered']) },
+    'fingerprint-sync': { axes: WORLD, relations: new Set(['equal']) },
+    'producer-owned': { axes: ACTOR, relations: new Set(['empty', 'nonEmpty']) },
+    'self-absolution-ban': {
+        axes: CHANGE,
+        relations: new Set(['unchanged', 'empty']),
+    },
+    'actor-scope': { axes: ACTOR, relations: new Set(['empty', 'nonEmpty']) },
+    // The spawn sidecar is a world-axis channel carrying session history, so a precedent
+    // read off it is still a precedent; the transcript source carries the history axis.
+    precedent: { axes: HISTORY_WORLD, relations: new Set(['nonEmpty']) },
+    'phase-order': { axes: HISTORY, relations: new Set(['ordered']) },
+    'turn-locality': { axes: HISTORY, relations: new Set(['nonEmpty']) },
+    'stated-ground': { axes: HISTORY, relations: new Set(['nonEmpty']) },
+    'controlled-vocabulary': { axes: CHANGE_WORLD, relations: new Set(['subset']) },
+    naming: {
+        axes: CHANGE,
+        relations: new Set(['empty', 'nonEmpty']),
+        scopeSource: 'target.path',
+    },
+    'added-only': { axes: CHANGE, relations: new Set(['empty']) },
+    'one-way-marker': { axes: CHANGE, relations: new Set(['subset']) },
+    'delegated-scope': {
+        axes: new Set(),
+        relations: new Set(),
+        reserved: 'the definition-time evaluator',
+    },
+    'scoped-valve': {
+        axes: new Set(AXIS_NAMES),
+        relations: new Set([
+            'empty',
+            'nonEmpty',
+            'equal',
+            'subset',
+            'implies',
+            'ordered',
+            'unchanged',
+        ]),
+        requiresWitness: true,
+    },
+    // A command-line ban scopes on the command it reads: a world with no shell call carries
+    // no `command`, and a scope-less reader would refuse every file-changing call as unjudgeable.
+    'forbidden-command': {
+        axes: CHANGE,
+        relations: new Set(['empty']),
+        scopeSource: 'command',
+    },
+};
+/** The names a rejection message lists so the author sees what is admitted. */
+function quotedList(names) {
+    return names.map((name) => `'${name}'`).join(', ');
+}
+/** Whether one `sources` binding names the session history rather than a world value. */
+function isTranscriptSource(binding) {
+    return isPlainObject(binding) && binding.transcript === true;
+}
+/** The source names one extract block's `source` steps name, in declaration order. */
+function sourceNamesOf(extract) {
+    if (extract === undefined)
+        return [];
+    const names = [];
+    for (const steps of Object.values(extract)) {
+        for (const step of steps) {
+            if (isPlainObject(step) && step.op === 'source' && typeof step.of === 'string') {
+                names.push(step.of);
+            }
+        }
+    }
+    return names;
+}
+/** Every source name the body and the valve read, in declaration order. */
+function sourceNames(declaration) {
+    return [...sourceNamesOf(declaration.extract), ...sourceNamesOf(declaration.witness?.extract)];
+}
+/**
+ * Read one declaration's shape from its syntax (pure).
+ *
+ * The axis of a source name is where the name comes from: the fixed name `actor` is the
+ * actor axis and the other six fixed names the change axis, a name the declaration's own
+ * `sources` block binds is the world axis unless the binding is of the transcript kind,
+ * which is the history axis. A name that is neither is refused by
+ * {@link validateMechanism} — skipping it would derive the empty set, which is a subset of
+ * every spec, and an axis-restricted name would load on a typo. The witness block's
+ * `extract` reads a world too, so its source steps count; its `relate` does not, because the
+ * valve's relation is not the judgment's.
+ */
+export function deriveShape(declaration) {
+    const bindings = declaration.sources ?? {};
+    const axes = new Set();
+    for (const name of sourceNames(declaration)) {
+        if (FIXED_SOURCE_NAMES.includes(name)) {
+            axes.add(name === ACTOR_SOURCE ? 'actor' : 'change');
+        }
+        else if (name in bindings) {
+            axes.add(isTranscriptSource(bindings[name]) ? 'history' : 'world');
+        }
+    }
+    const relations = new Set(declaration.relate.map((entry) => entry.relation.op));
+    return { axes, relations, witness: declaration.witness !== undefined };
+}
+/** Refuse a `source` step naming neither a fixed source nor a binding of this declaration. */
+function checkSourceNames(declaration, location) {
+    const declared = new Set(Object.keys(declaration.sources ?? {}));
+    for (const name of sourceNames(declaration)) {
+        if (FIXED_SOURCE_NAMES.includes(name) || declared.has(name))
+            continue;
+        const bindings = declared.size === 0 ? 'and this declaration binds none' : `or ${quotedList([...declared])}`;
+        throw new ConfigValidationError(`${location} reads the source '${name}', which is neither one of ${quotedList(FIXED_SOURCE_NAMES)} ${bindings}`);
+    }
+}
+/**
+ * Check the declaration's `mechanism` against the catalogue (throws on a mismatch).
+ *
+ * The order is the author's repair order: an unknown name first (nothing else is
+ * meaningful without a spec), then the reserved name, then the structural markers, then
+ * the axes and relations the derived shape must stay inside. Membership is subset, not
+ * equality — a name admitting two relations accepts a declaration using one of them.
+ */
+export function validateMechanism(declaration, location) {
+    const mechanism = declaration.mechanism;
+    if (!MECHANISM_NAMES.includes(mechanism)) {
+        throw new ConfigValidationError(`${location} mechanism is '${mechanism}' — must be one of ${quotedList(MECHANISM_NAMES)}`);
+    }
+    const spec = MECHANISM_SHAPES[mechanism];
+    if (spec.reserved !== undefined) {
+        throw new ConfigValidationError(`${location} mechanism '${mechanism}' is reserved for ${spec.reserved}, which does not exist yet`);
+    }
+    checkSourceNames(declaration, location);
+    const shape = deriveShape(declaration);
+    if (spec.requiresWitness === true && !shape.witness) {
+        throw new ConfigValidationError(`${location} mechanism '${mechanism}' needs a witness block — the valve is its whole shape`);
+    }
+    if (spec.scopeSource !== undefined && declaration.scope?.source !== spec.scopeSource) {
+        const actual = declaration.scope === undefined
+            ? 'this declaration has no scope block'
+            : `this declaration scopes on '${declaration.scope.source}'`;
+        throw new ConfigValidationError(`${location} mechanism '${mechanism}' scopes on '${spec.scopeSource}' — ${actual}`);
+    }
+    const outsideAxes = [...shape.axes].filter((axis) => !spec.axes.has(axis));
+    const outsideRelations = [...shape.relations].filter((relation) => !spec.relations.has(relation));
+    if (outsideAxes.length > 0 || outsideRelations.length > 0) {
+        throw new ConfigValidationError(`${location} mechanism '${mechanism}' expects relations ${quotedList([...spec.relations])} on axes ${quotedList([...spec.axes])}; this declaration relates ${quotedList([...shape.relations])} on ${quotedList([...shape.axes])}`);
+    }
+}

package/dist/config.d.ts

@@ -6,6 +6,8 @@
  * saw. It stays a pure function — no file I/O and no runtime dependencies: validation is
  * hand-rolled, and the published JSON Schema is a sibling artifact this source never reads.
  */
+import { type AlgebraDeclaration } from './algebra.ts';
+export { ConfigValidationError } from './validation.ts';
 /** Conventional default telemetry log path — local-only observation data. */
 export declare const DEFAULT_TELEMETRY_LOG_PATH = ".polydeukes/roi.log";
 /**
@@ -24,14 +26,12 @@ export type LanguageProfile = {
     testCmd: string;
 };
 /**
- * `DisciplineForbid` — the delta-family predicate value.
+ * `AlgebraDeclarationBody` — an algebra declaration minus its name.
  *
- * The string shorthand is equivalent to `{ added }`. It is the only direction that exists;
- * anything else is rejected by validation.
+ * An entry names its declaration with the entry's `id`, so the block under `declare`
+ * carries every other key and never `discipline`.
  */
-export type DisciplineForbid = string | {
-    added: string;
-};
+export type AlgebraDeclarationBody = Omit<AlgebraDeclaration, 'discipline'>;
 /**
  * `EnforceLevel` — an entry's own rung on the promotion ladder. `advise` records a break
  * without stopping it; `block` pins the entry at block whatever default the ladder later
@@ -41,10 +41,9 @@ export type EnforceLevel = 'block' | 'advise';
 /**
  * `DisciplineEntry` — one user-declared discipline. Pure JSON data.
  *
- * Exactly one predicate key (`forbid` | `immutable` | `forbidCommand` |
- * `requirePrecedent`) per entry; `in`/`except` scope the delta and context families.
- * Compilation is the covenant package's job — the core validates compilability of regex
- * strings but never executes them.
+ * The judgment is the `declare` block and nothing else; the other three keys name the
+ * entry, explain it, and set its level. Compilation is the covenant package's job — the
+ * core validates the block's grammar but never runs an extraction.
  */
 export type DisciplineEntry = {
     /** unique handle — telemetry label and verdict reason prefix */
@@ -53,33 +52,17 @@ export type DisciplineEntry = {
     why?: string;
     /** the author's level; composes with the observer's surface level, lenient side winning */
     enforce?: EnforceLevel;
-    /** delta/context-family scope: glob(s) the file path must match (absent = every file change) */
-    in?: string | string[];
-    /** delta/context-family scope: glob(s) excluded after `in` */
-    except?: string | string[];
-    /** delta family — string shorthand = { added } */
-    forbid?: DisciplineForbid;
-    /** path family — its own glob is the scope */
-    immutable?: string | string[];
-    /** command family — regex over shell command strings */
-    forbidCommand?: string;
-    /** context-family trigger: added-direction delta regex (absent = every in-scope change) */
-    when?: string;
-    /**
-     * context family — the session evidence one edit requires beforehand. Exactly one
-     * evidence key. The core owns and fully validates `command`; every other key is
-     * adapter vocabulary whose value passes through verbatim.
-     */
-    requirePrecedent?: Record<string, unknown>;
+    /** one judgment written as data — the entry's `id` is the declaration's name */
+    declare: AlgebraDeclarationBody;
 };
 /**
  * `DisciplineDraft` — an unpromoted discipline: the promotion ladder's first rung,
- * registered as prose ahead of any predicate.
+ * registered as prose ahead of any declaration.
  *
  * A draft is declared, never inferred — only the literal `draft: true` makes one, and an
- * entry with neither a predicate nor the marker stays a validation error. It carries no
- * predicate, scope, or trigger key, produces no registration, no judgment, and no
- * telemetry row; `pdks explain` renders it as unpromoted.
+ * entry with neither a `declare` block nor the marker stays a validation error. It carries
+ * no declaration, produces no registration, no judgment, and no telemetry row;
+ * `pdks explain` renders it as unpromoted.
  */
 export type DisciplineDraft = {
     /** unique handle in the same label space as judged entries and meta-covenant labels */
@@ -166,16 +149,6 @@ export type ResolvedConfig = {
         ttlMinutes: number;
     };
 };
-/**
- * `ConfigValidationError` — raised when a config fails structural validation.
- *
- * The message names the offending field path so the developer sees exactly what is wrong.
- * This throw is a developer-time error (config authoring), a different axis from the
- * covenant runtime's fail-closed exit code — a bad config should fail loud and early.
- */
-export declare class ConfigValidationError extends Error {
-    constructor(message: string);
-}
 /**
  * Validate parsed unknown data as a {@link PolydeukesConfig} and return a
  * {@link ResolvedConfig} with defaults filled and templates compiled. Pure — no file I/O.

package/dist/config.js

@@ -6,22 +6,12 @@
  * saw. It stays a pure function — no file I/O and no runtime dependencies: validation is
  * hand-rolled, and the published JSON Schema is a sibling artifact this source never reads.
  */
+import { validateAlgebraDeclaration } from './algebra.js';
 import { isPlainObject } from './is-plain-object.js';
+import { ConfigValidationError, isNonEmptyString, isStringArray, rejectUnknownKeys, } from './validation.js';
+export { ConfigValidationError } from './validation.js';
 /** Conventional default telemetry log path — local-only observation data. */
 export const DEFAULT_TELEMETRY_LOG_PATH = '.polydeukes/roi.log';
-/**
- * `ConfigValidationError` — raised when a config fails structural validation.
- *
- * The message names the offending field path so the developer sees exactly what is wrong.
- * This throw is a developer-time error (config authoring), a different axis from the
- * covenant runtime's fail-closed exit code — a bad config should fail loud and early.
- */
-export class ConfigValidationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ConfigValidationError';
-    }
-}
 /** Labels the assembly reserves for the judging chain's own registrations. */
 const META_COVENANT_LABELS = ['self-mod', 'shell-mod', 'transcript-mod'];
 const TOP_LEVEL_KEYS = new Set([
@@ -36,44 +26,15 @@ const TOP_LEVEL_KEYS = new Set([
 const PROFILE_KEYS = new Set(['productionGlob', 'testCmd']);
 const TELEMETRY_KEYS = new Set(['logPath']);
 const WITNESS_KEYS = new Set(['token', 'ttlMinutes']);
-const DISCIPLINE_KEYS = new Set([
-    'id',
-    'why',
-    'enforce',
-    'in',
-    'except',
-    'forbid',
-    'immutable',
-    'forbidCommand',
-    'when',
-    'requirePrecedent',
-]);
+const DISCIPLINE_KEYS = new Set(['id', 'why', 'enforce', 'declare']);
 const DRAFT_KEYS = new Set(['id', 'why', 'draft']);
 const ENFORCE_LEVELS = new Set(['block', 'advise']);
-const PREDICATE_KEYS = ['forbid', 'immutable', 'forbidCommand', 'requirePrecedent'];
-/** Predicate families that `in`/`except` may scope — delta and context. */
-const SCOPED_PREDICATE_KEYS = new Set(['forbid', 'requirePrecedent']);
-/** Throw on the first key outside the allowed vocabulary, naming the key and its location. */
-function rejectUnknownKeys(record, allowed, location) {
-    for (const key of Object.keys(record)) {
-        if (!allowed.has(key)) {
-            throw new ConfigValidationError(`unknown key '${key}' in ${location}`);
-        }
-    }
-}
-/** True when the value is an array whose every element is a string. */
-function isStringArray(value) {
-    return Array.isArray(value) && value.every((entry) => typeof entry === 'string');
-}
 /** True when the glob value is a present, non-empty string or a non-empty array of non-empty strings. */
 function isValidGlob(glob) {
     if (typeof glob === 'string') {
-        return glob.length > 0;
-    }
-    if (Array.isArray(glob)) {
-        return glob.length > 0 && glob.every((entry) => typeof entry === 'string' && entry.length > 0);
+        return isNonEmptyString(glob);
     }
-    return false;
+    return Array.isArray(glob) && glob.length > 0 && glob.every(isNonEmptyString);
 }
 /**
  * Compile a `{scope}` template into the callable consumers use.
@@ -87,45 +48,11 @@ function compileTestCmd(template) {
     // via GetSubstitution, breaking literal insertion for scopes containing `$`.
     return (scope) => template.replaceAll('{scope}', () => scope);
 }
-/** Throw unless the pattern string compiles with `new RegExp` — compilability only, never run. */
-function rejectUncompilableRegex(pattern, location) {
-    try {
-        new RegExp(pattern);
-    }
-    catch {
-        throw new ConfigValidationError(`${location} must be a compilable regular expression`);
-    }
-}
-/**
- * Validate a context-family `requirePrecedent` value.
- *
- * Evidence vocabulary is layered: the container (a flat object holding exactly one
- * evidence key) is the core's, and so is the `command` key — a shell command is the
- * agent-crossing surface, fully validated here. Every other key belongs to an adapter,
- * whose own validator judges the value; the core passes it through verbatim and never
- * inspects it. An unrecognized evidence key fails closed at assembly time, not here.
- */
-function validateRequirePrecedent(evidence, location) {
-    if (!isPlainObject(evidence)) {
-        throw new ConfigValidationError(`${location} requirePrecedent must be an object`);
-    }
-    const keys = Object.keys(evidence);
-    if (keys.length !== 1) {
-        throw new ConfigValidationError(`${location} requirePrecedent must have exactly one evidence key`);
-    }
-    if (keys[0] === 'command') {
-        const command = evidence.command;
-        if (typeof command !== 'string' || command.length === 0) {
-            throw new ConfigValidationError(`${location} requirePrecedent.command must be a non-empty string pattern`);
-        }
-        rejectUncompilableRegex(command, `${location} requirePrecedent.command`);
-    }
-}
 /** Validate a draft entry and return it as data. */
 function validateDraft(entry, id, location) {
     for (const key of Object.keys(entry)) {
         if (!DRAFT_KEYS.has(key)) {
-            // Named as the draft rule, not as an unknown key: `forbid` et al. are legal
+            // Named as the draft rule, not as an unknown key: `declare` et al. are legal
             // discipline keys, just not on a draft.
             throw new ConfigValidationError(`${location} allows only id, why, draft on a draft entry (found '${key}')`);
         }
@@ -138,8 +65,8 @@ function validateDraft(entry, id, location) {
     }
     return { id, why: entry.why, draft: true };
 }
-/** Validate the family-independent rules of a judged entry and return its predicate key. */
-function validateJudgedHead(entry, location) {
+/** Validate the head of a judged entry — the closed key set, `why`, and `enforce`. */
+function validateEntryHead(entry, location) {
     rejectUnknownKeys(entry, DISCIPLINE_KEYS, location);
     if (entry.why !== undefined && typeof entry.why !== 'string') {
         throw new ConfigValidationError(`${location} why must be a string`);
@@ -148,90 +75,25 @@ function validateJudgedHead(entry, location) {
         (typeof entry.enforce !== 'string' || !ENFORCE_LEVELS.has(entry.enforce))) {
         throw new ConfigValidationError(`${location} enforce must be 'block' or 'advise'`);
     }
-    const predicates = PREDICATE_KEYS.filter((key) => entry[key] !== undefined);
-    if (predicates.length !== 1) {
-        throw new ConfigValidationError(`${location} must have exactly one predicate key ` +
-            `(forbid | immutable | forbidCommand | requirePrecedent)`);
-    }
-    const predicate = predicates[0];
-    if (!SCOPED_PREDICATE_KEYS.has(predicate) &&
-        (entry.in !== undefined || entry.except !== undefined)) {
-        throw new ConfigValidationError(`${location} allows in/except only on a forbid or requirePrecedent entry`);
-    }
-    // `when` is the context family's trigger; on any other family it would be dead data
-    // implying a trigger that is never applied.
-    if (entry.when !== undefined && predicate !== 'requirePrecedent') {
-        throw new ConfigValidationError(`${location} allows when only on a requirePrecedent entry`);
-    }
-    if (entry.in !== undefined && !isValidGlob(entry.in)) {
-        throw new ConfigValidationError(`${location} in must be a non-empty glob or glob array`);
-    }
-    if (entry.except !== undefined && !isValidGlob(entry.except)) {
-        throw new ConfigValidationError(`${location} except must be a non-empty glob or glob array`);
-    }
-    return predicate;
 }
-function validateForbid(entry, location) {
-    const forbid = entry.forbid;
-    if (typeof forbid === 'string') {
-        // An empty pattern matches at every position, so the entry would break every
-        // in-scope change — rejected like every sibling pattern field.
-        if (forbid.length === 0) {
-            throw new ConfigValidationError(`${location} forbid must be a non-empty string pattern`);
-        }
-        rejectUncompilableRegex(forbid, `${location} forbid`);
-    }
-    else if (isPlainObject(forbid)) {
-        const keys = Object.keys(forbid);
-        if (keys.length !== 1 || keys[0] !== 'added' || typeof forbid.added !== 'string') {
-            throw new ConfigValidationError(`${location} forbid object must have exactly one key 'added' with a string pattern`);
-        }
-        if (forbid.added.length === 0) {
-            throw new ConfigValidationError(`${location} forbid.added must be a non-empty string pattern`);
-        }
-        rejectUncompilableRegex(forbid.added, `${location} forbid.added`);
-    }
-    else {
-        throw new ConfigValidationError(`${location} forbid must be a string pattern or an { added } object`);
-    }
-}
-function validateImmutable(entry, location) {
-    if (!isValidGlob(entry.immutable)) {
-        throw new ConfigValidationError(`${location} immutable must be a non-empty glob or glob array`);
-    }
-}
-function validateForbidCommand(entry, location) {
-    if (typeof entry.forbidCommand !== 'string') {
-        throw new ConfigValidationError(`${location} forbidCommand must be a string pattern`);
-    }
-    if (entry.forbidCommand.length === 0) {
-        // An empty pattern matches every command line — one typo would block every
-        // shell call the entry sees.
-        throw new ConfigValidationError(`${location} forbidCommand must be a non-empty string pattern`);
+/**
+ * Validate a judged entry's declaration by delegating the block to the algebra validator.
+ *
+ * The entry's `id` supplies the declaration's name, so the block carrying its own
+ * `discipline` is refused rather than silently overwritten. The delegated messages arrive
+ * with the entry's location in front of them, which is what places a failure among many
+ * entries.
+ */
+function validateDeclareEntry(entry, location) {
+    const block = entry.declare;
+    if (!isPlainObject(block)) {
+        throw new ConfigValidationError(`${location} declare must be an object`);
     }
-    rejectUncompilableRegex(entry.forbidCommand, `${location} forbidCommand`);
-}
-function validateContextEntry(entry, location) {
-    if (entry.when !== undefined) {
-        if (typeof entry.when !== 'string') {
-            throw new ConfigValidationError(`${location} when must be a string pattern`);
-        }
-        if (entry.when.length === 0) {
-            // An empty pattern matches at every position, so the trigger would fire on any
-            // file that merely grows — reject it like every sibling pattern field.
-            throw new ConfigValidationError(`${location} when must be a non-empty string pattern`);
-        }
-        rejectUncompilableRegex(entry.when, `${location} when`);
+    if ('discipline' in block) {
+        throw new ConfigValidationError(`${location} declare must not carry discipline — the entry id is the name`);
     }
-    validateRequirePrecedent(entry.requirePrecedent, location);
+    validateAlgebraDeclaration({ discipline: entry.id, ...block }, `${location} declare`);
 }
-/** One validator per family, keyed by the predicate that selects the family. */
-const PREDICATE_VALIDATORS = {
-    forbid: validateForbid,
-    immutable: validateImmutable,
-    forbidCommand: validateForbidCommand,
-    requirePrecedent: validateContextEntry,
-};
 /**
  * Validate the `disciplines` array and split judged entries from drafts. Throws
  * {@link ConfigValidationError} naming the offending entry/key; the validated data passes
@@ -268,8 +130,8 @@ function validateDisciplines(disciplines) {
             drafts.push(validateDraft(entry, entry.id, location));
             return;
         }
-        const predicate = validateJudgedHead(entry, location);
-        PREDICATE_VALIDATORS[predicate](entry, location);
+        validateEntryHead(entry, location);
+        validateDeclareEntry(entry, location);
         judged.push(entry);
     });
     return { judged, drafts };

package/dist/exit-codes.d.ts

@@ -4,10 +4,10 @@
  * The three codes are distinct and ordered by severity. The covenant *body* only ever
  * emits `0` (uphold) or `1` (break, non-blocking); translating a break into the blocking
  * `2` is the wrapper's job, never the core's. The sole place the core itself reaches for
- * `2` is the fail-closed parse path in the barrel.
+ * `2` is the fail-closed parse path in `protocol.ts`.
  *
- * These live in their own module rather than the barrel because `fail-policy.ts` needs
- * them: importing them from the barrel, which re-exports fail-policy, is an initialization
+ * These live in their own leaf module because `fail-policy.ts` and `protocol.ts` both need
+ * them: importing them from the barrel, which re-exports both, is an initialization
  * cycle — the constants read as `undefined` depending on which module the runtime evaluates
  * first. The barrel re-exports them, so every consumer outside core still reaches them at
  * the same path.

package/dist/exit-codes.js

@@ -4,10 +4,10 @@
  * The three codes are distinct and ordered by severity. The covenant *body* only ever
  * emits `0` (uphold) or `1` (break, non-blocking); translating a break into the blocking
  * `2` is the wrapper's job, never the core's. The sole place the core itself reaches for
- * `2` is the fail-closed parse path in the barrel.
+ * `2` is the fail-closed parse path in `protocol.ts`.
  *
- * These live in their own module rather than the barrel because `fail-policy.ts` needs
- * them: importing them from the barrel, which re-exports fail-policy, is an initialization
+ * These live in their own leaf module because `fail-policy.ts` and `protocol.ts` both need
+ * them: importing them from the barrel, which re-exports both, is an initialization
  * cycle — the constants read as `undefined` depending on which module the runtime evaluates
  * first. The barrel re-exports them, so every consumer outside core still reaches them at
  * the same path.