@polydeukes/core 0.4.0 → 0.5.0

package/dist/config.d.ts

@@ -1,18 +1,15 @@
 /**
- * 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.
  */
-/** Conventional default telemetry log path (PRD §4.3) — local-only observation data. */
+/** Conventional default telemetry log path — local-only observation data. */
 export declare const DEFAULT_TELEMETRY_LOG_PATH = ".polydeukes/roi.log";
 /**
- * `LanguageProfile` — the unit of the language axis (PRD §4.1).
+ * `LanguageProfile` — the unit of the language axis.
  *
  * `testCmd` is a shell command template: every literal `{scope}` token is substituted at
  * resolve time, and the core only carries the resulting string — it never interprets it.
@@ -27,16 +24,22 @@ export type LanguageProfile = {
     testCmd: string;
 };
 /**
- * `DisciplineForbid` — the delta-family predicate value (COVENANT-10 §4.1).
+ * `DisciplineForbid` — the delta-family predicate value.
  *
- * The string shorthand is equivalent to `{ added }`; `removed`/`present` directions are
- * deferred (COVENANT-12) and rejected by validation.
+ * The string shorthand is equivalent to `{ added }`. It is the only direction that exists;
+ * anything else is rejected by validation.
  */
 export type DisciplineForbid = string | {
     added: string;
 };
 /**
- * `DisciplineEntry` — one user-declared discipline (COVENANT-10 §4.1). Pure JSON data.
+ * `EnforceLevel` — an entry's own rung on the promotion ladder. `advise` records a break
+ * without stopping it; `block` pins the entry at block whatever default the ladder later
+ * adopts. Absence means advise; `block` is the promotion rung.
+ */
+export type EnforceLevel = 'block' | 'advise';
+/**
+ * `DisciplineEntry` — one user-declared discipline. Pure JSON data.
  *
  * Exactly one predicate key (`forbid` | `immutable` | `forbidCommand` |
  * `requirePrecedent`) per entry; `in`/`except` scope the delta and context families.
@@ -46,8 +49,10 @@ export type DisciplineForbid = string | {
 export type DisciplineEntry = {
     /** unique handle — telemetry label and verdict reason prefix */
     id: string;
-    /** prose rationale, documentation only — never judged */
+    /** prose rationale — never judged, and carried into the break message */
     why?: string;
+    /** the author's level; composes with the observer's surface level, lenient side winning */
+    enforce?: EnforceLevel;
     /** delta/context-family scope: glob(s) the file path must match (absent = every file change) */
     in?: string | string[];
     /** delta/context-family scope: glob(s) excluded after `in` */
@@ -63,44 +68,61 @@ export type DisciplineEntry = {
     /**
      * context family — the session evidence one edit requires beforehand. Exactly one
      * evidence key. The core owns and fully validates `command`; every other key is
-     * adapter vocabulary whose value passes through verbatim (CONFIG-07 layering).
+     * adapter vocabulary whose value passes through verbatim.
      */
     requirePrecedent?: Record<string, unknown>;
 };
 /**
- * `PolydeukesConfig` — the input shape a user writes (PRD §4.1). JSON-serializable data.
+ * `DisciplineDraft` — an unpromoted discipline: the promotion ladder's first rung,
+ * registered as prose ahead of any predicate.
+ *
+ * A draft is declared, never inferred — only the literal `draft: true` makes one, and an
+ * entry with neither a predicate nor the marker stays a validation error. It carries no
+ * predicate, scope, or trigger key, produces no registration, no judgment, and no
+ * telemetry row; `pdks explain` renders it as unpromoted.
+ */
+export type DisciplineDraft = {
+    /** unique handle in the same label space as judged entries and meta-covenant labels */
+    id: string;
+    /** the draft's whole body — required prose, unlike the judged families' optional why */
+    why: string;
+    /** the explicit marker; only the literal true exists (false is rejected as dead data) */
+    draft: true;
+};
+/**
+ * `PolydeukesConfig` — the input shape a user writes. JSON-serializable data.
  *
  * Language keys (`typescript`, `python`, …) are user *values*, not the core's vocabulary —
  * no language or tool literal appears in the core source.
  */
 export type PolydeukesConfig = {
-    /** IDE schema reference (CONFIG-03) — accepted and ignored, never part of the resolution */
+    /** IDE schema reference — accepted and ignored, never part of the resolution */
     $schema?: string;
     /** language axis, first-class. keys are user values ('typescript', 'python', …) */
     languages: Record<string, LanguageProfile>;
-    /** raw protected path patterns — normalization is CONFIG-02's job */
+    /** raw protected path patterns — normalized downstream, never here */
     protectedPaths?: string[];
     /**
-     * adapter namespaces (CONFIG-07) — keys are ecosystem values (never validated), each
-     * value is that adapter's own settings object, passed through verbatim (the vocabulary
-     * belongs to the adapter, whose own validator judges the contents)
+     * adapter namespaces — keys are ecosystem values (never validated), each value is that
+     * adapter's own settings object, passed through verbatim (the vocabulary belongs to the
+     * adapter, whose own validator judges the contents)
      */
     adapters?: Record<string, Record<string, unknown>>;
     telemetry?: {
-        /** conventional default applies when omitted (§4.3) */
+        /** conventional default applies when omitted */
         logPath?: string;
     };
     /** user-declared disciplines — validated here, compiled by the covenant package */
-    disciplines?: DisciplineEntry[];
+    disciplines?: (DisciplineEntry | DisciplineDraft)[];
     /**
-     * TTL witness values for the covenant valve seam (CONFIG-05) — consumed at
-     * assembly time, validated here
+     * TTL witness values for the covenant valve seam — consumed at assembly time,
+     * validated here
      */
     witness?: {
         /**
          * the agreed phrase a human types alone on a message's first line — quoting it
-         * mid-sentence is a mention, not an invocation (COVENANT-15). Non-empty after
-         * trimming; the value itself is free (provenance, not secrecy, is the defence)
+         * mid-sentence is a mention, not an invocation. Non-empty after trimming; the value
+         * itself is free, since provenance rather than secrecy is the defence
          */
         token: string;
         /** validity window in minutes from the user message's timestamp — finite and > 0 */
@@ -110,11 +132,11 @@ export type PolydeukesConfig = {
 /**
  * `ResolvedLanguageProfile` — a {@link LanguageProfile} with its template compiled.
  *
- * Consumers keep the callable shape (`testCmd(scope)`), identical to schema v1 (LEDGER-05).
+ * Consumers keep the callable shape (`testCmd(scope)`).
  */
 export type ResolvedLanguageProfile = {
     productionGlob: string | string[];
-    /** compiled from the template — consumers keep the callable shape (LEDGER-05) */
+    /** compiled from the template — consumers keep the callable shape */
     testCmd: (scope: string) => string;
 };
 /**
@@ -130,8 +152,14 @@ export type ResolvedConfig = {
     telemetry: {
         logPath: string;
     };
-    /** validated discipline data, passed through verbatim (absent stays absent) */
+    /**
+     * validated judged entries only — drafts are split out at resolution time so the
+     * covenant compiler has no path that receives one. Present whenever the input
+     * declared a `disciplines` array, holding exactly its judged entries in order.
+     */
     disciplines?: DisciplineEntry[];
+    /** validated drafts in declaration order (absent when the input carries none) */
+    drafts?: DisciplineDraft[];
     /** validated witness data, passed through verbatim (absent stays absent) */
     witness?: {
         token: string;
@@ -139,7 +167,7 @@ export type ResolvedConfig = {
     };
 };
 /**
- * `ConfigValidationError` — raised when a config fails structural validation (PRD §4.3).
+ * `ConfigValidationError` — raised when a config fails structural validation.
  *
  * The message names the offending field path so the developer sees exactly what is wrong.
  * This throw is a developer-time error (config authoring), a different axis from the
@@ -150,8 +178,7 @@ export declare class ConfigValidationError extends Error {
 }
 /**
  * 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

package/dist/config.js

@@ -1,19 +1,16 @@
 /**
- * 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 { isPlainObject } from './is-plain-object.js';
-/** Conventional default telemetry log path (PRD §4.3) — local-only observation data. */
+/** 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).
+ * `ConfigValidationError` — raised when a config fails structural validation.
  *
  * The message names the offending field path so the developer sees exactly what is wrong.
  * This throw is a developer-time error (config authoring), a different axis from the
@@ -25,7 +22,8 @@ export class ConfigValidationError extends Error {
         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',
@@ -41,6 +39,7 @@ const WITNESS_KEYS = new Set(['token', 'ttlMinutes']);
 const DISCIPLINE_KEYS = new Set([
     'id',
     'why',
+    'enforce',
     'in',
     'except',
     'forbid',
@@ -49,8 +48,10 @@ const DISCIPLINE_KEYS = new Set([
     'when',
     'requirePrecedent',
 ]);
+const DRAFT_KEYS = new Set(['id', 'why', 'draft']);
+const ENFORCE_LEVELS = new Set(['block', 'advise']);
 const PREDICATE_KEYS = ['forbid', 'immutable', 'forbidCommand', 'requirePrecedent'];
-/** Predicate families that `in`/`except` may scope — delta and context (COVENANT-13 §4.1). */
+/** Predicate families that `in`/`except` may scope — delta and context. */
 const SCOPED_PREDICATE_KEYS = new Set(['forbid', 'requirePrecedent']);
 /** Throw on the first key outside the allowed vocabulary, naming the key and its location. */
 function rejectUnknownKeys(record, allowed, location) {
@@ -75,7 +76,7 @@ function isValidGlob(glob) {
     return false;
 }
 /**
- * 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
@@ -96,14 +97,13 @@ function rejectUncompilableRegex(pattern, location) {
     }
 }
 /**
- * Validate a context-family `requirePrecedent` value (COVENANT-13 §4.1).
+ * Validate a context-family `requirePrecedent` value.
  *
  * Evidence vocabulary is layered: the container (a flat object holding exactly one
  * evidence key) is the core's, and so is the `command` key — a shell command is the
  * agent-crossing surface, fully validated here. Every other key belongs to an adapter,
  * whose own validator judges the value; the core passes it through verbatim and never
- * inspects it (CONFIG-07 layering). An unrecognized evidence key fails closed at
- * assembly time, not here.
+ * inspects it. An unrecognized evidence key fails closed at assembly time, not here.
  */
 function validateRequirePrecedent(evidence, location) {
     if (!isPlainObject(evidence)) {
@@ -121,14 +121,128 @@ function validateRequirePrecedent(evidence, location) {
         rejectUncompilableRegex(command, `${location} requirePrecedent.command`);
     }
 }
+/** Validate a draft entry and return it as data. */
+function validateDraft(entry, id, location) {
+    for (const key of Object.keys(entry)) {
+        if (!DRAFT_KEYS.has(key)) {
+            // Named as the draft rule, not as an unknown key: `forbid` et al. are legal
+            // 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 family-independent rules of a judged entry and return its predicate key. */
+function validateJudgedHead(entry, location) {
+    rejectUnknownKeys(entry, DISCIPLINE_KEYS, location);
+    if (entry.why !== undefined && typeof entry.why !== 'string') {
+        throw new ConfigValidationError(`${location} why must be a string`);
+    }
+    if (entry.enforce !== undefined &&
+        (typeof entry.enforce !== 'string' || !ENFORCE_LEVELS.has(entry.enforce))) {
+        throw new ConfigValidationError(`${location} enforce must be 'block' or 'advise'`);
+    }
+    const predicates = PREDICATE_KEYS.filter((key) => entry[key] !== undefined);
+    if (predicates.length !== 1) {
+        throw new ConfigValidationError(`${location} must have exactly one predicate key ` +
+            `(forbid | immutable | forbidCommand | requirePrecedent)`);
+    }
+    const predicate = predicates[0];
+    if (!SCOPED_PREDICATE_KEYS.has(predicate) &&
+        (entry.in !== undefined || entry.except !== undefined)) {
+        throw new ConfigValidationError(`${location} allows in/except only on a forbid or requirePrecedent entry`);
+    }
+    // `when` is the context family's trigger; on any other family it would be dead data
+    // implying a trigger that is never applied.
+    if (entry.when !== undefined && predicate !== 'requirePrecedent') {
+        throw new ConfigValidationError(`${location} allows when only on a requirePrecedent entry`);
+    }
+    if (entry.in !== undefined && !isValidGlob(entry.in)) {
+        throw new ConfigValidationError(`${location} in must be a non-empty glob or glob array`);
+    }
+    if (entry.except !== undefined && !isValidGlob(entry.except)) {
+        throw new ConfigValidationError(`${location} except must be a non-empty glob or glob array`);
+    }
+    return predicate;
+}
+function validateForbid(entry, location) {
+    const forbid = entry.forbid;
+    if (typeof forbid === 'string') {
+        // An empty pattern matches at every position, so the entry would break every
+        // in-scope change — rejected like every sibling pattern field.
+        if (forbid.length === 0) {
+            throw new ConfigValidationError(`${location} forbid must be a non-empty string pattern`);
+        }
+        rejectUncompilableRegex(forbid, `${location} forbid`);
+    }
+    else if (isPlainObject(forbid)) {
+        const keys = Object.keys(forbid);
+        if (keys.length !== 1 || keys[0] !== 'added' || typeof forbid.added !== 'string') {
+            throw new ConfigValidationError(`${location} forbid object must have exactly one key 'added' with a string pattern`);
+        }
+        if (forbid.added.length === 0) {
+            throw new ConfigValidationError(`${location} forbid.added must be a non-empty string pattern`);
+        }
+        rejectUncompilableRegex(forbid.added, `${location} forbid.added`);
+    }
+    else {
+        throw new ConfigValidationError(`${location} forbid must be a string pattern or an { added } object`);
+    }
+}
+function validateImmutable(entry, location) {
+    if (!isValidGlob(entry.immutable)) {
+        throw new ConfigValidationError(`${location} immutable must be a non-empty glob or glob array`);
+    }
+}
+function validateForbidCommand(entry, location) {
+    if (typeof entry.forbidCommand !== 'string') {
+        throw new ConfigValidationError(`${location} forbidCommand must be a string pattern`);
+    }
+    if (entry.forbidCommand.length === 0) {
+        // An empty pattern matches every command line — one typo would block every
+        // shell call the entry sees.
+        throw new ConfigValidationError(`${location} forbidCommand must be a non-empty string pattern`);
+    }
+    rejectUncompilableRegex(entry.forbidCommand, `${location} forbidCommand`);
+}
+function validateContextEntry(entry, location) {
+    if (entry.when !== undefined) {
+        if (typeof entry.when !== 'string') {
+            throw new ConfigValidationError(`${location} when must be a string pattern`);
+        }
+        if (entry.when.length === 0) {
+            // An empty pattern matches at every position, so the trigger would fire on any
+            // file that merely grows — reject it like every sibling pattern field.
+            throw new ConfigValidationError(`${location} when must be a non-empty string pattern`);
+        }
+        rejectUncompilableRegex(entry.when, `${location} when`);
+    }
+    validateRequirePrecedent(entry.requirePrecedent, location);
+}
+/** One validator per family, keyed by the predicate that selects the family. */
+const PREDICATE_VALIDATORS = {
+    forbid: validateForbid,
+    immutable: validateImmutable,
+    forbidCommand: validateForbidCommand,
+    requirePrecedent: validateContextEntry,
+};
 /**
- * Validate the `disciplines` array (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 +255,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)`);
+        // 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`);
         }
-        const predicate = predicates[0];
-        if (!SCOPED_PREDICATE_KEYS.has(predicate) &&
-            (entry.in !== undefined || entry.except !== undefined)) {
-            throw new ConfigValidationError(`${location} allows in/except only on a forbid or requirePrecedent entry`);
-        }
-        // `when` is the context family's trigger; on any other family it would be dead data
-        // implying a trigger that is never applied.
-        if (entry.when !== undefined && predicate !== 'requirePrecedent') {
-            throw new ConfigValidationError(`${location} allows when only on a requirePrecedent entry`);
-        }
-        if (entry.in !== undefined && !isValidGlob(entry.in)) {
-            throw new ConfigValidationError(`${location} in must be a non-empty glob or glob array`);
-        }
-        if (entry.except !== undefined && !isValidGlob(entry.except)) {
-            throw new ConfigValidationError(`${location} except must be a non-empty glob or glob array`);
-        }
-        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;
         }
+        const predicate = validateJudgedHead(entry, location);
+        PREDICATE_VALIDATORS[predicate](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 +315,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 +349,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 +366,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 +380,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 +401,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 the barrel.
  *
  * 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.
+ * 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. 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 the barrel.
  *
  * 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.
+ * 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. 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;