polydeukes 0.6.0 → 0.7.1

package/dist/claude-code-hook.d.ts

@@ -1,79 +0,0 @@
-/**
- * `runClaudeCodeHook` — the assembled session-surface judgment runner.
- *
- * The session counterpart of {@link runCovenantCheck}, and the one place where the Claude
- * Code adapter (tool vocabulary, up-translation) and the covenant package (dispatcher +
- * judge bodies) meet. Packages stay one-way — each depends only on core — so their
- * composition lives here, in the umbrella, and the repository's PreToolUse hook shrinks to
- * a delegator that calls this function. That is what makes the session surface installable:
- * a consumer registers a hook that resolves this package instead of copying assembly.
- *
- * The protection-policy data (protectedPaths / disciplines / witness) is read from the root
- * data config through {@link loadConfig}, which also attaches the config file to its own
- * surface.
- *
- * The valve is the TTL witness, judged over the JSONL transcript provider. The judge body
- * always spawns, and only an outcome that translated to blocked consults the witness —
- * `witnessed` rows are would-block only. Its defence is provenance rather than secrecy: only
- * a real human utterance carries the transcript marking `findUserMessages()` admits.
- *
- * fail-closed: ANY failure — an unbuilt judge body, an unreadable stdin, a missing or
- * invalid config file — resolves to `{ exitCode: 2 }` with one `blocked` record under the
- * `hook` label. Nothing throws: an uncaught rejection would exit the delegator non-blocking,
- * the cheapest bypass vector there is. Recovery from an unbuilt clone is `pnpm build` (it
- * mentions no protected path, so it is never blocked).
- */
-import { type CanonicalTranscript } from '@polydeukes/core';
-import { type CovenantRegistration } from '@polydeukes/covenant';
-import { type CovenantModule } from './covenant-module.ts';
-import { loadConfig } from './load-config.ts';
-/** {@link runClaudeCodeHook} result — the exit code the hook process leaves with. */
-export type ClaudeCodeHookOutcome = {
-    exitCode: 0 | 2;
-};
-/** `runClaudeCodeHook` input — the `CovenantCheckSpec` shape, session side. */
-export type ClaudeCodeHookSpec = {
-    /** Repository root — config discovery and discipline glob scoping both anchor here. */
-    repoRoot: string;
-    /** One raw PreToolUse payload. ABSENT means read fd 0 (the hook's real stdin). */
-    rawPayload?: string;
-    /** Overrides the config's telemetry log path (tests and assembly injection). */
-    telemetryPath?: string;
-    /** Overrides the resolved covenant dist directory (tests and assembly injection). */
-    covenantDist?: string;
-};
-/** {@link assembleSessionRegistrations} input — what the session surface's assembly needs. */
-export type SessionAssemblySpec = {
-    config: ReturnType<typeof loadConfig>['config'];
-    rootDir: string;
-    /**
-     * The covenant surface the registrations are built from — the module the caller loaded
-     * from the resolved dist, so what judges a call is what that dist carries, and what
-     * `explain` renders is what would judge it.
-     */
-    covenant: CovenantModule;
-    /** The payload's transcript path. ABSENT leaves the transcript-mod registration out. */
-    transcriptPath?: string;
-    transcript?: CanonicalTranscript;
-    witness?: CovenantRegistration['witness'];
-};
-/**
- * The session surface's registration set. One assembly, two consumers: the runner below
- * dispatches it, `explain` renders it — so what a reader is shown is the table the judgment
- * actually uses, never a second opinion about it.
- */
-export declare function assembleSessionRegistrations(spec: SessionAssemblySpec): CovenantRegistration[];
-/**
- * The session-surface entry point: the post-hoc state comparison wrapped around the judgment.
- *
- * The comparison sits OUTSIDE {@link judgeHookCall}'s fail-closed try on both ends. Inside
- * it, a comparison failure would become a blocked call — the opposite of a mechanism whose
- * whole purpose is to record rather than stop — so each side carries its own catch and
- * neither can reach the verdict. Observation is fail-open, the direction
- * `appendRecordFailOpen` already established: the worst outcome is a missing datum.
- *
- * Order is the contract. The comparison runs first, so it reads the window the previous call
- * left and its rows land ahead of this call's judgment; the re-establishment runs last, so
- * this call's own judged writes are folded in rather than alarmed on next time.
- */
-export declare function runClaudeCodeHook(spec: ClaudeCodeHookSpec): Promise<ClaudeCodeHookOutcome>;

package/dist/claude-code-hook.js

@@ -1,372 +0,0 @@
-/**
- * `runClaudeCodeHook` — the assembled session-surface judgment runner.
- *
- * The session counterpart of {@link runCovenantCheck}, and the one place where the Claude
- * Code adapter (tool vocabulary, up-translation) and the covenant package (dispatcher +
- * judge bodies) meet. Packages stay one-way — each depends only on core — so their
- * composition lives here, in the umbrella, and the repository's PreToolUse hook shrinks to
- * a delegator that calls this function. That is what makes the session surface installable:
- * a consumer registers a hook that resolves this package instead of copying assembly.
- *
- * The protection-policy data (protectedPaths / disciplines / witness) is read from the root
- * data config through {@link loadConfig}, which also attaches the config file to its own
- * surface.
- *
- * The valve is the TTL witness, judged over the JSONL transcript provider. The judge body
- * always spawns, and only an outcome that translated to blocked consults the witness —
- * `witnessed` rows are would-block only. Its defence is provenance rather than secrecy: only
- * a real human utterance carries the transcript marking `findUserMessages()` admits.
- *
- * fail-closed: ANY failure — an unbuilt judge body, an unreadable stdin, a missing or
- * invalid config file — resolves to `{ exitCode: 2 }` with one `blocked` record under the
- * `hook` label. Nothing throws: an uncaught rejection would exit the delegator non-blocking,
- * the cheapest bypass vector there is. Recovery from an unbuilt clone is `pnpm build` (it
- * mentions no protected path, so it is never blocked).
- */
-import { mkdirSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { COMMAND_ARGS, MUTATING_TOOLS, runAdapterPath, SHELL_TOOLS, sessionChannelReader, sessionSourceReader, transcriptFromJsonlFile, transcriptPathFromPayload, } from '@polydeukes/adapter-claude-code';
-import { appendRecordFailOpen, DEFAULT_TELEMETRY_LOG_PATH, isPlainObject, normalizeProtectedPaths, readRecords, } from '@polydeukes/core';
-import { ttlWitness } from '@polydeukes/covenant';
-import { findUnattributed, readBaseline, snapshotBaseline, writeBaseline } from './baseline.js';
-import { loadCovenantModule, resolveCovenantDist } from './covenant-module.js';
-import { loadConfig } from './load-config.js';
-import { sessionPreStateReader } from './pre-state-reader.js';
-/** The label every post-hoc state comparison row carries. */
-const BASELINE_LABEL = 'baseline';
-/**
- * Compare the protected entries' on-disk state against the stored baseline and record what
- * moved with no judgment explaining it.
- *
- * Runs at hook call START, before this call's own judgment rows land, so the window it reads
- * is the one the previous comparison left open. Returns the record count as of right now —
- * where the NEXT window opens, which {@link updateBaseline} persists at call end.
- *
- * The comparison records, it never blocks: no row it writes and no failure it hits changes
- * a verdict or an exit code, which is why every caller keeps it outside the judgment path.
- */
-function compareBaseline(spec) {
-    const baselinePath = join(spec.repoRoot, '.polydeukes', 'baseline.json');
-    // Read before any row of this comparison lands, so the rows this call is about to write
-    // cannot fall inside the window they would then explain away.
-    const { records } = readRecords(spec.telemetryPath);
-    const stored = readBaseline(baselinePath);
-    if (stored === null) {
-        // Absence and corruption are the same signal. The baseline file is NOT on the protection
-        // list — protecting it would need a comparison of its own — so its disappearance has to
-        // stay legible in the log instead.
-        appendRecordFailOpen(spec.telemetryPath, {
-            event: 'unattributed',
-            label: BASELINE_LABEL,
-            subject: baselinePath,
-        });
-        return;
-    }
-    const changed = findUnattributed({
-        previous: stored.entries,
-        current: snapshotBaseline({ rootDir: spec.repoRoot, entries: spec.entries }),
-        records,
-        // The cut travels with the hashes it belongs to, from the one read above. Rows older
-        // than it were already spent explaining the state that snapshot recorded.
-        cutAt: stored.cutAt,
-    });
-    // One row per changed entry — an aggregate row could not say WHICH gate definition moved.
-    for (const entry of changed) {
-        appendRecordFailOpen(spec.telemetryPath, {
-            event: 'unattributed',
-            label: BASELINE_LABEL,
-            subject: entry,
-        });
-    }
-}
-/**
- * Re-establish the baseline at hook call END.
- *
- * At call end rather than right after the comparison: refreshing at comparison time would
- * miss whatever this call's own judged writes changed, leaving detection permanently one
- * call behind.
- *
- * The cut is stamped HERE, beside the snapshot, not at the comparison that opened the call.
- * Both describe the same instant — everything this call did is already folded into the
- * hashes — so the rows explaining it belong before the cut. Stamping the earlier instant
- * instead would re-admit this call's own judgment rows into the next window, where they
- * would attribute a change they had nothing to do with: a call that merely MENTIONED a
- * protected entry would then absolve any tamper that followed it.
- */
-function updateBaseline(spec) {
-    const dotDir = join(spec.repoRoot, '.polydeukes');
-    mkdirSync(dotDir, { recursive: true });
-    writeBaseline(join(dotDir, 'baseline.json'), snapshotBaseline({ rootDir: spec.repoRoot, entries: spec.entries }), new Date().toISOString());
-}
-/**
- * Where the comparison writes and what it observes, or `undefined`.
- *
- * The domain is derived from config rather than enumerated here, and the telemetry path is
- * resolved by the same precedence the judgment uses so both land in one log. A config that
- * does not load leaves NO domain, so there is nothing to compare and nothing to re-establish
- * — the judgment path already answers that failure fail-closed, and a comparison row on top
- * of it would report the same absence twice under a label that judges nothing.
- */
-function comparisonSpec(spec) {
-    let config;
-    try {
-        config = loadConfig({ rootDir: spec.repoRoot }).config;
-    }
-    catch {
-        return undefined;
-    }
-    return {
-        repoRoot: spec.repoRoot,
-        telemetryPath: spec.telemetryPath ??
-            process.env.POLYDEUKES_TELEMETRY_PATH ??
-            resolve(spec.repoRoot, config.telemetry.logPath),
-        entries: normalizeProtectedPaths({ protectedPaths: config.protectedPaths }),
-    };
-}
-/**
- * The session surface's registration set. One assembly, two consumers: the runner below
- * dispatches it, `explain` renders it — so what a reader is shown is the table the judgment
- * actually uses, never a second opinion about it.
- */
-export function assembleSessionRegistrations(spec) {
-    const { config, rootDir, covenant, transcriptPath, transcript, witness } = spec;
-    // The live transcript is the session a history declaration reads AND the one the witness
-    // reads, so erasing or forging it disables every history discipline while opening or
-    // shutting the human valve on the same file. It must NOT join this list: it lives deep
-    // under HOME, and a path entry makes every ancestor protected — which measured as an
-    // over-block refusing `cd /home/<user>`, `echo $HOME`, and every edit whose content
-    // carried a bare `~`. The dedicated `transcript-mod` registration below covers that one
-    // file instead: equality-only, never an ancestor. Ancestor destruction outside the
-    // repository is out of observation scope — the agent's own deny policy owns what no
-    // repo-scoped judge can reach.
-    const protectedPaths = normalizeProtectedPaths({
-        protectedPaths: config.protectedPaths ?? [],
-    });
-    const disciplines = config.disciplines ?? [];
-    const registrations = [
-        covenant.selfModRegistration({
-            protectedPaths,
-            mutatingToolNames: MUTATING_TOOLS,
-            witness,
-        }),
-        covenant.shellModRegistration({
-            protectedPaths,
-            shellTools: SHELL_TOOLS,
-            commandArgs: COMMAND_ARGS,
-            witness,
-        }),
-        // Routing is the matches predicate, never path mention, so the home directory cannot
-        // become a protected ancestor. No transcript in the payload means nothing to protect —
-        // the valve and every history declaration already forfeited on the same absence.
-        ...(transcriptPath === undefined
-            ? []
-            : [
-                covenant.transcriptModRegistration({
-                    transcriptPath,
-                    // The env value first, since that is what the judged shell expands `~` and
-                    // `$HOME` from. `homedir()` reads the same passwd entry bash falls back to when
-                    // HOME is unset, so a hook spawned without an environment (a service manager,
-                    // `env -i`) keeps judging the home spellings instead of silently going
-                    // absolute-only — an inert spelling closure looks identical to a passing call.
-                    home: process.env.HOME ?? homedir(),
-                    shellTools: SHELL_TOOLS,
-                    commandArgs: COMMAND_ARGS,
-                    mutatingTools: MUTATING_TOOLS,
-                    witness,
-                }),
-            ]),
-        ...covenant.compileDisciplineRegistrations({
-            disciplines,
-            rootDir,
-            shellTools: SHELL_TOOLS,
-            commandArgs: COMMAND_ARGS,
-            readPreState: sessionPreStateReader,
-            // One PreToolUse call is the whole observation, so the derived change set is a
-            // singleton and a change-set declaration cannot be judged here — it records `skipped`,
-            // the shape the commit surface gives a history declaration.
-            observesChangeSet: false,
-            witness,
-            // The session itself, injected rather than its path: a declaration reading a
-            // `transcript` binding sees it flattened, and passing a path would leak JSONL
-            // knowledge into covenant.
-            transcript,
-        }),
-    ];
-    return registrations;
-}
-/**
- * This runtime's mutating+shell roster, rewritten onto the Claude vocabulary the adapter
- * already judges. Claude names are not keys, so an existing Write/Edit/Bash envelope
- * passes through. A name outside the table is left alone — that is a declared limit,
- * recorded as the adapter's funnel pass, never a parse fault. The map lives here, not in
- * the adapter, so the adapter stays Claude-vocabulary-only.
- */
-const GROK_TOOL_NAME_MAP = {
-    write: 'Write',
-    search_replace: 'Edit',
-    run_terminal_command: 'Bash',
-};
-/**
- * Rewrite Grok tool names in a raw PreToolUse payload. Invalid JSON is left as the original
- * string so the existing fail-closed path still runs — this function must not throw.
- */
-function rewriteGrokToolNames(rawPayload) {
-    let parsed;
-    try {
-        parsed = JSON.parse(rawPayload);
-    }
-    catch {
-        return rawPayload;
-    }
-    if (!isPlainObject(parsed))
-        return rawPayload;
-    for (const key of ['tool_name', 'toolName']) {
-        const value = parsed[key];
-        if (typeof value !== 'string')
-            continue;
-        const mapped = GROK_TOOL_NAME_MAP[value];
-        if (mapped !== undefined)
-            parsed[key] = mapped;
-    }
-    return JSON.stringify(parsed);
-}
-/**
- * Judge one declared tool call before it runs. Async because the dispatcher spawns covenant
- * bodies — a synchronous runner would mean reimplementing the judge, which the
- * single-dispatcher principle forbids.
- */
-async function judgeHookCall(spec) {
-    // Env-first telemetry precedence, settled BEFORE any failure branch: a config that never
-    // loads still has somewhere to write its one blocked row. The config value applies after
-    // the load succeeds.
-    //
-    // Computed INSIDE the try even though it must run first, because `join` throws on a
-    // non-string repoRoot and this function's contract is that nothing escapes it — a rejection
-    // would exit a delegator non-blocking, which is the cheapest bypass there is. A throw here
-    // leaves `telemetryPath` undefined, which the catch tolerates: there is no root to write a
-    // row under anyway.
-    let telemetryPath;
-    try {
-        const envTelemetryPath = process.env.POLYDEUKES_TELEMETRY_PATH;
-        telemetryPath =
-            spec.telemetryPath ?? envTelemetryPath ?? join(spec.repoRoot, DEFAULT_TELEMETRY_LOG_PATH);
-        // Discovery + parse + validation are the loader's job; a throw here (absent, ambiguous,
-        // unparseable, or invalid config) falls into the fail-closed catch.
-        const { config } = loadConfig({ rootDir: spec.repoRoot });
-        telemetryPath =
-            spec.telemetryPath ?? envTelemetryPath ?? resolve(spec.repoRoot, config.telemetry.logPath);
-        // Settled for the rest of the happy path. The `let` above exists so the catch can still
-        // record when a failure lands before this point; a closure cannot narrow it, so the
-        // dispatch seam below takes this const instead.
-        const logPath = telemetryPath;
-        const rawPayload = rewriteGrokToolNames(spec.rawPayload ?? readFileSync(0, 'utf-8'));
-        // The transcript path travels in the raw payload only — up-translation drops it, so the
-        // adapter reads it from the string. Every failure narrows to `undefined`, which leaves
-        // the dispatcher on its `noopTranscript` default: lost evidence closes the valve rather
-        // than opening it.
-        const transcriptPath = transcriptPathFromPayload({ rawPayload });
-        const transcript = transcriptPath === undefined ? undefined : transcriptFromJsonlFile({ path: transcriptPath });
-        // One witness predicate shared by every registration: a witness is a session-wide
-        // permission the human granted, not a per-covenant one. Absent `witness` config leaves
-        // this undefined, and no verdict can be witnessed open at all. The predicate receives
-        // the transcript as its second argument from the dispatcher, which is why the transcript
-        // is injected below rather than captured here.
-        const witness = config.witness === undefined
-            ? undefined
-            : ttlWitness({
-                token: config.witness.token,
-                // Minutes are the human-facing unit in config; the predicate takes milliseconds.
-                // Core passes the value through verbatim, so the conversion belongs to assembly.
-                ttlMs: config.witness.ttlMinutes * 60_000,
-            });
-        // The judges are the covenant package's built barrel — resolved through the real
-        // package (never a test alias), so the session surface runs the same judges the commit
-        // surface does. An injected directory overrides that resolution, which is how a fixture
-        // reaches a dist that real Node resolution would never land on. Awaited HERE, before
-        // any registration is composed: a dist the barrel cannot load throws now, into the
-        // fail-closed catch, instead of leaving a half-judged table behind.
-        const covenantDist = spec.covenantDist ?? resolveCovenantDist();
-        const covenant = await loadCovenantModule(covenantDist);
-        // Assembled HERE, outside the dispatch seam: a judge takes its call set as an argument,
-        // so assembly needs no payload, and an assembly throw belongs to this function's own
-        // fail-closed catch — `hook` label, `covenant hook failed closed:` on stderr. Composed
-        // inside the dispatch closure it would land in `runAdapterPath`'s catch instead, which
-        // records the adapter's label and says nothing about what broke.
-        const registrations = assembleSessionRegistrations({
-            config,
-            rootDir: spec.repoRoot,
-            covenant,
-            transcriptPath,
-            transcript,
-            witness,
-        });
-        // The world axis: files read from disk under the repository root, channels read beside
-        // the session's transcript. The disk is the pre-edit state on this surface; the rule
-        // that the judged change's own `post` overrides it belongs to the judge, so the root
-        // supplies what it read and nothing more. No `changes` list either — one PreToolUse call
-        // is the whole observation, and the judge derives that set from the input.
-        const { files, channels } = covenant.supplySources({
-            plan: covenant.planSources({ registrations }),
-            read: sessionSourceReader({ repoRoot: spec.repoRoot }),
-            readChannel: sessionChannelReader({ transcriptPath }),
-        });
-        return await runAdapterPath({
-            rawPayload,
-            telemetryPath: logPath,
-            dispatch: (stdinPayload) => covenant.dispatchCovenants({
-                stdinPayload,
-                registrations,
-                telemetryPath: logPath,
-                transcript,
-                world: { files, channels },
-            }),
-        });
-    }
-    catch (error) {
-        process.stderr.write(`covenant hook failed closed: ${error instanceof Error ? error.message : String(error)}\n`);
-        // Honor the one-call-one-record invariant with a blocked record under the assembly's own
-        // label — never a judge's, since no judge answered. `undefined` means the failure landed
-        // before a path could even be composed (a non-string repoRoot), where there is nowhere
-        // to write and nothing to attribute the row to.
-        if (telemetryPath !== undefined) {
-            appendRecordFailOpen(telemetryPath, { event: 'blocked', label: 'hook', subject: '-' });
-        }
-        return { exitCode: 2 };
-    }
-}
-/**
- * The session-surface entry point: the post-hoc state comparison wrapped around the judgment.
- *
- * The comparison sits OUTSIDE {@link judgeHookCall}'s fail-closed try on both ends. Inside
- * it, a comparison failure would become a blocked call — the opposite of a mechanism whose
- * whole purpose is to record rather than stop — so each side carries its own catch and
- * neither can reach the verdict. Observation is fail-open, the direction
- * `appendRecordFailOpen` already established: the worst outcome is a missing datum.
- *
- * Order is the contract. The comparison runs first, so it reads the window the previous call
- * left and its rows land ahead of this call's judgment; the re-establishment runs last, so
- * this call's own judged writes are folded in rather than alarmed on next time.
- */
-export async function runClaudeCodeHook(spec) {
-    let comparison;
-    try {
-        comparison = comparisonSpec(spec);
-        if (comparison !== undefined) {
-            compareBaseline(comparison);
-        }
-    }
-    catch {
-        // fail-open: a comparison that could not run leaves the judgment exactly as it was.
-    }
-    const result = await judgeHookCall(spec);
-    try {
-        if (comparison !== undefined) {
-            updateBaseline(comparison);
-        }
-    }
-    catch {
-        // fail-open: an unwritable baseline costs the next call's detection, never this verdict.
-    }
-    return result;
-}

package/dist/claude-code.d.ts

@@ -1,6 +0,0 @@
-/**
- * `polydeukes/claude-code` — the session surface's entry point.
- *
- * The delegator a consumer project's PreToolUse hook imports: one verb and its spec type.
- */
-export { type ClaudeCodeHookOutcome, type ClaudeCodeHookSpec, runClaudeCodeHook, } from './claude-code-hook.ts';

package/dist/claude-code.js

@@ -1,6 +0,0 @@
-/**
- * `polydeukes/claude-code` — the session surface's entry point.
- *
- * The delegator a consumer project's PreToolUse hook imports: one verb and its spec type.
- */
-export { runClaudeCodeHook, } from './claude-code-hook.js';

package/dist/covenant-module.d.ts

@@ -1,25 +0,0 @@
-/**
- * The covenant package as a resolved artifact — the existence proof both composition roots
- * share.
- *
- * What the roots prove is the package IMPORT itself. The barrel is eager: a dist missing one
- * of the modules it references throws on import, before any assembly can compose a
- * registration, and the surface's own fail-closed catch records that as one `blocked` row. A
- * partially loaded judge set has no representation here — an ESM import either fully succeeds
- * or throws.
- *
- * The `covenantDist` seam selects WHICH dist is imported, so a fixture can inject a gutted
- * mirror where real Node resolution would always land on the healthy build.
- */
-import type * as covenant from '@polydeukes/covenant';
-/** The covenant surface both roots assemble against — the members they call, and no more. */
-export type CovenantModule = Pick<typeof covenant, 'dispatchCovenants' | 'compileDisciplineRegistrations' | 'selfModRegistration' | 'shellModRegistration' | 'transcriptModRegistration' | 'planSources' | 'supplySources'>;
-/** Where real Node resolution puts the covenant package's built barrel. */
-export declare function resolveCovenantDist(): string;
-/**
- * Import the covenant barrel from `distDir`, naming the recovery command when it will not
- * load. The message carries the loader's own text, which names the module that is missing;
- * a reader locked out by an unbuilt or half-built dist needs both that name and the one
- * command that fixes it.
- */
-export declare function loadCovenantModule(distDir: string): Promise<CovenantModule>;

package/dist/covenant-module.js

@@ -1,42 +0,0 @@
-/**
- * The covenant package as a resolved artifact — the existence proof both composition roots
- * share.
- *
- * What the roots prove is the package IMPORT itself. The barrel is eager: a dist missing one
- * of the modules it references throws on import, before any assembly can compose a
- * registration, and the surface's own fail-closed catch records that as one `blocked` row. A
- * partially loaded judge set has no representation here — an ESM import either fully succeeds
- * or throws.
- *
- * The `covenantDist` seam selects WHICH dist is imported, so a fixture can inject a gutted
- * mirror where real Node resolution would always land on the healthy build.
- */
-var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
-    if (typeof path === "string" && /^\.\.?\//.test(path)) {
-        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
-            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
-        });
-    }
-    return path;
-};
-import { createRequire } from 'node:module';
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-/** Where real Node resolution puts the covenant package's built barrel. */
-export function resolveCovenantDist() {
-    return join(createRequire(import.meta.url).resolve('@polydeukes/covenant'), '..');
-}
-/**
- * Import the covenant barrel from `distDir`, naming the recovery command when it will not
- * load. The message carries the loader's own text, which names the module that is missing;
- * a reader locked out by an unbuilt or half-built dist needs both that name and the one
- * command that fixes it.
- */
-export async function loadCovenantModule(distDir) {
-    try {
-        return (await import(__rewriteRelativeImportExtension(pathToFileURL(join(distDir, 'index.js')).href)));
-    }
-    catch (error) {
-        throw new Error(`the covenant judges could not be loaded from ${distDir} — run 'pnpm build' to rebuild them: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/dist/docs/configuration.md

@@ -1,103 +0,0 @@
-# Configuring Polydeukes
-
-**English** · [한국어](./configuration.ko.md)
-
-> Alpha. This guide covers the config surface as shipped today (schema v2, loader, and
-> the declaration grammar). Fields and steps will grow; what is
-> written here is tested and enforced now.
-
-`polydeukes.config.yaml` is the one file where a project declares its disciplines — the
-promises the human and the AI partner both agree to be bound by. It is **data, not code**:
-nothing in it can compute, so nothing in it can lie. The core validates it, the covenant
-package enforces it, and every judgment it causes is measured.
-
-This is the guide layer: the file itself, how discovery fails, the IDE wiring, and what
-enforcement looks like. Every key, with its full rules and pitfalls, lives in
-[the configuration reference](./reference/configuration.md).
-
-## The file
-
-Put exactly one of these at the project root:
-
-| Filename | Note |
-|---|---|
-| `polydeukes.config.yaml` | canonical |
-| `polydeukes.config.yml` | accepted variant |
-| `polydeukes.config.json` | accepted variant (read by the same parser — YAML is a JSON superset) |
-
-Discovery is deliberately strict, and every failure refuses loudly instead of guessing:
-
-- **No config found** → error naming all three candidate filenames. A missing config never
-  silently loads defaults — silent defaults would mean silently unprotected.
-- **More than one found** → error naming the collisions. Ambiguity never picks a winner.
-- **Parse error, or a custom YAML tag** → error naming the file. Custom tags are rejected
-  even though the parser cannot execute them — config data stays uncomputable by contract.
-- **Schema violation** → error naming the key and the file. Unknown keys are rejected
-  wherever the core owns the vocabulary — the top level, and the fixed keys inside a
-  discipline entry — so `protectedPath:` for `protectedPaths:`, or `adaptors:` for
-  `adapters:`, is caught here. Two maps stay open, because their keys are your values
-  rather than the core's: language names under `languages`, and adapter names under
-  `adapters`. A misspelt adapter name is accepted and its block simply goes unread, which
-  leaves that adapter on its defaults — check the name against the adapter's own reference.
-  Inside a namespace the vocabulary belongs to that adapter: the core passes contents
-  through verbatim, and the adapter's own validator rejects what it does not recognise,
-  naming the full field path (see
-  [the `adapters` reference](./reference/configuration.md#adapters)).
-
-## IDE support
-
-The JSON Schema gives autocompletion and validation in editors. It ships inside the
-`polydeukes` package, so the line names a path into your own `node_modules`:
-
-```yaml
-# yaml-language-server: $schema=node_modules/polydeukes/dist/schema/polydeukes.schema.json
-```
-
-For a JSON config, use the standard top-level key instead. The loader accepts it and drops
-it from the resolved config:
-
-```json
-{ "$schema": "node_modules/polydeukes/dist/schema/polydeukes.schema.json" }
-```
-
-**The path is resolved against the directory your config sits in**, not against a project
-root the editor infers. The spelling above is right when the two are the same place. When
-they are not — a config in a monorepo sub-package whose dependencies installed at the
-workspace root — count the levels up yourself:
-
-```yaml
-# yaml-language-server: $schema=../../node_modules/polydeukes/dist/schema/polydeukes.schema.json
-```
-
-`pdks init claude-code` writes the line only when the schema is where the plain spelling
-names it. If the generated config has no such line, that is the case above, and the prefix
-is yours to add — an unresolvable path costs you validation without reporting anything.
-
-If you installed `@polydeukes/core` directly rather than the umbrella, name its own copy:
-
-```yaml
-# yaml-language-server: $schema=node_modules/@polydeukes/core/schema/polydeukes.schema.json
-```
-
-Every value here is a **file path**, not a module specifier: `$schema` is a static string an
-editor reads, so no module resolver runs on it. Code that reads the schema at runtime uses
-the package subpath `polydeukes/schema.json` instead.
-
-## What enforcement looks like
-
-A `disciplines:` entry lands at **advise** by default: a break is recorded as `advised`
-with the discipline's `id` in the telemetry record, the break message with its `why` goes
-to stderr, and the call proceeds (exit 0) — the judgment measures instead of stopping.
-Writing `enforce: block` on an entry is the promotion: that entry then **blocks (exit 2)**
-before the call runs. The sanctioned valve on a block is the witness — a human supplying
-the pass condition on a judgment that actually blocked, recorded as `witnessed` — never
-silent.
-
-What blocks without being asked is the judging chain's own protection, a finite list: the
-`protectedPaths` entries (tool-axis and shell-axis mutations, and mentions without a
-read-only head), the session transcript, and the assembly itself — a missing, ambiguous, or
-invalid config, an unbuilt judge, an unparseable payload, or a routing that could not
-answer. At either level the system fails closed on these, because a dead gate that waves
-things through is the cheapest bypass of all. On the commit surface `adapters.git.enforce: advise` relaxes
-the protected-path verdicts to `advised` as well — it is the observer's setting — while an
-assembly that cannot judge still fails closed.