polydeukes 0.6.0 → 0.7.1

package/dist/covenant/discipline.js

@@ -0,0 +1,667 @@
+/**
+ * Discipline registration compiler.
+ *
+ * `compileDisciplineRegistrations` turns validated entries into dispatcher registrations —
+ * one per entry, routed by the declaration's own scope (`matches`), judged by an in-process
+ * thunk that runs the compiled declaration over each world the input yields. Absolute paths
+ * are relativized against the repo root first, so a path outside the root never routes: a
+ * declaration's scope is written repo-relative.
+ */
+import { isAbsolute, posix, relative, resolve } from 'node:path';
+import { allFileChanges, } from '@polydeukes/core';
+import { executedText } from './bash-line.js';
+import { compileDeclaration, judgeDeclaration, scopeAdmits, witnessOpens, } from './declaration-engine.js';
+import { UNJUDGEABLE_OUTCOME } from './run-covenant.js';
+import { deriveShellChanges } from './shell-evidence.js';
+/**
+ * Relativize a file-change path against the root for glob matching. A relative path passes
+ * through; an absolute path outside `rootDir` yields null (never matches — discipline scope
+ * is declared repo-relative).
+ */
+function relativizeForScope(filePath, rootDir) {
+    if (!isAbsolute(filePath)) {
+        // A relative spelling normalizes before matching — `./x` and `a/../x` name x, and a
+        // spelling that resolves out of the root matches nothing. Matching verbatim instead
+        // lets an equivalent spelling escape every scope.
+        const normalized = posix.normalize(filePath);
+        if (normalized === '.' || normalized.startsWith('..'))
+            return null;
+        return normalized;
+    }
+    const relativized = relative(rootDir, filePath);
+    if (relativized.startsWith('..') || isAbsolute(relativized))
+        return null;
+    return relativized;
+}
+/**
+ * Turn each observation of the input into one world, in input order.
+ *
+ * The seven source names are fixed: `target.path`, `pre`, `post`, the paired `state`,
+ * `changes`, `command`, and `actor`. A side the change does not carry is an ABSENT key, never a
+ * fabricated default — what a missing source means is the declaration's own `supply` policy
+ * to state. `state` exists only where both sides do, so a declaration comparing before with
+ * after refuses a change that has no before. A path outside the root is dropped, as
+ * everywhere else in this module: a declaration's scope is written repo-relative.
+ *
+ * `changes` is the observation unit's change set, the same array instance in every world so
+ * a large commit costs one list rather than one per change. It is derived from this input
+ * unless the host supplied its own — a host whose observation is wider than the changes it
+ * dispatches at once has a set no derivation here could reach.
+ *
+ * `actor` is the input's actor object, carried by every world of the input — the file
+ * worlds and the call world alike. An input without one leaves the key absent, since `{}`
+ * is the positive value saying the host observed an actor that is not a subagent.
+ *
+ * `command` is the first shell call's command line with its heredoc bodies and herestring
+ * words deleted, carried by every world of the input. bash hands those bytes to the command
+ * as stdin data instead of executing them — except a body or word bash expands first, which
+ * stays — and whether they become a file write is the shell-evidence path's judgment, which
+ * reads the command as written.
+ * A shell call changing no in-scope file is still one observation, so it yields the single
+ * CALL WORLD — subject `'-'`, no `target.path`, so a path-scoped declaration finds no string
+ * and refuses it. A surface whose shell tools are empty observes no shell call, hence no
+ * `command` and no call world.
+ */
+export function worldsFromInput(spec) {
+    const { input, rootDir } = spec;
+    const rawCommand = filterShellCommands(input.toolCalls, spec.shellTools, spec.commandArgs)[0];
+    const command = rawCommand === undefined ? undefined : executedText(rawCommand);
+    const scoped = [];
+    for (const change of allFileChanges(input)) {
+        const path = relativizeForScope(change.path, rootDir);
+        if (path !== null)
+            scoped.push({ path, change });
+    }
+    const changes = input.world?.changes ?? scoped.map((entry) => entry.path);
+    // The facts every world of this input shares. A key is set only when its value exists: a
+    // key holding `undefined` would satisfy the engine's presence check and skip the supply
+    // policy, so the step would run over nothing and could answer pass.
+    const shared = {
+        changes,
+        ...(command !== undefined && { command }),
+        ...(input.actor !== undefined && { actor: input.actor }),
+    };
+    const worlds = [];
+    for (const { path, change } of scoped) {
+        const world = { 'target.path': path, ...shared };
+        // A kind this host does not know (a stale adapter dist) yields no world at all: a key
+        // holding `undefined` would satisfy the engine's presence check and skip the supply
+        // policy, so the step would run over nothing and could answer pass.
+        switch (change.kind) {
+            case 'create':
+                world.post = change.post;
+                break;
+            case 'modify':
+                world.pre = change.pre;
+                world.post = change.post;
+                world.state = { pre: change.pre, post: change.post };
+                break;
+            case 'delete':
+                if (change.pre !== undefined)
+                    world.pre = change.pre;
+                break;
+            default:
+                continue;
+        }
+        worlds.push({ path, world });
+    }
+    if (worlds.length === 0 && command !== undefined)
+        return [{ path: '-', world: shared }];
+    return worlds;
+}
+/** The one shell-surface filter: named args of shell-tool calls, whatever the source. */
+function filterShellCalls(calls, shellTools, commandArgs) {
+    const found = [];
+    for (const call of calls) {
+        if (!shellTools.includes(call.name))
+            continue;
+        for (const argName of commandArgs) {
+            const value = call.args?.[argName];
+            if (typeof value === 'string')
+                found.push({ toolName: call.name, command: value });
+        }
+    }
+    return found;
+}
+/** The command strings of shell-tool calls, whatever the source. */
+function filterShellCommands(calls, shellTools, commandArgs) {
+    return filterShellCalls(calls, shellTools, commandArgs).map((call) => call.command);
+}
+/**
+ * Derive the shell-delivered signals of an input — the one derivation seam both the routing
+ * closures and the judged body consume, so the two can never disagree on what a command
+ * proves. Pure: completing the evidence with a pre-state is the body's job, since routing
+ * may not consult the reader.
+ */
+function deriveShellSignals(input, opts) {
+    const signals = { evidence: [], unjudgeable: [] };
+    for (const call of filterShellCalls(input.toolCalls, opts.shellTools, opts.commandArgs)) {
+        const derived = deriveShellChanges(call.command);
+        for (const change of derived.evidence) {
+            signals.evidence.push({ toolName: call.toolName, change });
+        }
+        signals.unjudgeable.push(...derived.unjudgeable);
+    }
+    return signals;
+}
+/**
+ * Complete shell-derived evidence with the surface's pre-state and attach it to the input.
+ * The hook runs before the tool does, so what the surface observes now IS the pre-state.
+ *
+ * Two rules. **One evidence, one call element**: `toolCall.fileChange` is singular, so each
+ * derived change rides its own element (same tool name, no args) rather than the shell call
+ * it came from. **Same-path evidence chains in command order**: only the first write consults
+ * the reader, and every later one composes onto its predecessor's post, or a truncate
+ * followed by a re-add would be forgiven as pre-existing debt.
+ */
+function enrichWithShellEvidence(input, opts) {
+    const derived = deriveShellSignals(input, opts);
+    if (derived.evidence.length === 0)
+        return input;
+    const composed = new Map();
+    const proven = [];
+    for (const { toolName, change } of derived.evidence) {
+        const location = resolve(opts.rootDir, change.path);
+        const chained = composed.get(location);
+        const pre = chained !== undefined ? chained : opts.readPreState(location);
+        if (pre === undefined) {
+            // Cannot judge means block: the thunk-level catch turns this throw into the
+            // undecidable-structure outcome — never a quiet uphold recorded as `passed`.
+            throw new Error(`pre-state of ${change.path} is unreadable`);
+        }
+        const post = change.mode === 'append' ? `${pre ?? ''}${change.content}` : change.content;
+        composed.set(location, post);
+        proven.push({
+            name: toolName,
+            fileChange: pre === null
+                ? { kind: 'create', path: change.path, post }
+                : { kind: 'modify', path: change.path, pre, post },
+        });
+    }
+    return { ...input, toolCalls: [...input.toolCalls, ...proven] };
+}
+/**
+ * The paths a command writes in a way this layer cannot compute. The skip arm owns them: a
+ * computable write to the same path in the same command composes onto a state the
+ * uncomputable one then changes, so no world the body could build is the one the call leaves
+ * on disk.
+ */
+function uncomputablePaths(signals, rootDir) {
+    const owned = new Set();
+    for (const signal of signals.unjudgeable) {
+        const path = signal.path === undefined ? null : relativizeForScope(signal.path, rootDir);
+        if (path !== null)
+            owned.add(path);
+    }
+    return owned;
+}
+/**
+ * The first computable shell write a declaration's scope admits, judged on what the command
+ * text alone decides: the target path. A scope over any other source needs the world only
+ * the body can build (an append's content composes onto a pre-state the reader holds), so
+ * such a write is admitted here and the body settles it — routing to nothing would leave a
+ * write the body could break on with no row at all.
+ */
+function firstAdmittedShellWrite(compiled, input, opts, rootDir) {
+    const signals = deriveShellSignals(input, opts);
+    const owned = uncomputablePaths(signals, rootDir);
+    const testable = compiled.scope === undefined || compiled.scope.source === 'target.path';
+    for (const derived of signals.evidence) {
+        const path = relativizeForScope(derived.change.path, rootDir);
+        if (path === null || owned.has(path))
+            continue;
+        if (!testable || scopeAdmits(compiled, { 'target.path': path }))
+            return path;
+    }
+    return null;
+}
+/**
+ * Append an entry's rationale to a break reason.
+ *
+ * The reason is one line an agent reads off stderr, so a `why` spanning several lines — a YAML
+ * block scalar writes exactly that — folds to spaces before it is appended. Every line break
+ * folds, CR included and not only the CRLF pair: a lone CR reaching a terminal returns the
+ * cursor to column zero, so it would repaint the rationale over the discipline id and path this
+ * reason has already named. A run of breaks folds to one space, which is what a block scalar's
+ * blank line and trailing newline produce. Emptiness is decided AFTER folding: a why of only
+ * breaks or spaces carries no rationale, and appending the separator alone would leave a
+ * dangling ` — why: `. Nothing about a verdict is decided here; the caller has already judged.
+ */
+function withWhy(reason, why) {
+    const folded = why?.replace(/[\r\n]+/g, ' ').trim();
+    return folded === undefined || folded === '' ? reason : `${reason} — why: ${folded}`;
+}
+/** The declaration compiler's fault value, distinguished from a compiled declaration. */
+function isFault(value) {
+    return value.kind === 'config-fault';
+}
+/** Compile a declare entry's block, the entry's id supplying the declaration's name. */
+function compileEntryDeclaration(entry) {
+    return compileDeclaration({
+        declaration: {
+            discipline: entry.id,
+            ...entry.declare,
+        },
+    });
+}
+/**
+ * The first of `paths` the declaration's scope admits, judged as a world of that path alone.
+ *
+ * A shell line delivers a path and nothing else, so only a scope over `target.path` can be
+ * tested here. A scope over any other source admits every path: the write may be in scope
+ * and this layer cannot tell, which is exactly what the skip row is for.
+ */
+function firstAdmittedPath(compiled, paths, rootDir) {
+    const testable = compiled.scope === undefined || compiled.scope.source === 'target.path';
+    for (const path of paths) {
+        const scoped = relativizeForScope(path, rootDir);
+        if (scoped === null)
+            continue;
+        if (!testable || scopeAdmits(compiled, { 'target.path': scoped }))
+            return scoped;
+    }
+    return null;
+}
+/**
+ * Whether a surface completes a computable shell write into a file world at all. Without a
+ * pre-state channel the derivation stops at the command text, so such a write is as
+ * uncomputable here as one this layer's table refuses.
+ */
+function completesShellWrites(spec) {
+    return spec.observesPreState !== false;
+}
+/**
+ * Whether an entry's shell-delivered writes are attributable to it — a declaration that
+ * compiles has a scope to attribute them by, and one that does not compile defines no match.
+ */
+function hasShellSkipArm(entry, spec) {
+    // No shell surface, no shell writes to detect: the arm's own matches predicate could
+    // never fire, so registering it would only misreport the entry as unjudgeable there.
+    if (spec.shellTools.length === 0 || spec.commandArgs.length === 0)
+        return false;
+    const compiled = compileEntryDeclaration(entry);
+    if (isFault(compiled))
+        return false;
+    // A declaration scoped on the command line owns no path: the shell call it judges is the
+    // world its body already saw, so an uncomputable write in the same call is not its row.
+    return compiled.scope?.source !== 'command';
+}
+/**
+ * The per-entry skip registration: a detected write in this entry's scope whose result
+ * cannot be computed records one `skipped` under the entry's own label, keeping the gain
+ * aggregation in one group instead of falling to the common backstop.
+ *
+ * On a surface with no pre-state channel the computable writes join them, because there the
+ * judging arm receives no world for such a write either: routing it there would record the
+ * entry as having judged a file it never read.
+ */
+function shellSkipArm(entry, spec) {
+    const opts = {
+        rootDir: spec.rootDir,
+        shellTools: spec.shellTools,
+        commandArgs: spec.commandArgs,
+        readPreState: spec.readPreState,
+    };
+    // Where the surface completes them, this arm carries the UNCOMPUTABLE writes only — a
+    // computable one becomes a file change the judging arm sees, so admitting it here would
+    // leave one call two rows.
+    const completes = completesShellWrites(spec);
+    const compiled = compileEntryDeclaration(entry);
+    const unjudgeable = (input) => {
+        const signals = deriveShellSignals(input, opts);
+        const paths = signals.unjudgeable.flatMap((signal) => signal.path ?? []);
+        if (completes)
+            return paths;
+        return [...paths, ...signals.evidence.map((derived) => derived.change.path)];
+    };
+    const scoped = isFault(compiled)
+        ? () => null
+        : (input) => firstAdmittedPath(compiled, unjudgeable(input), spec.rootDir);
+    return {
+        label: entry.id,
+        protectedPaths: [],
+        matches: scoped,
+        skip: {
+            reason: completes
+                ? 'a shell write in scope whose result this layer cannot compute'
+                : 'a shell write in scope on a surface with no pre-state channel to complete it',
+            kind: 'no-observation',
+        },
+    };
+}
+/**
+ * The one common shell-axis skip registration. A write whose target itself is unknowable
+ * belongs to no entry's scope, so leaving N rows under N labels would trade one silent pass
+ * for a fabricated attribution — one row, one subject `'-'`.
+ */
+function shellUnjudgeableRegistration(spec) {
+    const opts = {
+        rootDir: spec.rootDir,
+        shellTools: spec.shellTools,
+        commandArgs: spec.commandArgs,
+        readPreState: spec.readPreState,
+    };
+    return {
+        label: 'shell-unjudgeable',
+        protectedPaths: [],
+        matches: (input) => deriveShellSignals(input, opts).unjudgeable.some((signal) => signal.path === undefined)
+            ? '-'
+            : null,
+        skip: {
+            reason: 'a shell command whose write target this layer cannot determine',
+            kind: 'no-observation',
+        },
+    };
+}
+/**
+ * Flatten a session into the plain snapshot a declaration reads.
+ *
+ * `index` is the observation ordinal within its own list, and `observedAtMs` is the clock at
+ * supply time — the only moment the age of a turn can be measured against, since the engine
+ * itself reads no clock.
+ */
+function snapshotOf(transcript) {
+    return {
+        observedAtMs: Date.now(),
+        userMessages: transcript
+            .findUserMessages()
+            .map((message, index) => ({ index, text: message.text, timestampMs: message.timestampMs })),
+        toolCalls: transcript.findToolCalls().map((call, index) => ({
+            index,
+            name: call.name,
+            args: call.args,
+            succeeded: call.succeeded,
+        })),
+    };
+}
+/**
+ * The `sources` bindings of a declare entry, in declaration order; none is an empty list.
+ *
+ * Each file path is normalized once, here, so the plan, the supplied keys, and the match
+ * against the change set all see one spelling: a `./locales/en.json` an author wrote is
+ * otherwise read under one name and looked up under another, and the change's own text never
+ * wins. A channel or transcript binding carries its kind instead — neither is a path.
+ */
+function sourceBindings(entry) {
+    return Object.entries(entry.declare?.sources ?? {}).map(([name, source]) => {
+        if ('sidecar' in source)
+            return { name, sidecar: true };
+        if ('transcript' in source)
+            return { name, transcript: true };
+        return { name, file: posix.normalize(source.file) };
+    });
+}
+/**
+ * What each named source is worth on this input: for a file, the change's own `post` when it
+ * is one this input changes and the host-supplied text otherwise; for a channel, the text the
+ * surface supplied; for a transcript, the injected session flattened into a plain snapshot.
+ * Absent when none exists.
+ *
+ * The change set wins over the supplied text because the two surfaces read the tree at
+ * different moments — a session call is judged while the disk still holds the pre-edit
+ * state — and the change carries the state the call will produce. A deletion leaves the
+ * key absent, since after it there is no file for the declaration's `supply` policy to
+ * dispose of by any other reading. That rule never reaches a channel: a channel has no path,
+ * so it can never overlap the change set. A transcript has no path either, and its absence
+ * is the absence of the injected session — never anything the world axis carries.
+ */
+function sourceValues(bindings, worlds, world, transcript, postIsWholeFile) {
+    const values = {};
+    for (const binding of bindings) {
+        if ('transcript' in binding) {
+            // An injected transcript that throws is an unusable channel, not an answer — the
+            // same reading the precedent path gives it. Leaving the key absent hands the case
+            // to the declaration's `supply` policy instead of the dispatcher's routing failure,
+            // which would block an advised entry.
+            if (transcript !== undefined) {
+                try {
+                    values[binding.name] = snapshotOf(transcript);
+                }
+                catch {
+                    // absent
+                }
+            }
+            continue;
+        }
+        if ('sidecar' in binding) {
+            const text = world?.channels?.sidecar;
+            if (text !== undefined)
+                values[binding.name] = text;
+            continue;
+        }
+        const { name, file } = binding;
+        // Same-path shell writes chain in command order and each carries its own world, so the
+        // last one at the path is the state the call leaves. A hunk-only `post` is not that
+        // state, so a surface whose changes carry fragments reads the tree below instead — except
+        // for a create, whose added lines are the whole file on every surface.
+        let changed;
+        for (const supplied of worlds) {
+            if (supplied.path !== file)
+                continue;
+            if (postIsWholeFile || !('pre' in supplied.world))
+                changed = supplied;
+        }
+        if (changed !== undefined) {
+            if ('post' in changed.world)
+                values[name] = changed.world.post;
+            continue;
+        }
+        const supplied = world?.files?.[file];
+        if (supplied !== undefined)
+            values[name] = supplied;
+    }
+    return values;
+}
+/** The first non-pass world of one input, or pass — what the body reports and the valve reads. */
+/**
+ * Judge one declaration over the worlds an input admits, first non-pass world wins.
+ *
+ * A supply-passed world does not stop the loop — a later world may still break, and a break
+ * outranks a skip. `supply-pass` is the answer only when no world was judged at all: exit 0
+ * with a `passed` row would read as a covenant upheld.
+ */
+function judgeAdmitted(compiled, worlds) {
+    let suppliedPast = false;
+    let judgedAny = false;
+    for (const supplied of worlds) {
+        const verdict = judgeDeclaration({ compiled, world: supplied.world });
+        if (verdict.kind === 'broken')
+            return { kind: 'broken', supplied, breaks: verdict.breaks };
+        if (verdict.kind === 'supply-error') {
+            return { kind: 'unjudgeable', supplied, source: verdict.source, reason: verdict.reason };
+        }
+        if (verdict.kind === 'not-applicable' && verdict.reason === 'supply-pass') {
+            suppliedPast = true;
+        }
+        else if (verdict.kind === 'pass') {
+            judgedAny = true;
+        }
+    }
+    return suppliedPast && !judgedAny ? { kind: 'supply-pass' } : { kind: 'pass' };
+}
+/**
+ * Compile one declaration entry into its registration.
+ *
+ * An assembly fault is the author's mistake, so it becomes a skip that names its location
+ * on stderr and routes nothing: a declaration that could never judge must not record a
+ * `skipped` row per change as though the call were at fault. Otherwise routing and judging
+ * share the declaration's own scope — the subject is the first world it admits, and the
+ * body walks every admitted world in input order, reporting the first that breaks.
+ *
+ * The declaration's `witness` block joins the injected valve with OR: either the human's
+ * pass condition or the declaration's own opens a blocked verdict — the declaration's on
+ * the very world the body reported broken, never on an unjudgeable one.
+ */
+function declareRegistration(entry, spec, witness, nameFault, enrich) {
+    const compiled = compileEntryDeclaration(entry);
+    if (isFault(compiled)) {
+        const reason = `${compiled.location}: ${compiled.reason}`;
+        nameFault(reason);
+        return {
+            label: entry.id,
+            protectedPaths: [],
+            matches: () => null,
+            ...witness,
+            skip: { reason, kind: 'config-fault' },
+        };
+    }
+    const bindings = sourceBindings(entry);
+    const opts = {
+        rootDir: spec.rootDir,
+        shellTools: spec.shellTools,
+        commandArgs: spec.commandArgs,
+        readPreState: spec.readPreState,
+    };
+    // One derivation per input, shared by routing, the body, and the valve: the valve must
+    // see the same first non-pass world the body reported — a valve that re-judged on its
+    // own could open on a later break while the body had stopped at an unjudgeable world.
+    //
+    // The input is enriched first, so a computable shell write reaches the declaration as an
+    // ordinary file change: without it a Bash call carries no world and the write passes with
+    // no row. A path the same command also writes uncomputably is the skip arm's, so its
+    // derived world is dropped here. An unreadable pre-state throws out of here and the body
+    // turns it into the cannot-judge exit, never a quiet pass.
+    //
+    // The named sources join the world here rather than in `worldsFromInput`: what a source
+    // name means is this declaration's own binding, and the fixed world knows none of them.
+    const admittedOf = new WeakMap();
+    const admitted = (input) => {
+        const cached = admittedOf.get(input);
+        if (cached !== undefined)
+            return cached;
+        const owned = uncomputablePaths(deriveShellSignals(input, opts), spec.rootDir);
+        const fixed = worldsFromInput({
+            input: enrich(input),
+            rootDir: spec.rootDir,
+            shellTools: spec.shellTools,
+            commandArgs: spec.commandArgs,
+        }).filter((supplied) => !owned.has(supplied.path));
+        const values = sourceValues(bindings, fixed, input.world, spec.transcript, spec.postIsWholeFile ?? true);
+        const worlds = fixed
+            .map((supplied) => ({ path: supplied.path, world: { ...supplied.world, ...values } }))
+            .filter((supplied) => scopeAdmits(compiled, supplied.world));
+        admittedOf.set(input, worlds);
+        return worlds;
+    };
+    // Routing never consults the pre-state reader: it answers a subject, and the reader is
+    // the body's channel — asking here would read the disk once per routing pass as well.
+    // File-change evidence already carries its own worlds, and a shell write contributes the
+    // path it names; whether that write is in scope is settled from `target.path` alone.
+    //
+    // The shell fallback belongs to a surface that completes such a write. Where none does,
+    // the body would be handed no world for it and answer pass, so the write routes to this
+    // entry's skip arm instead and the missing channel is what the row records.
+    const completes = completesShellWrites(spec);
+    const route = (input) => {
+        const fixed = worldsFromInput({
+            input,
+            rootDir: spec.rootDir,
+            shellTools: spec.shellTools,
+            commandArgs: spec.commandArgs,
+        });
+        const values = sourceValues(bindings, fixed, input.world, spec.transcript, spec.postIsWholeFile ?? true);
+        const matched = fixed.find((supplied) => scopeAdmits(compiled, { ...supplied.world, ...values }))?.path;
+        if (matched !== undefined)
+            return matched;
+        return completes ? firstAdmittedShellWrite(compiled, input, opts, spec.rootDir) : null;
+    };
+    const judgedOf = new WeakMap();
+    const judged = (input) => {
+        const cached = judgedOf.get(input);
+        if (cached !== undefined)
+            return cached;
+        const result = judgeAdmitted(compiled, admitted(input));
+        judgedOf.set(input, result);
+        return result;
+    };
+    return {
+        label: entry.id,
+        protectedPaths: [],
+        ...(entry.declare?.sources !== undefined && { sources: bindings }),
+        matches: route,
+        enforce: entry.enforce ?? 'advise',
+        witness: (input, transcript, ctx) => {
+            if (spec.witness?.(input, transcript, ctx) === true)
+                return true;
+            const judgment = judged(input);
+            return (judgment.kind === 'broken' && witnessOpens({ compiled, world: judgment.supplied.world }));
+        },
+        body: async (input) => {
+            try {
+                const judgment = judged(input);
+                if (judgment.kind === 'broken') {
+                    return {
+                        exitCode: 1,
+                        reason: withWhy(`discipline '${entry.id}' broken on ${judgment.supplied.path}: ${judgment.breaks[0]?.message}`, entry.why),
+                        witnesses: judgment.breaks,
+                    };
+                }
+                if (judgment.kind === 'unjudgeable') {
+                    process.stderr.write(`discipline '${entry.id}' cannot judge ${judgment.supplied.path}: ${judgment.source} — ${judgment.reason}\n`);
+                    return UNJUDGEABLE_OUTCOME;
+                }
+                if (judgment.kind === 'supply-pass') {
+                    return { exitCode: 0, skipped: 'supply-pass' };
+                }
+                return { exitCode: 0 };
+            }
+            catch {
+                // An input no supply layer could read is unjudgeable, like every other body here.
+                return UNJUDGEABLE_OUTCOME;
+            }
+        },
+    };
+}
+/**
+ * Compile validated discipline entries into dispatcher registrations.
+ *
+ * One registration per entry: `label` = id (per-discipline telemetry), `protectedPaths`
+ * = [] (routing is the matches closure, not path mention), `body` = the judge thunk with
+ * the entry and the assembly values bound in. Each entry gains a second, body-less
+ * registration for its shell axis, and one common `shell-unjudgeable` registration is
+ * appended last whatever the entry count.
+ *
+ * An entry whose declaration does not compile becomes a **skip registration** that routes
+ * nothing and names its location on stderr. Assembly never throws — one bad entry taking
+ * down its siblings, the meta-covenants, and the witness valve would leave no way to fix
+ * the config that caused it.
+ */
+export function compileDisciplineRegistrations(spec) {
+    // One enrichment per input, shared by every declaration: the pre-state reader is opened
+    // once for a call however many entries judge it, and they all judge the same world.
+    //
+    // A surface with no pre-state channel completes no shell evidence: the enrichment's every
+    // read would answer `undefined`, which means "this location failed" and would block the
+    // call. That reading is right for a surface that has the channel and lost one location,
+    // and wrong for one that never had it — there the input's own file changes are the whole
+    // evidence, and a declaration reading nothing else judges as it would with no shell call.
+    const shell = {
+        rootDir: spec.rootDir,
+        shellTools: spec.shellTools,
+        commandArgs: spec.commandArgs,
+        readPreState: spec.readPreState,
+    };
+    const enrichedOf = new WeakMap();
+    const enrich = (input) => {
+        if (spec.observesPreState === false)
+            return input;
+        const cached = enrichedOf.get(input);
+        if (cached !== undefined)
+            return cached;
+        const enriched = enrichWithShellEvidence(input, shell);
+        enrichedOf.set(input, enriched);
+        return enriched;
+    };
+    const judged = spec.disciplines.map((entry) => {
+        const witness = spec.witness !== undefined ? { witness: spec.witness } : {};
+        // A silent skip is how a discipline goes inert while its verdict still reads passed.
+        const nameFault = (reason) => {
+            process.stderr.write(`discipline '${entry.id}': ${reason} — skipped, not judged\n`);
+        };
+        return declareRegistration(entry, spec, witness, nameFault, enrich);
+    });
+    const skipArms = spec.disciplines
+        .filter((entry) => hasShellSkipArm(entry, spec))
+        .map((entry) => shellSkipArm(entry, spec));
+    return [...judged, ...skipArms, shellUnjudgeableRegistration(spec)];
+}