@polydeukes/core 0.4.0 → 0.6.0

package/dist/config.js

@@ -1,31 +1,19 @@
 /**
- * Config schema v2 + `defineConfig()` validator — config as data (CONFIG-04).
+ * Config schema and the `defineConfig()` validator — config as data.
  *
- * This is the single settings surface the three areas share (covenant's `protectedPaths`,
- * ledger's `testCmd`, memory's ticket pattern all reference this shape). Since schema v2 the
- * input is pure JSON-representable data: `testCmd` is a `{scope}` template string, and
- * `defineConfig` is the runtime validator for parsed unknown data (the CONFIG-03 loader feeds
- * it values the compiler never saw). It stays a pure function — zero file I/O, zero runtime
- * dependencies (hand-rolled validation; the published JSON Schema is a sibling artifact the
- * source never reads).
+ * The single settings surface the areas share. The input is pure JSON-representable data,
+ * and `defineConfig` is the runtime validator for parsed unknown values the compiler never
+ * 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';
-/** Conventional default telemetry log path (PRD §4.3) — local-only observation data. */
+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 (PRD §4.3).
- *
- * 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';
-    }
-}
-/** The exact key vocabulary of each object level — anything else is a typo, rejected loudly. */
+/** 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([
     '$schema',
     'languages',
@@ -38,44 +26,18 @@ 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',
-    'in',
-    'except',
-    'forbid',
-    'immutable',
-    'forbidCommand',
-    'when',
-    'requirePrecedent',
-]);
-const PREDICATE_KEYS = ['forbid', 'immutable', 'forbidCommand', 'requirePrecedent'];
-/** Predicate families that `in`/`except` may scope — delta and context (COVENANT-13 §4.1). */
-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');
-}
+const DISCIPLINE_KEYS = new Set(['id', 'why', 'enforce', 'declare']);
+const DRAFT_KEYS = new Set(['id', 'why', 'draft']);
+const ENFORCE_LEVELS = new Set(['block', 'advise']);
 /** 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;
+        return isNonEmptyString(glob);
     }
-    if (Array.isArray(glob)) {
-        return glob.length > 0 && glob.every((entry) => typeof entry === 'string' && entry.length > 0);
-    }
-    return false;
+    return Array.isArray(glob) && glob.length > 0 && glob.every(isNonEmptyString);
 }
 /**
- * Compile a `{scope}` template into the callable consumers use (PRD §4.2).
+ * Compile a `{scope}` template into the callable consumers use.
  *
  * Exactly the literal token `{scope}` is substituted, at every occurrence (`replaceAll`
  * semantics). Other braces (`${VAR}`, `{a,b}`, `awk '{print}'`) are the shell's own
@@ -86,49 +48,63 @@ 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);
+/** 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: `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}')`);
+        }
+    }
+    if (entry.draft !== true) {
+        throw new ConfigValidationError(`${location} draft must be the literal true`);
+    }
+    if (typeof entry.why !== 'string' || entry.why.length === 0) {
+        throw new ConfigValidationError(`${location} why must be a non-empty string on a draft entry — the prose is its whole body`);
+    }
+    return { id, why: entry.why, draft: true };
+}
+/** 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`);
     }
-    catch {
-        throw new ConfigValidationError(`${location} must be a compilable regular expression`);
+    if (entry.enforce !== undefined &&
+        (typeof entry.enforce !== 'string' || !ENFORCE_LEVELS.has(entry.enforce))) {
+        throw new ConfigValidationError(`${location} enforce must be 'block' or 'advise'`);
     }
 }
 /**
- * Validate a context-family `requirePrecedent` value (COVENANT-13 §4.1).
+ * Validate a judged entry's declaration by delegating the block to the algebra validator.
  *
- * 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 (CONFIG-07 layering). An unrecognized evidence key fails closed at
- * assembly time, not here.
+ * 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 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`);
+function validateDeclareEntry(entry, location) {
+    const block = entry.declare;
+    if (!isPlainObject(block)) {
+        throw new ConfigValidationError(`${location} declare must be an object`);
     }
-    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`);
+    if ('discipline' in block) {
+        throw new ConfigValidationError(`${location} declare must not carry discipline — the entry id is the name`);
     }
+    validateAlgebraDeclaration({ discipline: entry.id, ...block }, `${location} declare`);
 }
 /**
- * Validate the `disciplines` array (COVENANT-10 §4.1). Throws {@link ConfigValidationError}
- * naming the offending entry/key; the validated data passes through verbatim.
+ * Validate the `disciplines` array and split judged entries from drafts. Throws
+ * {@link ConfigValidationError} naming the offending entry/key; the validated data passes
+ * through verbatim, in declaration order.
  */
 function validateDisciplines(disciplines) {
     if (!Array.isArray(disciplines)) {
         throw new ConfigValidationError('disciplines must be an array');
     }
+    const judged = [];
+    const drafts = [];
     const seenIds = new Set();
     disciplines.forEach((entry, index) => {
         if (!isPlainObject(entry)) {
@@ -141,93 +117,26 @@ function validateDisciplines(disciplines) {
         if (seenIds.has(entry.id)) {
             throw new ConfigValidationError(`${location} duplicates the id of an earlier entry`);
         }
-        seenIds.add(entry.id);
-        rejectUnknownKeys(entry, DISCIPLINE_KEYS, location);
-        if (entry.why !== undefined && typeof entry.why !== 'string') {
-            throw new ConfigValidationError(`${location} why must be a string`);
-        }
-        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`);
+        // The three meta-covenant registrations share the telemetry label space with
+        // discipline ids; a colliding id would make gain aggregation and any label-keyed
+        // reader (pdks explain) ambiguous.
+        if (META_COVENANT_LABELS.includes(entry.id)) {
+            throw new ConfigValidationError(`${location} id collides with a meta-covenant label`);
         }
-        if (entry.except !== undefined && !isValidGlob(entry.except)) {
-            throw new ConfigValidationError(`${location} except must be a non-empty glob or glob array`);
-        }
-        if (predicate === 'forbid') {
-            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)) {
-                // Only the { added } direction exists before COVENANT-12.
-                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`);
-            }
-        }
-        else if (predicate === 'immutable') {
-            if (!isValidGlob(entry.immutable)) {
-                throw new ConfigValidationError(`${location} immutable must be a non-empty glob or glob array`);
-            }
-        }
-        else if (predicate === 'forbidCommand') {
-            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`);
-            }
-            rejectUncompilableRegex(entry.forbidCommand, `${location} forbidCommand`);
-        }
-        else {
-            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`);
-            }
-            validateRequirePrecedent(entry.requirePrecedent, location);
+        seenIds.add(entry.id);
+        // Selected by the marker's value, so an explicit `draft: undefined` is absence,
+        // like every other optional key in this validator.
+        if (entry.draft !== undefined) {
+            drafts.push(validateDraft(entry, entry.id, location));
+            return;
         }
+        validateEntryHead(entry, location);
+        validateDeclareEntry(entry, location);
+        judged.push(entry);
     });
-    return disciplines;
+    return { judged, drafts };
 }
-/**
- * Validate the `languages` map and compile each profile's `{scope}` template (PRD §4.1).
- */
+/** Validate the `languages` map and compile each profile's `{scope}` template. */
 function validateLanguages(languages) {
     if (!isPlainObject(languages) || Object.keys(languages).length === 0) {
         throw new ConfigValidationError('languages must be a non-empty object');
@@ -268,8 +177,8 @@ function validateProtectedPaths(protectedPaths) {
     return protectedPaths;
 }
 /**
- * Validate the `adapters` map (CONFIG-07 layering) — each namespace is a plain object whose
- * contents belong to that adapter's own validator, so they pass through verbatim.
+ * Validate the `adapters` map — each namespace is a plain object whose contents belong to
+ * that adapter's own validator, so they pass through verbatim.
  */
 function validateAdapters(adapters) {
     // Array first: the removed directory-list form deserves a migration hint, not a
@@ -302,7 +211,7 @@ function validateTelemetry(telemetry) {
     }
     return telemetry.logPath;
 }
-/** Validate the `witness` section (CONFIG-05) — both values are consumed at assembly time. */
+/** Validate the `witness` section — both values are consumed at assembly time. */
 function validateWitness(witness) {
     if (!isPlainObject(witness)) {
         throw new ConfigValidationError('witness must be an object');
@@ -319,8 +228,7 @@ function validateWitness(witness) {
 }
 /**
  * Validate parsed unknown data as a {@link PolydeukesConfig} and return a
- * {@link ResolvedConfig} with defaults filled and templates compiled (PRD §4.3).
- * Pure — no file I/O.
+ * {@link ResolvedConfig} with defaults filled and templates compiled. Pure — no file I/O.
  *
  * Throws {@link ConfigValidationError} (naming the offending field path) when the top level
  * is not a plain object, any object level carries an unknown key, `languages` is
@@ -334,15 +242,17 @@ export function defineConfig(config) {
         throw new ConfigValidationError('config must be a plain object');
     }
     rejectUnknownKeys(config, TOP_LEVEL_KEYS, 'config');
-    // `$schema` is an IDE schema reference (CONFIG-03): accepted, type-checked, and
-    // ignored — it never appears in the resolution output.
+    // `$schema` is an IDE schema reference: accepted, type-checked, and ignored — it never
+    // appears in the resolution output.
     if (config.$schema !== undefined && typeof config.$schema !== 'string') {
         throw new ConfigValidationError('$schema must be a string');
     }
     const resolvedLanguages = validateLanguages(config.languages);
     const protectedPaths = config.protectedPaths !== undefined ? validateProtectedPaths(config.protectedPaths) : undefined;
     const adapters = config.adapters !== undefined ? validateAdapters(config.adapters) : undefined;
-    const disciplines = config.disciplines !== undefined ? validateDisciplines(config.disciplines) : undefined;
+    const split = config.disciplines !== undefined ? validateDisciplines(config.disciplines) : undefined;
+    const disciplines = split?.judged;
+    const drafts = split !== undefined && split.drafts.length > 0 ? split.drafts : undefined;
     const logPath = config.telemetry !== undefined ? validateTelemetry(config.telemetry) : undefined;
     const witness = config.witness !== undefined ? validateWitness(config.witness) : undefined;
     return {
@@ -353,6 +263,7 @@ export function defineConfig(config) {
             logPath: logPath ?? DEFAULT_TELEMETRY_LOG_PATH,
         },
         ...(disciplines !== undefined && { disciplines }),
+        ...(drafts !== undefined && { drafts }),
         ...(witness !== undefined && { witness }),
     };
 }

package/dist/exit-codes.d.ts

@@ -1,16 +1,16 @@
 /**
- * exit-codes — the covenant protocol's exit-code vocabulary (CORE-01 PRD §4.1).
+ * exit-codes — the covenant protocol's exit-code vocabulary.
  *
- * 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 (COVENANT-01), never the core's. The sole place
- * the core itself reaches for `2` is the fail-closed parse path in the barrel.
+ * 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 `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 cycle — the constants read as `undefined` depending on which module
- * the runtime evaluates first (CLEANUP-01 F1). The barrel re-exports them, so every
- * consumer outside core still reaches them at the same path.
+ * 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.
  */
 /** Promise upheld — no violation, the edit/push passes. */
 export declare const EXIT_UPHOLD = 0;

package/dist/exit-codes.js

@@ -1,16 +1,16 @@
 /**
- * exit-codes — the covenant protocol's exit-code vocabulary (CORE-01 PRD §4.1).
+ * exit-codes — the covenant protocol's exit-code vocabulary.
  *
- * 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 (COVENANT-01), never the core's. The sole place
- * the core itself reaches for `2` is the fail-closed parse path in the barrel.
+ * 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 `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 cycle — the constants read as `undefined` depending on which module
- * the runtime evaluates first (CLEANUP-01 F1). The barrel re-exports them, so every
- * consumer outside core still reaches them at the same path.
+ * 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.
  */
 /** Promise upheld — no violation, the edit/push passes. */
 export const EXIT_UPHOLD = 0;

package/dist/fail-policy.d.ts

@@ -1,5 +1,5 @@
 /**
- * fail-policy — the failure-kind → fail-mode policy table (CORE-03).
+ * fail-policy — the failure-kind → fail-mode policy table.
  *
  * Pure and total: classifying a failure and mapping it to an exit code never
  * performs I/O and never throws. The single source of truth for "which failures
@@ -8,7 +8,7 @@
 /** How a failure resolves: 'open' passes the call through, 'closed' blocks it. */
 export type FailMode = 'open' | 'closed';
 /**
- * The registered failure kinds (PRD §4.1). Gate-integrity failures
+ * The registered failure kinds. Gate-integrity failures
  * (evidence-absence / input-parse / undecidable-structure) fail closed;
  * observability failures fail open so measurement loss never holds work hostage.
  */
@@ -16,14 +16,14 @@ export type FailureKind = 'evidence-absence' | 'input-parse' | 'undecidable-stru
 /**
  * Resolve a failure kind to its {@link FailMode} via the policy table.
  *
- * fail-closed default (PRD §5.2): any unregistered kind — including '' and
- * prototype-pollution keys — resolves to 'closed'. "Cannot classify" means
- * block. Pure and total (PRD §7): never throws, no I/O, no logging.
+ * fail-closed default: any unregistered kind — including '' and prototype-pollution
+ * keys — resolves to 'closed'. "Cannot classify" means block. Pure and total: never
+ * throws, no I/O, no logging.
  */
 export declare function resolveFailMode(kind: string): FailMode;
 /**
- * Map a {@link FailMode} to the covenant protocol's exit code (PRD §4.2):
+ * Map a {@link FailMode} to the covenant protocol's exit code:
  * 'open' → {@link EXIT_UPHOLD}, 'closed' → {@link EXIT_BREAK_BLOCKING}.
- * Reuses CORE-01's constants — no independent numeric literals here.
+ * Reuses the protocol's constants — no independent numeric literals here.
  */
 export declare function failModeToExitCode(mode: FailMode): 0 | 2;

package/dist/fail-policy.js

@@ -1,5 +1,5 @@
 /**
- * fail-policy — the failure-kind → fail-mode policy table (CORE-03).
+ * fail-policy — the failure-kind → fail-mode policy table.
  *
  * Pure and total: classifying a failure and mapping it to an exit code never
  * performs I/O and never throws. The single source of truth for "which failures
@@ -7,7 +7,7 @@
  */
 import { EXIT_BREAK_BLOCKING, EXIT_UPHOLD } from './exit-codes.js';
 /**
- * Policy table (PRD §4.1). Null-prototype so lookups can never reach
+ * Policy table. Null-prototype so lookups can never reach
  * Object.prototype members ('__proto__', 'toString', …) — those must resolve
  * to the fail-closed default, not to an inherited function.
  */
@@ -20,17 +20,17 @@ const FAIL_POLICY = Object.assign(Object.create(null), {
 /**
  * Resolve a failure kind to its {@link FailMode} via the policy table.
  *
- * fail-closed default (PRD §5.2): any unregistered kind — including '' and
- * prototype-pollution keys — resolves to 'closed'. "Cannot classify" means
- * block. Pure and total (PRD §7): never throws, no I/O, no logging.
+ * fail-closed default: any unregistered kind — including '' and prototype-pollution
+ * keys — resolves to 'closed'. "Cannot classify" means block. Pure and total: never
+ * throws, no I/O, no logging.
  */
 export function resolveFailMode(kind) {
     return FAIL_POLICY[kind] ?? 'closed';
 }
 /**
- * Map a {@link FailMode} to the covenant protocol's exit code (PRD §4.2):
+ * Map a {@link FailMode} to the covenant protocol's exit code:
  * 'open' → {@link EXIT_UPHOLD}, 'closed' → {@link EXIT_BREAK_BLOCKING}.
- * Reuses CORE-01's constants — no independent numeric literals here.
+ * Reuses the protocol's constants — no independent numeric literals here.
  */
 export function failModeToExitCode(mode) {
     return mode === 'open' ? EXIT_UPHOLD : EXIT_BREAK_BLOCKING;

package/dist/index.d.ts

@@ -1,104 +1,18 @@
 /**
  * @polydeukes/core — the thin, domain- and agent-agnostic core.
  *
- * Pre-alpha. The covenant protocol (CORE-01) landed first, then the ROI telemetry
- * collector (CORE-02) and the config loader (CONFIG-01). Pure types and functions,
- * except telemetry's confined I/O functions (appendRecord / readRecords /
- * appendRecordFailOpen — the fail-open wrapper promoted by CORE-05).
+ * Alpha. Carries the covenant protocol, the ROI telemetry collector, and the config
+ * schema. Pure types and functions, except telemetry's confined I/O functions
+ * (appendRecord / readRecords / appendRecordFailOpen).
  * See https://github.com/huskyhoochu/polydeukes
  */
-export { ConfigValidationError, DEFAULT_TELEMETRY_LOG_PATH, type DisciplineEntry, type DisciplineForbid, defineConfig, type LanguageProfile, type PolydeukesConfig, type ResolvedConfig, type ResolvedLanguageProfile, } from './config.js';
-export { EXIT_BREAK_BLOCKING, EXIT_BREAK_NON_BLOCKING, EXIT_UPHOLD, } from './exit-codes.js';
-export { type FailMode, type FailureKind, failModeToExitCode, resolveFailMode, } from './fail-policy.js';
-export { isPlainObject } from './is-plain-object.js';
-export { normalizeProtectedPaths } from './protected-paths.js';
-export { aggregateGain, appendRecord, appendRecordFailOpen, formatRecordLine, type GainSummary, parseRecordLine, readRecords, runGain, type TelemetryEvent, type TelemetryRecord, } from './telemetry.js';
-export { type CanonicalTranscript, noopTranscript, type SubagentInvocation, type TranscriptToolCall, type TranscriptUserMessage, transcriptFromInput, } from './transcript.js';
-/**
- * `FileChange` — one file's mutation evidence around the judged call (CORE-06 §4.1).
- *
- * Agent-neutral, discriminated by `kind`: a deletion is first-class evidence rather
- * than an unrepresentable case, and impossible states (a deletion with resulting
- * content, a creation with a baseline) cannot be written down. Adapters fill this from
- * their own sources (virtual apply, git blobs) — the core only transports it.
- * `delete.pre` is the readable text baseline when one exists — absent for a binary
- * blob, because a deletion needs no content to be judged.
- */
-export type FileChange = {
-    kind: 'create';
-    path: string;
-    post: string;
-} | {
-    kind: 'modify';
-    path: string;
-    pre: string;
-    post: string;
-} | {
-    kind: 'delete';
-    path: string;
-    pre?: string;
-};
-/**
- * `CovenantInput` — the agent-neutral input IR a covenant judges (PRD §4.2).
- *
- * Adapters up-translate their own agent payloads into this shape and pipe it as
- * stdin-JSON. The vocabulary carries no agent/tool literals; concrete tool or
- * subagent names are *values* an adapter fills in, never part of the core's type.
- * Evidence has exactly one home — the call element it belongs to (CORE-06 §4.1):
- * `fileChange` absent means "this call is unproven", and no sibling call's evidence
- * can stand in for it.
- */
-export type CovenantInput = {
-    toolCalls: {
-        name: string;
-        args?: Record<string, unknown>;
-        fileChange?: FileChange;
-    }[];
-    subagentSpawns: {
-        kind: string;
-    }[];
-    userMessages: {
-        text: string;
-    }[];
-};
-/**
- * `CovenantVerdict` — the result a covenant body produces (PRD §4.3).
- *
- * Either the promise was upheld, or it was broken with a human-readable reason.
- * Maps to an exit code via {@link verdictToExitCode}.
- */
-export type CovenantVerdict = {
-    upheld: true;
-} | {
-    upheld: false;
-    reason: string;
-};
-/**
- * Deserialize stdin-JSON into a {@link CovenantInput} (the protocol's reverse direction).
- *
- * fail-closed (PRD §5.2): this never throws. Any failure — unparseable JSON, an empty
- * payload, a parsed value that is not an object, or a missing required collection —
- * resolves to a blocking `{ ok: false, exitCode: 2 }`. "Cannot judge" means block,
- * so an unjudgeable input can never be mistaken for a valid one.
- */
-export declare function parseInput(stdinJson: string): {
-    ok: true;
-    value: CovenantInput;
-} | {
-    ok: false;
-    exitCode: 2;
-};
-/**
- * Flatten every call's evidence into one array in call order (CORE-06 §4.1).
- *
- * The one traversal for consumers that need no attribution (discipline scope, delta
- * judging): calls without evidence are skipped, never substituted for.
- */
-export declare function allFileChanges(input: CovenantInput): FileChange[];
-/**
- * Map a {@link CovenantVerdict} to an exit code (the protocol's forward direction).
- *
- * Responsibility boundary (PRD §4.1): the body emits `0` when upheld and `1` when
- * broken — never the blocking `2`. Translating `1` into `2` is the wrapper's policy.
- */
-export declare function verdictToExitCode(verdict: CovenantVerdict): 0 | 1;
+export { type AlgebraDeclaration, BINARY_COMBINATOR_NAMES, type BinaryStep, type ExtractBlock, type ExtractStep, RELATION_NAMES, type RelateEntry, type RelationDecl, type RelationName, type ScopeBlock, SUPPLY_POLICIES, type SupplyBlock, type UnaryStep, validateAlgebraDeclaration, type Witness, type WitnessBlock, type Witnesses, } from './algebra.ts';
+export { AXIS_NAMES, type Axis, type DerivableDeclaration, deriveShape, MECHANISM_NAMES, MECHANISM_SHAPES, type MechanismName, type MechanismShape, } from './catalogue.ts';
+export { type AlgebraDeclarationBody, ConfigValidationError, DEFAULT_TELEMETRY_LOG_PATH, type DisciplineDraft, type DisciplineEntry, defineConfig, type EnforceLevel, type LanguageProfile, type PolydeukesConfig, type ResolvedConfig, type ResolvedLanguageProfile, } from './config.ts';
+export { EXIT_BREAK_BLOCKING, EXIT_BREAK_NON_BLOCKING, EXIT_UPHOLD, } from './exit-codes.ts';
+export { type FailMode, type FailureKind, failModeToExitCode, resolveFailMode, } from './fail-policy.ts';
+export { isPlainObject } from './is-plain-object.ts';
+export { normalizeProtectedPaths } from './protected-paths.ts';
+export { allFileChanges, type ChannelReader, type CovenantInput, type CovenantVerdict, type DispatchOutcome, type FileChange, parseInput, type SourceReader, verdictToExitCode, } from './protocol.ts';
+export { aggregateGain, appendRecord, appendRecordFailOpen, formatRecordLine, type GainSummary, parseRecordLine, readRecords, runGain, SKIP_REASONS, type SkipReason, type TelemetryEvent, type TelemetryRecord, } from './telemetry.ts';
+export { type CanonicalTranscript, noopTranscript, type TranscriptToolCall, type TranscriptUserMessage, transcriptFromInput, } from './transcript.ts';