@polydeukes/core 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -1,34 +1,20 @@
 /**
  * @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 { ConfigValidationError, DEFAULT_TELEMETRY_LOG_PATH, type DisciplineDraft, type DisciplineEntry, type DisciplineForbid, defineConfig, type EnforceLevel, 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';
 /**
- * exit-code semantics of the covenant protocol (PRD §4.1).
- *
- * 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 below.
- */
-/** Promise upheld — no violation, the edit/push passes. */
-export declare const EXIT_UPHOLD = 0;
-/** Violation reported as a non-blocking signal. The covenant body's break code. */
-export declare const EXIT_BREAK_NON_BLOCKING = 1;
-/** Violation blocked — the edit/push is refused. Reserved for the wrapper / fail-closed. */
-export declare const EXIT_BREAK_BLOCKING = 2;
-/**
- * `FileChange` — one file's mutation evidence around the judged call (CORE-06 §4.1).
+ * `FileChange` — one file's mutation evidence around the judged call.
  *
  * Agent-neutral, discriminated by `kind`: a deletion is first-class evidence rather
  * than an unrepresentable case, and impossible states (a deletion with resulting
@@ -52,14 +38,13 @@ export type FileChange = {
     pre?: string;
 };
 /**
- * `CovenantInput` — the agent-neutral input IR a covenant judges (PRD §4.2).
+ * `CovenantInput` — the agent-neutral input IR a covenant judges.
  *
  * 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.
+ * Evidence has exactly one home, the call element it belongs to: `fileChange` absent
+ * means "this call is unproven", and no sibling call's evidence can stand in for it.
  */
 export type CovenantInput = {
     toolCalls: {
@@ -75,7 +60,7 @@ export type CovenantInput = {
     }[];
 };
 /**
- * `CovenantVerdict` — the result a covenant body produces (PRD §4.3).
+ * `CovenantVerdict` — the result a covenant body produces.
  *
  * Either the promise was upheld, or it was broken with a human-readable reason.
  * Maps to an exit code via {@link verdictToExitCode}.
@@ -89,7 +74,7 @@ export type CovenantVerdict = {
 /**
  * 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
+ * fail-closed: 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.
@@ -102,7 +87,7 @@ export declare function parseInput(stdinJson: string): {
     exitCode: 2;
 };
 /**
- * Flatten every call's evidence into one array in call order (CORE-06 §4.1).
+ * Flatten every call's evidence into one array in call order.
  *
  * The one traversal for consumers that need no attribution (discipline scope, delta
  * judging): calls without evidence are skipped, never substituted for.
@@ -111,7 +96,7 @@ 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
+ * Responsibility boundary: 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;

package/dist/index.js

@@ -1,37 +1,24 @@
 /**
  * @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
  */
+import { EXIT_BREAK_BLOCKING, EXIT_BREAK_NON_BLOCKING, EXIT_UPHOLD } from './exit-codes.js';
 import { isPlainObject } from './is-plain-object.js';
 export { ConfigValidationError, DEFAULT_TELEMETRY_LOG_PATH, defineConfig, } from './config.js';
+export { EXIT_BREAK_BLOCKING, EXIT_BREAK_NON_BLOCKING, EXIT_UPHOLD, } from './exit-codes.js';
 export { failModeToExitCode, resolveFailMode, } from './fail-policy.js';
 export { isPlainObject } from './is-plain-object.js';
 export { normalizeProtectedPaths } from './protected-paths.js';
 export { aggregateGain, appendRecord, appendRecordFailOpen, formatRecordLine, parseRecordLine, readRecords, runGain, } from './telemetry.js';
 export { noopTranscript, transcriptFromInput, } from './transcript.js';
-/**
- * exit-code semantics of the covenant protocol (PRD §4.1).
- *
- * 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 below.
- */
-/** Promise upheld — no violation, the edit/push passes. */
-export const EXIT_UPHOLD = 0;
-/** Violation reported as a non-blocking signal. The covenant body's break code. */
-export const EXIT_BREAK_NON_BLOCKING = 1;
-/** Violation blocked — the edit/push is refused. Reserved for the wrapper / fail-closed. */
-export const EXIT_BREAK_BLOCKING = 2;
 /**
  * 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
+ * fail-closed: 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.
@@ -56,7 +43,7 @@ export function parseInput(stdinJson) {
     return { ok: true, value: candidate };
 }
 /**
- * Flatten every call's evidence into one array in call order (CORE-06 §4.1).
+ * Flatten every call's evidence into one array in call order.
  *
  * The one traversal for consumers that need no attribution (discipline scope, delta
  * judging): calls without evidence are skipped, never substituted for.
@@ -72,7 +59,7 @@ export function allFileChanges(input) {
 /**
  * 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
+ * Responsibility boundary: the body emits `0` when upheld and `1` when
  * broken — never the blocking `2`. Translating `1` into `2` is the wrapper's policy.
  */
 export function verdictToExitCode(verdict) {

package/dist/is-plain-object.d.ts

@@ -1,6 +1,6 @@
 /**
  * `isPlainObject` — the workspace's single canonical plain-object predicate.
  *
- * Promoted by CORE-05 from per-package copies: typeof `object`, non-null, not an array.
+ * typeof `object`, non-null, not an array.
  */
 export declare function isPlainObject(value: unknown): value is Record<string, unknown>;

package/dist/is-plain-object.js

@@ -1,7 +1,7 @@
 /**
  * `isPlainObject` — the workspace's single canonical plain-object predicate.
  *
- * Promoted by CORE-05 from per-package copies: typeof `object`, non-null, not an array.
+ * typeof `object`, non-null, not an array.
  */
 export function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);

package/dist/protected-paths.d.ts

@@ -1,10 +1,10 @@
 /**
  * Protected-path normalization — the `protectedPaths` list normalized into the literal
- * path strings the dispatcher contract expects (CONFIG-02). Pure string transformation —
- * zero file I/O, no glob expansion, no path resolution (PRD §4.2).
+ * path strings the dispatcher contract expects. Pure string transformation — zero file
+ * I/O, no glob expansion, no path resolution.
  */
 /**
- * Normalize the protection surface from a config-shaped spec (PRD §4.2).
+ * Normalize the protection surface from a config-shaped spec.
  *
  * Processing order: trim each entry → strip a leading `./` → strip a trailing `/` → drop
  * empty-equivalent entries → dedupe on the normalized value, keeping the first occurrence.

package/dist/protected-paths.js

@@ -1,10 +1,10 @@
 /**
  * Protected-path normalization — the `protectedPaths` list normalized into the literal
- * path strings the dispatcher contract expects (CONFIG-02). Pure string transformation —
- * zero file I/O, no glob expansion, no path resolution (PRD §4.2).
+ * path strings the dispatcher contract expects. Pure string transformation — zero file
+ * I/O, no glob expansion, no path resolution.
  */
 /**
- * Normalize the protection surface from a config-shaped spec (PRD §4.2).
+ * Normalize the protection surface from a config-shaped spec.
  *
  * Processing order: trim each entry → strip a leading `./` → strip a trailing `/` → drop
  * empty-equivalent entries → dedupe on the normalized value, keeping the first occurrence.

package/dist/telemetry.d.ts

@@ -1,22 +1,25 @@
 /**
- * ROI telemetry — the single shared collector and its `gain` aggregation (CORE-02).
+ * ROI telemetry — the single shared collector and its `gain` aggregation.
  *
- * One record is one line of 4-field TSV (PRD §4.1); one append is one write call
- * (PRD §4.2). I/O is confined to exactly two functions — {@link appendRecord} (the
- * only write) and {@link readRecords} (the only read). Formatting, parsing, and
- * aggregation are pure. This is the sole collector: later work calls this API rather
- * than building its own logger.
+ * One record is one line of 4-field TSV; one append is one write call. I/O is confined to
+ * exactly two functions — {@link appendRecord} (the only write) and {@link readRecords}
+ * (the only read). Formatting, parsing, and aggregation are pure.
  */
 /**
- * The five telemetry events. `witnessed` is a first-class event, not a flag on `passed`:
+ * The six telemetry events. `witnessed` is a first-class event, not a flag on `passed`:
  * a break a human stood behind by supplying the pass condition themselves. `advised` is a
  * violation verdict an advise-level observer recorded but let through; `skipped` is a
  * discipline a surface could not judge at all (no evidence channel) — a no-op that shows
  * up in the data instead of vanishing.
+ *
+ * `unattributed` is the one observation event among them: a protected entry whose state
+ * changed with no judgment row explaining it. It sits on a different axis from the five
+ * verdicts — `skipped` is an inability known up front, `unattributed` an attribution
+ * failure found after the fact — and it never blocks or passes a call.
  */
-export type TelemetryEvent = 'passed' | 'blocked' | 'witnessed' | 'advised' | 'skipped';
+export type TelemetryEvent = 'passed' | 'blocked' | 'witnessed' | 'advised' | 'skipped' | 'unattributed';
 /**
- * `TelemetryRecord` — one measured covenant outcome (PRD §4.1).
+ * `TelemetryRecord` — one measured covenant outcome.
  *
  * `subject` is the judged target (a file path, etc.); `-` is the documented sentinel
  * for "no subject", carried round-trip like any other value.
@@ -43,19 +46,19 @@ export declare function formatRecordLine(record: TelemetryRecord): string;
  * Parse one TSV line back into a {@link TelemetryRecord}, or `null` if malformed (pure).
  *
  * Tolerates a trailing newline (so it round-trips {@link formatRecordLine}). Returns
- * `null` for the wrong field count, an event outside the five valid events, or an
+ * `null` for the wrong field count, an event outside the six valid events, or an
  * empty line — a malformed line is rejected, never coerced into a bogus record. The one
  * exception is {@link LEGACY_WITNESSED_EVENT}, which reads back as `witnessed`.
  */
 export declare function parseRecordLine(line: string): TelemetryRecord | null;
 /**
- * Append one record to the log at `path` — the only write I/O (PRD §4.2).
+ * Append one record to the log at `path` — the only write I/O.
  *
  * Exactly one {@link appendFileSync} call per record, writing {@link formatRecordLine}
  * verbatim. Relying on POSIX `O_APPEND` single-write semantics, concurrent appends do
  * not interleave lines.
  *
- * fail-open (PRD §4.3): any fs failure — bad path, permissions, disk — returns
+ * fail-open: any fs failure — bad path, permissions, disk — returns
  * `{ ok: false }` and never throws. This is deliberately the opposite direction of the
  * covenant path's fail-closed: the worst outcome of telemetry is a missing datum, never
  * a blocked workflow.
@@ -64,16 +67,16 @@ export declare function appendRecord(path: string, record: TelemetryRecord): {
     ok: boolean;
 };
 /**
- * Append one telemetry record fail-open, timestamping it here (CORE-05).
+ * Append one telemetry record fail-open, timestamping it here.
  *
- * This layer lives above the deliberately mkdir-free {@link appendRecord} (COVENANT-01b:
- * an absent directory is a fail-open `{ ok: false }` for `appendRecord` itself), so this
- * wrapper carries the parent-directory guarantee. The mkdir and the append share one try
- * block, and a failure of either never alters the caller's verdict and never propagates.
+ * {@link appendRecord} is deliberately mkdir-free — for it an absent directory is just a
+ * fail-open `{ ok: false }` — so this wrapper carries the parent-directory guarantee. The
+ * mkdir and the append share one try block, and a failure of either never alters the
+ * caller's verdict and never propagates.
  */
 export declare function appendRecordFailOpen(telemetryPath: string, record: Omit<TelemetryRecord, 'timestamp'>): void;
 /**
- * Read every record from the log at `path` — the only read I/O (PRD §4.4).
+ * Read every record from the log at `path` — the only read I/O.
  *
  * fail-open: an absent file or any read error returns `{ records: [], skipped: 0 }`
  * (an absent log means "nothing collected yet"), never throwing. Corrupt lines
@@ -85,14 +88,14 @@ export declare function readRecords(path: string): {
     skipped: number;
 };
 /**
- * Aggregate records into per-label event counts (PRD §4.4, pure).
+ * Aggregate records into per-label event counts (pure).
  *
- * Each label gets its own counter across all five events, so a corrupt or missing
+ * Each label gets its own counter across all six events, so a corrupt or missing
  * event never bleeds counts between labels.
  */
 export declare function aggregateGain(records: TelemetryRecord[]): GainSummary;
 /**
- * `gain` entry point — read the log at `path`, aggregate, and render (PRD §4.4).
+ * `gain` entry point — read the log at `path`, aggregate, and render.
  *
  * Composes {@link readRecords} + {@link aggregateGain} + a pure renderer. An absent or
  * empty log yields `no telemetry collected`; a corrupt line is skipped upstream, reported

package/dist/telemetry.js

@@ -1,11 +1,9 @@
 /**
- * ROI telemetry — the single shared collector and its `gain` aggregation (CORE-02).
+ * ROI telemetry — the single shared collector and its `gain` aggregation.
  *
- * One record is one line of 4-field TSV (PRD §4.1); one append is one write call
- * (PRD §4.2). I/O is confined to exactly two functions — {@link appendRecord} (the
- * only write) and {@link readRecords} (the only read). Formatting, parsing, and
- * aggregation are pure. This is the sole collector: later work calls this API rather
- * than building its own logger.
+ * One record is one line of 4-field TSV; one append is one write call. I/O is confined to
+ * exactly two functions — {@link appendRecord} (the only write) and {@link readRecords}
+ * (the only read). Formatting, parsing, and aggregation are pure.
  */
 import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
 import { dirname } from 'node:path';
@@ -16,20 +14,21 @@ const VALID_EVENTS = [
     'witnessed',
     'advised',
     'skipped',
+    'unattributed',
 ];
 /**
  * The event name `witnessed` was written under before the rename — a read-only migration
  * seam, never a value this module emits.
  *
- * It exists because the collected log predates the rename: those rows are the sample the
- * milestone journal round argues from, and dropping them as corrupt would delete the
- * measurement instead of migrating it. Compatibility runs one way only — {@link
- * formatRecordLine} has no path back to this name — and the match is the exact literal, so
- * a genuinely corrupt field is still rejected rather than coerced into a fabricated record.
+ * A log written before the rename still carries the old name, and rejecting those rows as
+ * corrupt would discard the measurement rather than migrate it. Compatibility runs one way —
+ * {@link formatRecordLine} has no path back to this name — and the match is the exact
+ * literal, so a genuinely corrupt field is still rejected rather than coerced into a
+ * fabricated record.
  */
 const LEGACY_WITNESSED_EVENT = 'bypassed';
 /**
- * Replace tab/newline/carriage-return with single spaces (PRD §4.1 line integrity).
+ * Replace tab/newline/carriage-return with single spaces.
  *
  * Without this, a tab or newline inside a field would fabricate extra TSV fields or
  * extra lines — a record is always exactly one line.
@@ -51,7 +50,7 @@ export function formatRecordLine(record) {
  * Parse one TSV line back into a {@link TelemetryRecord}, or `null` if malformed (pure).
  *
  * Tolerates a trailing newline (so it round-trips {@link formatRecordLine}). Returns
- * `null` for the wrong field count, an event outside the five valid events, or an
+ * `null` for the wrong field count, an event outside the six valid events, or an
  * empty line — a malformed line is rejected, never coerced into a bogus record. The one
  * exception is {@link LEGACY_WITNESSED_EVENT}, which reads back as `witnessed`.
  */
@@ -72,13 +71,13 @@ export function parseRecordLine(line) {
     return { timestamp, event: resolved, label, subject };
 }
 /**
- * Append one record to the log at `path` — the only write I/O (PRD §4.2).
+ * Append one record to the log at `path` — the only write I/O.
  *
  * Exactly one {@link appendFileSync} call per record, writing {@link formatRecordLine}
  * verbatim. Relying on POSIX `O_APPEND` single-write semantics, concurrent appends do
  * not interleave lines.
  *
- * fail-open (PRD §4.3): any fs failure — bad path, permissions, disk — returns
+ * fail-open: any fs failure — bad path, permissions, disk — returns
  * `{ ok: false }` and never throws. This is deliberately the opposite direction of the
  * covenant path's fail-closed: the worst outcome of telemetry is a missing datum, never
  * a blocked workflow.
@@ -93,12 +92,12 @@ export function appendRecord(path, record) {
     }
 }
 /**
- * Append one telemetry record fail-open, timestamping it here (CORE-05).
+ * Append one telemetry record fail-open, timestamping it here.
  *
- * This layer lives above the deliberately mkdir-free {@link appendRecord} (COVENANT-01b:
- * an absent directory is a fail-open `{ ok: false }` for `appendRecord` itself), so this
- * wrapper carries the parent-directory guarantee. The mkdir and the append share one try
- * block, and a failure of either never alters the caller's verdict and never propagates.
+ * {@link appendRecord} is deliberately mkdir-free — for it an absent directory is just a
+ * fail-open `{ ok: false }` — so this wrapper carries the parent-directory guarantee. The
+ * mkdir and the append share one try block, and a failure of either never alters the
+ * caller's verdict and never propagates.
  */
 export function appendRecordFailOpen(telemetryPath, record) {
     try {
@@ -110,7 +109,7 @@ export function appendRecordFailOpen(telemetryPath, record) {
     }
 }
 /**
- * Read every record from the log at `path` — the only read I/O (PRD §4.4).
+ * Read every record from the log at `path` — the only read I/O.
  *
  * fail-open: an absent file or any read error returns `{ records: [], skipped: 0 }`
  * (an absent log means "nothing collected yet"), never throwing. Corrupt lines
@@ -142,16 +141,23 @@ export function readRecords(path) {
     return { records, skipped };
 }
 /**
- * Aggregate records into per-label event counts (PRD §4.4, pure).
+ * Aggregate records into per-label event counts (pure).
  *
- * Each label gets its own counter across all five events, so a corrupt or missing
+ * Each label gets its own counter across all six events, so a corrupt or missing
  * event never bleeds counts between labels.
  */
 export function aggregateGain(records) {
     const counts = {};
     for (const record of records) {
         if (!(record.label in counts)) {
-            counts[record.label] = { passed: 0, blocked: 0, witnessed: 0, advised: 0, skipped: 0 };
+            counts[record.label] = {
+                passed: 0,
+                blocked: 0,
+                witnessed: 0,
+                advised: 0,
+                skipped: 0,
+                unattributed: 0,
+            };
         }
         counts[record.label][record.event] += 1;
     }
@@ -160,9 +166,10 @@ export function aggregateGain(records) {
 /**
  * Render a {@link GainSummary} into human-readable lines (pure).
  *
- * Each label is mentioned with its passed/blocked/witnessed/advised/skipped counts; each
- * is a distinct column, never folded into another (PRD §4.4). A non-zero corrupt-line
- * count is reported rather than hidden — silent skipping would mask log corruption.
+ * Each label is mentioned with its passed/blocked/witnessed/advised/skipped/unattributed
+ * counts; each is a distinct column, never folded into another. A non-zero
+ * corrupt-line count is reported rather than hidden — silent skipping would mask log
+ * corruption.
  *
  * Two different meanings share the word `skipped`: the per-label EVENT column above,
  * and the unparseable-line count below. They are rendered on separate lines and never
@@ -174,7 +181,7 @@ function renderGain(summary, skipped) {
     }
     const lines = [`total ${summary.total}`];
     for (const [label, counts] of Object.entries(summary.counts)) {
-        lines.push(`${label}: passed=${counts.passed} blocked=${counts.blocked} witnessed=${counts.witnessed} advised=${counts.advised} skipped=${counts.skipped}`);
+        lines.push(`${label}: passed=${counts.passed} blocked=${counts.blocked} witnessed=${counts.witnessed} advised=${counts.advised} skipped=${counts.skipped} unattributed=${counts.unattributed}`);
     }
     if (skipped > 0) {
         lines.push(`corrupt lines skipped=${skipped}`);
@@ -182,7 +189,7 @@ function renderGain(summary, skipped) {
     return lines.join('\n');
 }
 /**
- * `gain` entry point — read the log at `path`, aggregate, and render (PRD §4.4).
+ * `gain` entry point — read the log at `path`, aggregate, and render.
  *
  * Composes {@link readRecords} + {@link aggregateGain} + a pure renderer. An absent or
  * empty log yields `no telemetry collected`; a corrupt line is skipped upstream, reported

package/dist/transcript.d.ts

@@ -1,11 +1,10 @@
 /**
- * `CanonicalTranscript` — the agent-neutral session-query seam (CORE-04).
+ * `CanonicalTranscript` — the agent-neutral session-query seam.
  *
- * Layering (PRD §1): this seam does not replace `CovenantInput`. The IR (CORE-01) is
- * the *data* a covenant judges; `CanonicalTranscript` is the *behavioral seam* that
- * queries session data — CORE-04 sits on top of CORE-01, and the IR is one source it
- * can wrap. Concrete transcript formats stay in adapters; the core knows only the
- * query vocabulary. Pure types and functions, zero I/O.
+ * This seam does not replace `CovenantInput`. The IR is the *data* a covenant judges;
+ * `CanonicalTranscript` is the *behavioral seam* that queries session data, and the IR is
+ * one source it can wrap. Concrete transcript formats stay in adapters; the core knows only
+ * the query vocabulary. Pure types and functions, zero I/O.
  */
 import type { CovenantInput } from './index.js';
 /** One subagent invocation observed in the session. `kind` is an adapter-supplied value. */
@@ -13,7 +12,7 @@ export type SubagentInvocation = {
     kind: string;
 };
 /**
- * One user message observed in the session (PRD §4.1).
+ * One user message observed in the session.
  *
  * `timestampMs` is epoch milliseconds. Its absence means the source cannot prove
  * freshness — the fail-closed signal a witness consumer must treat as "not fresh".
@@ -23,10 +22,10 @@ export type TranscriptUserMessage = {
     timestampMs?: number;
 };
 /**
- * One tool call observed in the session (COVENANT-13 §4.2). `name` and `args` are
- * adapter-supplied values — the core knows the query vocabulary, never a tool's name.
+ * One tool call observed in the session. `name` and `args` are adapter-supplied values —
+ * the core knows the query vocabulary, never a tool's name.
  *
- * `succeeded` is three-valued (COVENANT-13b §4.1): `true` = it ran and reported success,
+ * `succeeded` is three-valued: `true` = it ran and reported success,
  * `false` = it ran and reported an error, was blocked, or was refused, and absent = the
  * provider cannot observe results at all. A consumer that treats the call as evidence
  * accepts only `true`, so the latter two share a disposition while staying diagnosable.
@@ -37,7 +36,7 @@ export type TranscriptToolCall = {
     succeeded?: boolean;
 };
 /**
- * `CanonicalTranscript` — what a covenant may ask about the session (PRD §4.1).
+ * `CanonicalTranscript` — what a covenant may ask about the session.
  *
  * Synchronous by design (covenant bodies are short-lived CLI processes) and
  * verdict-free: the seam carries facts only; TTL filtering and token matching belong
@@ -52,13 +51,13 @@ export type CanonicalTranscript = {
     findToolCalls(name?: string): TranscriptToolCall[];
 };
 /**
- * The injection-absent default (PRD §4.2): every query answers "nothing happened".
+ * The injection-absent default: every query answers "nothing happened".
  * A witness consumer naturally converges to fail-closed — no evidence, no skip — and
  * so does a precedent consumer (no evidence, gate stays shut).
  */
 export declare const noopTranscript: CanonicalTranscript;
 /**
- * Wrap a {@link CovenantInput} as a {@link CanonicalTranscript} (PRD §4.2).
+ * Wrap a {@link CovenantInput} as a {@link CanonicalTranscript}.
  *
  * Exposes `subagentSpawns` as invocations (filtered when a kind is given) and
  * `userMessages` with `timestampMs` omitted — the bare IR cannot prove freshness,
@@ -66,11 +65,9 @@ export declare const noopTranscript: CanonicalTranscript;
  * Order preserved; the input is never mutated, and every query returns fresh
  * objects so consumers never hold live aliases into the shared IR.
  *
- * `findToolCalls` projects each call down to `{ name, args }` only: since CORE-06 a
- * call element also carries `fileChange` evidence, and evidence is judgment input, not
- * session history — the two vocabularies stay separate (COVENANT-13 §4.2). `succeeded`
- * stays absent for the same reason it is left three-valued: these calls are the ones
- * being judged right now, so they have not run, and a call can never be its own
- * precedent (COVENANT-13b §4.1).
+ * `findToolCalls` projects each call down to `{ name, args }` only: a call element also
+ * carries `fileChange` evidence, and evidence is judgment input, not session history — the
+ * two vocabularies stay separate. `succeeded` stays absent because these calls are the ones
+ * being judged right now: they have not run, and a call can never be its own precedent.
  */
 export declare function transcriptFromInput(input: CovenantInput): CanonicalTranscript;

package/dist/transcript.js

@@ -1,14 +1,13 @@
 /**
- * `CanonicalTranscript` — the agent-neutral session-query seam (CORE-04).
+ * `CanonicalTranscript` — the agent-neutral session-query seam.
  *
- * Layering (PRD §1): this seam does not replace `CovenantInput`. The IR (CORE-01) is
- * the *data* a covenant judges; `CanonicalTranscript` is the *behavioral seam* that
- * queries session data — CORE-04 sits on top of CORE-01, and the IR is one source it
- * can wrap. Concrete transcript formats stay in adapters; the core knows only the
- * query vocabulary. Pure types and functions, zero I/O.
+ * This seam does not replace `CovenantInput`. The IR is the *data* a covenant judges;
+ * `CanonicalTranscript` is the *behavioral seam* that queries session data, and the IR is
+ * one source it can wrap. Concrete transcript formats stay in adapters; the core knows only
+ * the query vocabulary. Pure types and functions, zero I/O.
  */
 /**
- * The injection-absent default (PRD §4.2): every query answers "nothing happened".
+ * The injection-absent default: every query answers "nothing happened".
  * A witness consumer naturally converges to fail-closed — no evidence, no skip — and
  * so does a precedent consumer (no evidence, gate stays shut).
  */
@@ -18,7 +17,7 @@ export const noopTranscript = {
     findToolCalls: () => [],
 };
 /**
- * Wrap a {@link CovenantInput} as a {@link CanonicalTranscript} (PRD §4.2).
+ * Wrap a {@link CovenantInput} as a {@link CanonicalTranscript}.
  *
  * Exposes `subagentSpawns` as invocations (filtered when a kind is given) and
  * `userMessages` with `timestampMs` omitted — the bare IR cannot prove freshness,
@@ -26,12 +25,10 @@ export const noopTranscript = {
  * Order preserved; the input is never mutated, and every query returns fresh
  * objects so consumers never hold live aliases into the shared IR.
  *
- * `findToolCalls` projects each call down to `{ name, args }` only: since CORE-06 a
- * call element also carries `fileChange` evidence, and evidence is judgment input, not
- * session history — the two vocabularies stay separate (COVENANT-13 §4.2). `succeeded`
- * stays absent for the same reason it is left three-valued: these calls are the ones
- * being judged right now, so they have not run, and a call can never be its own
- * precedent (COVENANT-13b §4.1).
+ * `findToolCalls` projects each call down to `{ name, args }` only: a call element also
+ * carries `fileChange` evidence, and evidence is judgment input, not session history — the
+ * two vocabularies stay separate. `succeeded` stays absent because these calls are the ones
+ * being judged right now: they have not run, and a call can never be its own precedent.
  */
 export function transcriptFromInput(input) {
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polydeukes/core",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Polydeukes core — covenant protocol, config loader, and transcript interface. Domain- and agent-agnostic. Alpha.",
   "license": "MIT",
   "repository": {