@skill-harness/adapters 0.9.0 → 0.11.0

package/dist/trajectory.js

@@ -1,7 +1,9 @@
 import { createHash } from "node:crypto";
 import { readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { TRAJECTORY_EVENT_VERSION, deserializeTrajectoryEvents, matchesGlob, redactArgs } from "@skill-harness/core";
+import { TRAJECTORY_EVENT_VERSION, deserializeTrajectoryEvents, matchesGlob, redactArgs, redactText } from "@skill-harness/core";
+import { assertSupportedSchema, declaredPropertyNames, validateClosedSchema } from "./closed-schema.js";
+import { PI_DADDY_CONTRACT_COMMIT, PI_DADDY_LEDGER_V2_SCHEMA } from "./pi-daddy-ledger-v2.js";
 /** Read and normalize declared workspace-local native ledger files. */
 export function collectTrajectorySources(cwd, sources) {
     const files = walkFiles(cwd);
@@ -32,13 +34,21 @@ export function collectTrajectorySources(cwd, sources) {
                 if (!normalized)
                     throw new Error("normalized-v1 source is empty, malformed, or unsupported");
                 const times = normalized.map((event) => validTime(event.at) ? Date.parse(event.at) : null);
-                if (times.every((time) => time !== null) && times.some((time, index) => index > 0 && time < times[index - 1])) {
-                    throw new Error("native event timestamps move backwards relative to the source's recorded sequence");
+                if (times.every((time) => time !== null)) {
+                    const highWaterByStream = new Map();
+                    for (let index = 0; index < times.length; index += 1) {
+                        const stream = source.adapter === "pi-daddy-v1" ? normalizedPiDaddyStreamKey(normalized[index], index) : "source";
+                        const highWater = highWaterByStream.get(stream);
+                        if (highWater !== undefined && times[index] < highWater && !isAllowedPiDaddyReceiptInversion(source.adapter, normalized, index)) {
+                            throw new Error("native event timestamps move backwards relative to the source's recorded sequence");
+                        }
+                        highWaterByStream.set(stream, Math.max(highWater ?? times[index], times[index]));
+                    }
                 }
                 streams.push({ file, adapter: source.adapter, events: normalized });
             }
             catch (error) {
-                errors.push(`${source.adapter}:${file}: ${error instanceof Error ? error.message : String(error)}`);
+                errors.push(`${source.adapter}:${file}: ${sanitizePersistedError(error)}`);
             }
         }
     }
@@ -133,7 +143,7 @@ export function normalizePrincipalAssuranceLedger(text) {
     validatePrincipalIntegrity(records);
     return records.map((record, index) => {
         if (record.schema_version !== "1.0") {
-            throw new Error(`unsupported principal assurance schema version ${JSON.stringify(record.schema_version)} at line ${index + 1}; expected \"1.0\"`);
+            throw new Error(`unsupported principal assurance schema version ${safeDiagnosticValue(record.schema_version)} at line ${index + 1}; expected \"1.0\"`);
         }
         if (!Number.isInteger(record.seq) || Number(record.seq) < 1 || typeof record.type !== "string" || typeof record.run_id !== "string") {
             throw new Error(`invalid principal assurance v1 event at line ${index + 1}: seq, type, and run_id are required`);
@@ -174,27 +184,683 @@ export function normalizePrincipalAssuranceLedger(text) {
     });
 }
 /**
- * Normalize both the current unversioned pi-daddy 0.17 grant ledger and the
- * explicit v1 governance supplement. Legacy omissions remain omissions: no
- * task/workspace/expiry field is ever inferred as successful governance.
+ * Normalize pi-daddy's public ledgers: unversioned 0.17 GrantRecord lines and
+ * ledgerVersion 2 runtime events emitted by 0.18.0. Version detection precedes
+ * the legacy fallback so a new event can never be misdiagnosed as an old grant.
  */
 export function normalizePiDaddyLedger(text) {
     const records = parseJsonl(text, "pi-daddy");
+    validatePiDaddyTimestampOrder(records);
     const out = [];
     let seq = 1;
     records.forEach((record, index) => {
-        if (record.schema_version !== undefined && record.schema_version !== "1.0") {
-            throw new Error(`unsupported pi-daddy ledger schema version ${JSON.stringify(record.schema_version)} at line ${index + 1}; expected unversioned 0.17 grant records or \"1.0\" governance records`);
-        }
-        if (record.schema_version === "1.0") {
-            out.push(normalizePiDaddyV1(record, seq++, index));
+        if (record.ledgerVersion !== undefined) {
+            if (record.ledgerVersion !== 2) {
+                throw new Error(`unsupported pi-daddy ledgerVersion ${safeDiagnosticValue(record.ledgerVersion)} at line ${index + 1}; expected 2 or an unversioned 0.17 GrantRecord`);
+            }
+            // The discriminator first (it names the four public variants), then the
+            // producer's own closed schema, then semantic normalization. Nothing
+            // downstream may assume a field the pinned contract has not admitted.
+            requireV2Discriminator(record, index + 1);
+            assertPinnedV2Contract(record, index + 1);
+            for (const event of normalizePiDaddyV2(record, index))
+                out.push({ ...event, seq: seq++ });
             return;
         }
+        if (record.schema_version !== undefined) {
+            throw new Error(`pi-daddy schema_version/record_type at line ${index + 1} is not a public pi-daddy ledger format; expected ledgerVersion 2 or an unversioned 0.17 GrantRecord`);
+        }
+        if (record.event !== undefined) {
+            throw new Error(`pi-daddy event [REDACTED invalid value] at line ${index + 1} is missing explicit ledgerVersion 2`);
+        }
         for (const event of normalizeLegacyGrant(record, index))
             out.push({ ...event, seq: seq++ });
     });
     return out;
 }
+/** The four public `ledgerVersion: 2` event discriminators. */
+const V2_EVENTS = new Set(["capability_decision", "workspace_lease", "child_lifecycle", "check_receipt"]);
+function requireV2Discriminator(record, line) {
+    const nativeEvent = string(record.event);
+    if (!nativeEvent || !V2_EVENTS.has(nativeEvent)) {
+        throw new Error(`invalid pi-daddy v2 event at line ${line}: event must be capability_decision, workspace_lease, child_lifecycle, or check_receipt`);
+    }
+    return nativeEvent;
+}
+// Memoized once per process: the pinned document does not change at runtime, and
+// walking it for every ledger line would be pure waste.
+let pinnedContractChecked = false;
+let pinnedContractFieldNames;
+/**
+ * Validate one explicit `ledgerVersion: 2` record against pi-daddy's *own* closed
+ * schema before anything reads a field out of it.
+ *
+ * The harness used to reimplement the contract field by field, which is how an
+ * undeclared top-level field could ride along unnoticed: a check that is not
+ * written cannot fail. Driving the check from the producer's pinned bytes makes
+ * unknown fields, enum members, nullability and requiredness fail closed without
+ * a second vocabulary to keep in step.
+ */
+function assertPinnedV2Contract(record, line) {
+    if (!pinnedContractChecked) {
+        assertSupportedSchema(PI_DADDY_LEDGER_V2_SCHEMA, "pinned pi-daddy ledger v2 schema");
+        pinnedContractFieldNames = declaredPropertyNames(PI_DADDY_LEDGER_V2_SCHEMA);
+        pinnedContractChecked = true;
+    }
+    const violations = validateClosedSchema(PI_DADDY_LEDGER_V2_SCHEMA, record, { knownFieldNames: pinnedContractFieldNames });
+    if (violations.length === 0)
+        return;
+    const nativeEvent = string(record.event);
+    const label = nativeEvent && V2_EVENTS.has(nativeEvent) ? nativeEvent : "record";
+    const [first] = violations;
+    const extra = violations.length > 1 ? ` (+${violations.length - 1} more contract violation${violations.length > 2 ? "s" : ""})` : "";
+    throw new Error(`invalid pi-daddy v2 ${label} at line ${line}: closed contract violation — ${first.path ? `${first.path} ` : ""}${first.message}${extra}` +
+        ` [pi-daddy ${PI_DADDY_CONTRACT_COMMIT.slice(0, 12)}]`);
+}
+const V2_LEASE_OUTCOMES = new Set([
+    "acquired", "uncontended", "refused", "released", "released-unrecorded", "lost", "retained", "timeout", "recovered",
+]);
+const V2_LEASE_ACCESS = new Set(["read", "write"]);
+/** Lease outcomes that can precede the one accepted append-after-release receipt inversion. */
+const V2_RECEIPT_PRIOR_LEASE_OUTCOMES = new Set(["acquired", "recovered"]);
+const V2_REFUSAL_FIELDS = new Set(["code", "message", "details"]);
+const V2_REFUSAL_DETAIL_TYPES = new Set(["string", "number", "boolean", "null"]);
+const V2_LIFECYCLE_STATES = new Set(["starting", "completed", "failed"]);
+const V2_EXECUTORS = new Set(["process", "herdr"]);
+const V2_RECEIPT_RELEASE_OUTCOMES = new Set(["released", "released-unrecorded", "lost", "timeout"]);
+const NORMALIZED_RECEIPT_RELEASE_EVENTS = new Set([
+    "writer_lease_released", "writer_lease_released_unrecorded", "writer_lease_lost", "writer_lease_timeout",
+]);
+const V2_CORRELATION_FIELDS = new Set([
+    "schema_version", "run_id", "task_id", "workspace_id", "context_id", "phase", "assurance",
+    "assurance_effective", "policy_label", "assurance_source", "assurance_scope", "activated_at",
+    "plan_digest", "definition_digest", "task_digest", "base_sha", "head_sha", "tree_sha",
+    "event_seq", "last_change_seq", "last_authority_seq", "check_receipt_id",
+]);
+const V2_CORRELATION_NUMERIC_FIELDS = new Set(["event_seq", "last_change_seq", "last_authority_seq"]);
+const V2_APPROVAL_SOURCES = new Set(["prompt", "session", "persisted", "inherited"]);
+const V2_APPROVAL_SCOPES = new Set(["once", "session", "always"]);
+/**
+ * pi-daddy's canonical refusal vocabulary, in the pinned contract's own order.
+ *
+ * This is a copy of `#/$defs/refusalCode` from the pinned schema and is exported
+ * so `pi-daddy-contract.test.ts` can assert set equality against the producer
+ * artifact — a hand-maintained second vocabulary without that drift assertion is
+ * exactly how `GRANT_ID_MALFORMED` came to be rejected as "unsupported".
+ */
+export const V2_REFUSAL_CODES = new Set([
+    "CAPABILITY_ESCALATION", "GRANT_ID_MALFORMED", "DEFINITION_NOT_AUTHORIZED", "UNDECLARED_TOOLS", "UNKNOWN_TOOL",
+    "GATED_UNAPPROVED", "APPROVAL_EXPIRED", "APPROVAL_SCOPE_MISMATCH", "APPROVAL_FLOW_FAILED",
+    "DEPTH_EXCEEDED", "FANOUT_EXCEEDED", "EXECUTOR_UNAVAILABLE", "CHILD_TIMED_OUT", "CHILD_CANCELLED",
+    "CHILD_EXIT_NONZERO", "TASK_MISSING", "UNKNOWN_DEFINITION", "CEILING_PATTERNS_UNRESOLVED",
+    "NARROWING_VIOLATED", "DEFINITION_UNREADABLE", "CORRELATION_TOO_LARGE", "CORRELATION_INVALID",
+    "LEDGER_WRITE_FAILED", "FANOUT_FAILED", "WORKSPACE_NOT_REGISTERED", "WORKSPACE_WRITE_CONFLICT",
+    "WORKSPACE_LEASE_STALE", "CHECK_NOT_CONFIGURED", "CHECK_CONFIGURATION_INVALID",
+    "CHECK_IDENTITY_UNAVAILABLE", "CHECK_IDENTITY_MISMATCH",
+]);
+/**
+ * Every vocabulary the adapter restates from the pinned contract, paired with the
+ * place in the schema it must equal.
+ *
+ * The closed schema gates first, so a semantic check that has drifted *narrower*
+ * than the contract no longer opens a hole — it produces the opposite failure:
+ * a contract-valid record admitted by the schema and then thrown out by a stale
+ * harness set, which is precisely what `GRANT_ID_MALFORMED` did. One manifest, one
+ * test over all of it, so re-pinning cannot quietly leave a set behind.
+ */
+export const V2_RESTATED_VOCABULARIES = [
+    { name: "V2_EVENTS", kind: "discriminators", pointer: "#/oneOf", values: V2_EVENTS },
+    { name: "V2_REFUSAL_CODES", kind: "enum", pointer: "#/$defs/refusalCode", values: V2_REFUSAL_CODES },
+    { name: "V2_APPROVAL_SOURCES", kind: "enum", pointer: "#/$defs/approvalSource", values: V2_APPROVAL_SOURCES },
+    { name: "V2_APPROVAL_SCOPES", kind: "enum", pointer: "#/$defs/approvalScope", values: V2_APPROVAL_SCOPES },
+    { name: "V2_LEASE_OUTCOMES", kind: "enum", pointer: "#/$defs/workspaceLease/properties/outcome", values: V2_LEASE_OUTCOMES },
+    { name: "V2_LEASE_ACCESS", kind: "enum", pointer: "#/$defs/workspaceLease/properties/access", values: V2_LEASE_ACCESS },
+    { name: "V2_LIFECYCLE_STATES", kind: "enum", pointer: "#/$defs/childLifecycle/properties/state", values: V2_LIFECYCLE_STATES },
+    { name: "V2_EXECUTORS (lifecycle)", kind: "enum", pointer: "#/$defs/childLifecycle/properties/executor", values: V2_EXECUTORS },
+    { name: "V2_EXECUTORS (decision)", kind: "enum", pointer: "#/$defs/capabilityDecision/properties/executor", values: V2_EXECUTORS },
+    { name: "V2_CORRELATION_FIELDS", kind: "propertyNames", pointer: "#/$defs/correlation", values: V2_CORRELATION_FIELDS },
+    { name: "V2_CORRELATION_NUMERIC_FIELDS", kind: "numericPropertyNames", pointer: "#/$defs/correlation", values: V2_CORRELATION_NUMERIC_FIELDS },
+    { name: "V2_REFUSAL_FIELDS", kind: "propertyNames", pointer: "#/$defs/refusal", values: V2_REFUSAL_FIELDS },
+    { name: "V2_REFUSAL_DETAIL_TYPES", kind: "typeNames", pointer: "#/$defs/refusal/properties/details/additionalProperties", values: V2_REFUSAL_DETAIL_TYPES },
+];
+/**
+ * Harness-side subsets of a contract vocabulary, not restatements of one. They encode
+ * the harness's own semantics — which lease outcomes a receipt may be appended after,
+ * and which may precede that release — so the assertion on them is containment, not
+ * equality. Anything the test *equality*-asserts belongs in the manifest above
+ * instead; membership here is a claim that the harness deliberately holds a subset.
+ */
+export const V2_VOCABULARY_SUBSETS = [
+    { name: "V2_RECEIPT_RELEASE_OUTCOMES", pointer: "#/$defs/workspaceLease/properties/outcome", values: V2_RECEIPT_RELEASE_OUTCOMES },
+    { name: "V2_RECEIPT_PRIOR_LEASE_OUTCOMES", pointer: "#/$defs/workspaceLease/properties/outcome", values: V2_RECEIPT_PRIOR_LEASE_OUTCOMES },
+];
+const V2_CORRELATION_MAX_BYTES = 32 * 1024;
+const V2_CORRELATION_MAX_FIELD_CHARS = 512;
+const V2_CORRELATION_MAX_SCOPE_BYTES = 4 * 1024;
+function piDaddyStreamKey(record, index) {
+    if (record.ledgerVersion === undefined)
+        return JSON.stringify(["legacy", string(record.childId) ?? `missing-child:${index}`]);
+    const correlation = object(record.correlation);
+    return JSON.stringify([
+        string(correlation?.run_id) ?? `missing-run:${index}`,
+        string(correlation?.task_id) ?? `missing-task:${index}`,
+        string(record.workspaceId) ?? string(correlation?.workspace_id) ?? "",
+        string(record.childId) ?? `missing-child:${index}`,
+    ]);
+}
+function normalizedPiDaddyStreamKey(event, index) {
+    if (event.source === "pi-daddy-0.17")
+        return JSON.stringify(["legacy", event.child_id ?? `missing-child:${index}`]);
+    const correlation = object(event.attributes?.correlation);
+    return JSON.stringify([
+        event.run_id ?? `missing-run:${index}`,
+        event.task_id ?? `missing-task:${index}`,
+        event.workspace_id ?? string(correlation?.workspace_id) ?? "",
+        event.child_id ?? `missing-child:${index}`,
+    ]);
+}
+function sameRawCorrelationIdentity(left, right) {
+    const leftCorrelation = object(left.correlation);
+    const rightCorrelation = object(right.correlation);
+    return string(leftCorrelation?.run_id) === string(rightCorrelation?.run_id) &&
+        string(leftCorrelation?.task_id) === string(rightCorrelation?.task_id);
+}
+function validatePiDaddyTimestampOrder(records) {
+    const highWaterByChild = new Map();
+    records.forEach((record, index) => {
+        const supportedV2 = record.ledgerVersion === 2;
+        const legacy = record.ledgerVersion === undefined && record.schema_version === undefined && record.event === undefined;
+        if (!supportedV2 && !legacy)
+            return;
+        const at = string(record.ts);
+        if (!validTime(at))
+            throw new Error(`invalid pi-daddy ledger timestamp at line ${index + 1}: ts must be a date-time`);
+        const time = Date.parse(at);
+        const child = piDaddyStreamKey(record, index);
+        const highWater = highWaterByChild.get(child);
+        if (highWater !== undefined && time < highWater && !isRawPiDaddyReceiptInversion(records, index, time)) {
+            throw new Error(`pi-daddy ledger timestamp moves backwards at line ${index + 1}`);
+        }
+        highWaterByChild.set(child, Math.max(highWater ?? time, time));
+    });
+}
+function isRawPiDaddyReceiptInversion(records, index, receiptTime) {
+    const receipt = records[index];
+    const release = records[index - 1];
+    if (receipt?.ledgerVersion !== 2 || receipt.event !== "check_receipt" || release?.ledgerVersion !== 2 || release.event !== "workspace_lease")
+        return false;
+    if (receipt.childId !== release.childId || receipt.workspaceId !== release.workspaceId || !sameRawCorrelationIdentity(receipt, release) || !V2_RECEIPT_RELEASE_OUTCOMES.has(string(release.outcome) ?? ""))
+        return false;
+    const previousLease = records.slice(0, index - 1).reverse().find((record) => record.ledgerVersion === 2 && record.event === "workspace_lease" && record.childId === receipt.childId &&
+        record.workspaceId === receipt.workspaceId && sameRawCorrelationIdentity(receipt, record));
+    return Boolean(previousLease && V2_RECEIPT_PRIOR_LEASE_OUTCOMES.has(string(previousLease.outcome) ?? "") &&
+        validTime(string(previousLease.ts)) && Date.parse(string(previousLease.ts)) <= receiptTime);
+}
+function isAllowedPiDaddyReceiptInversion(adapter, events, index) {
+    if (adapter !== "pi-daddy-v1")
+        return false;
+    const receipt = events[index];
+    const release = events[index - 1];
+    if (receipt?.type !== "check_receipt_recorded" || !NORMALIZED_RECEIPT_RELEASE_EVENTS.has(release?.type))
+        return false;
+    if (receipt.child_id !== release.child_id || receipt.workspace_id !== release.workspace_id || receipt.run_id !== release.run_id || receipt.task_id !== release.task_id || !validTime(receipt.at))
+        return false;
+    const receiptTime = Date.parse(receipt.at);
+    const previousLease = events.slice(0, index - 1).reverse().find((event) => event.attributes?.native_event === "workspace_lease" && event.child_id === receipt.child_id &&
+        event.workspace_id === receipt.workspace_id && event.run_id === receipt.run_id && event.task_id === receipt.task_id);
+    return Boolean(previousLease && new Set(["writer_lease_acquired", "writer_lease_recovered"]).has(previousLease.type) &&
+        validTime(previousLease.at) && Date.parse(previousLease.at) <= receiptTime);
+}
+function normalizePiDaddyV2(record, index) {
+    const line = index + 1;
+    const nativeEvent = requireV2Discriminator(record, line);
+    const at = requireV2String(record, "ts", nativeEvent, line);
+    const childId = requireV2String(record, "childId", nativeEvent, line);
+    const correlation = requireV2Correlation(record, nativeEvent, line);
+    const carriesTopWorkspace = nativeEvent === "workspace_lease" || nativeEvent === "check_receipt";
+    if (!carriesTopWorkspace && record.workspaceId !== undefined) {
+        throw new Error(`invalid pi-daddy v2 ${nativeEvent} at line ${line}: workspaceId is not part of the public variant`);
+    }
+    const topWorkspace = carriesTopWorkspace ? string(record.workspaceId) : undefined;
+    const correlationWorkspace = string(correlation.workspace_id);
+    if (topWorkspace && correlationWorkspace && topWorkspace !== correlationWorkspace) {
+        throw new Error(`invalid pi-daddy v2 ${nativeEvent} at line ${line}: workspaceId disagrees with correlation.workspace_id`);
+    }
+    if (nativeEvent !== "capability_decision" && (record.taskDigest !== undefined || record.definitionDigest !== undefined)) {
+        throw new Error(`invalid pi-daddy v2 ${nativeEvent} at line ${line}: taskDigest and definitionDigest belong only to capability_decision`);
+    }
+    const definition = nativeEvent === "capability_decision" ? object(record.definitionDigest) : undefined;
+    const trustedTask = nativeEvent === "capability_decision" ? string(record.taskDigest) : undefined;
+    const trustedDefinition = nativeEvent === "capability_decision" ? string(definition?.sha256) : undefined;
+    const common = {
+        event_version: TRAJECTORY_EVENT_VERSION,
+        source: "pi-daddy-v2",
+        at,
+        run_id: string(correlation.run_id),
+        task_id: string(correlation.task_id),
+        // correlation.workspace_id is a controller-supplied join label, not proof that
+        // pi-daddy resolved or leased that workspace. Only a top-level runtime identity
+        // is promoted into the adapter-neutral authoritative-looking field.
+        workspace_id: topWorkspace,
+        context_id: string(correlation.context_id),
+        child_id: childId,
+        phase: string(correlation.phase),
+        digests: anyDefined({
+            task: trustedTask,
+            definition: trustedDefinition,
+            correlation_plan: string(correlation.plan_digest),
+            correlation_task: string(correlation.task_digest),
+            correlation_definition: string(correlation.definition_digest),
+            correlation_base: string(correlation.base_sha),
+            correlation_head: string(correlation.head_sha),
+            correlation_tree: string(correlation.tree_sha),
+        }),
+    };
+    const commonAttributes = safeAttributes({
+        ledger_version: 2,
+        native_event: nativeEvent,
+        correlation: sanitizeAttributes(correlation),
+        event_seq: finiteNumber(correlation.event_seq),
+        last_change_seq: finiteNumber(correlation.last_change_seq),
+        last_authority_seq: finiteNumber(correlation.last_authority_seq),
+        check_receipt_id: string(correlation.check_receipt_id),
+        assurance: string(correlation.assurance),
+        assurance_effective: string(correlation.assurance_effective),
+        policy_label: string(correlation.policy_label),
+        assurance_source: string(correlation.assurance_source),
+        assurance_scope: correlation.assurance_scope,
+        activated_at: string(correlation.activated_at),
+    });
+    if (nativeEvent === "capability_decision") {
+        if (record.definitionDigest !== undefined && (!definition || !string(definition.name) || !string(definition.source) || !trustedDefinition || !/^[a-fA-F0-9]{64}$/.test(trustedDefinition))) {
+            throw new Error(`invalid pi-daddy v2 capability_decision at line ${line}: definitionDigest requires non-empty name, source, and sha256`);
+        }
+        const parentId = requireV2String(record, "parentId", nativeEvent, line);
+        const executor = requireV2Executor(record, nativeEvent, line);
+        const taskDigest = requireV2String(record, "taskDigest", nativeEvent, line);
+        if (!/^[a-fA-F0-9]{64}$/.test(taskDigest))
+            throw new Error(`invalid pi-daddy v2 capability_decision at line ${line}: taskDigest must be sha256`);
+        if (!Number.isInteger(record.depth) || typeof record.blocked !== "boolean") {
+            throw new Error(`invalid pi-daddy v2 capability_decision at line ${line}: depth and blocked are required`);
+        }
+        const requested = requireV2StringArray(record, "requested", nativeEvent, line);
+        const parentGrant = requireV2StringArray(record, "parentGrant", nativeEvent, line);
+        const effective = requireV2StringArray(record, "effective", nativeEvent, line);
+        const denied = requireV2StringArray(record, "denied", nativeEvent, line);
+        const clipped = requireV2StringArray(record, "clipped", nativeEvent, line);
+        const gated = requireV2StringArray(record, "gatedBlocked", nativeEvent, line);
+        const approved = optionalV2StringArray(record, "approved", nativeEvent, line);
+        const agentType = optionalV2SafeString(record.agentType, "agentType", nativeEvent, line);
+        const humanDenied = optionalV2Boolean(record, "humanDenied", nativeEvent, line);
+        const refusal = structuredRefusal(record.refusal, nativeEvent, line);
+        if (!record.blocked && refusal)
+            throw new Error(`invalid pi-daddy v2 capability_decision at line ${line}: an allowed decision cannot carry a refusal`);
+        validateCapabilityPartition(requested, effective, denied, clipped, gated, approved, Boolean(record.blocked), line);
+        const approvalSource = optionalV2Enum(record.approvalSource, "approvalSource", V2_APPROVAL_SOURCES, nativeEvent, line);
+        const approvalSources = optionalV2EnumMap(record.approvalSources, "approvalSources", V2_APPROVAL_SOURCES, nativeEvent, line);
+        const approvalScope = optionalV2Enum(record.approvalScope, "approvalScope", V2_APPROVAL_SCOPES, nativeEvent, line);
+        const approvalScopes = optionalV2EnumMap(record.approvalScopes, "approvalScopes", V2_APPROVAL_SCOPES, nativeEvent, line);
+        const approvalExpiresAt = optionalV2StringMap(record.approvalExpiresAt, "approvalExpiresAt", nativeEvent, line, validTime);
+        const approvalUses = optionalV2ApprovalUses(record.approvalUses, nativeEvent, line);
+        validateApprovalEvidence(approved ?? [], approvalSource, approvalSources, approvalScopes, approvalExpiresAt, approvalUses, line);
+        const normalizedRequested = [...new Set(requested)];
+        const attributes = safeAttributes({
+            ...commonAttributes,
+            depth: record.depth,
+            agent_type: agentType,
+            native_requested: normalizedRequested.length === requested.length ? undefined : requested,
+            executor,
+            task_from: string(record.taskFrom),
+            parent_grant: parentGrant,
+            denied,
+            clipped,
+            gated_blocked: gated,
+            blocked: record.blocked,
+            reason: string(record.reason),
+            approved,
+            approval_source: approvalSource,
+            approval_sources: approvalSources,
+            approval_scope: approvalScope,
+            approval_scopes: approvalScopes,
+            approval_expires_at: approvalExpiresAt,
+            approval_uses: approvalUses,
+            human_denied: humanDenied,
+            gate_outcome: string(record.gateOutcome),
+            definition_name: string(definition?.name),
+            definition_source: string(definition?.source),
+            structured_refusal: refusal,
+        });
+        const base = { ...common, parent_id: parentId, requested_capabilities: normalizedRequested, effective_capabilities: effective, attributes };
+        const refusalCode = string(refusal?.code);
+        const events = [
+            ...normalizedRequested.map((capability) => ({ ...base, type: "capability_requested", capability })),
+        ];
+        const sources = approvalSources;
+        const scopes = approvalScopes;
+        const expiries = approvalExpiresAt;
+        const uses = approvalUses;
+        for (const capability of approved ?? []) {
+            events.push(cleanEvent({
+                ...base,
+                type: "approval_used",
+                capability,
+                approval: cleanObject({
+                    capability,
+                    subject: approvalSubject(agentType),
+                    source: string(sources?.[capability]) ?? string(record.approvalSource),
+                    scope: string(scopes?.[capability]) ?? string(record.approvalScope),
+                    expires_at: string(expiries?.[capability]),
+                    used_at: at,
+                }),
+                attributes: safeAttributes({ ...attributes, approval_uses: object(uses?.[capability]) }),
+            }));
+        }
+        const approvedSet = new Set(approved ?? []);
+        events.push(...(record.blocked ? [] : effective.map((capability) => ({ ...base, type: "capability_granted", capability }))), ...[...new Set([...denied, ...gated.filter((capability) => !approvedSet.has(capability))])].map((capability) => ({
+            ...base,
+            type: "capability_refused",
+            capability,
+            refusal_code: denied.includes(capability) ? "CAPABILITY_ESCALATION" : refusalCode,
+        })));
+        events.push(cleanEvent({
+            ...base,
+            type: record.blocked ? "child_spawn_refused" : "capability_decision",
+            refusal_code: refusalCode,
+        }));
+        return events;
+    }
+    if (nativeEvent === "workspace_lease") {
+        const workspaceId = requireV2String(record, "workspaceId", nativeEvent, line);
+        requireV2String(record, "root", nativeEvent, line);
+        const access = requireV2String(record, "access", nativeEvent, line);
+        const outcome = requireV2String(record, "outcome", nativeEvent, line);
+        if (!V2_LEASE_ACCESS.has(access) || !V2_LEASE_OUTCOMES.has(outcome)) {
+            throw new Error(`invalid pi-daddy v2 workspace_lease at line ${line}: access or outcome is unsupported`);
+        }
+        if (record.recovered !== undefined && typeof record.recovered !== "boolean" && record.recovered !== "unknown") {
+            throw new Error(`invalid pi-daddy v2 workspace_lease at line ${line}: recovered must be boolean or \"unknown\"`);
+        }
+        const refusal = structuredRefusal(record.refusal, nativeEvent, line);
+        const type = access === "read"
+            ? `workspace_read_${outcome.replaceAll("-", "_")}`
+            : outcome === "refused" && refusal?.code === "WORKSPACE_WRITE_CONFLICT"
+                ? "writer_lease_conflict"
+                : `writer_lease_${outcome.replaceAll("-", "_")}`;
+        return [cleanEvent({
+                ...common,
+                workspace_id: workspaceId,
+                type,
+                refusal_code: string(refusal?.code),
+                attributes: safeAttributes({
+                    ...commonAttributes,
+                    root: string(record.root),
+                    access,
+                    outcome,
+                    recovered: record.recovered,
+                    release_reason: string(record.releaseReason),
+                    structured_refusal: refusal,
+                }),
+            })];
+    }
+    if (nativeEvent === "child_lifecycle") {
+        const state = requireV2String(record, "state", nativeEvent, line);
+        const executor = requireV2Executor(record, nativeEvent, line);
+        if (!V2_LIFECYCLE_STATES.has(state)) {
+            throw new Error(`invalid pi-daddy v2 child_lifecycle at line ${line}: state is unsupported`);
+        }
+        if (record.exitCode !== undefined && record.exitCode !== null && !Number.isInteger(record.exitCode)) {
+            throw new Error(`invalid pi-daddy v2 child_lifecycle at line ${line}: exitCode must be an integer or null`);
+        }
+        const timedOut = optionalV2Boolean(record, "timedOut", nativeEvent, line);
+        const aborted = optionalV2Boolean(record, "aborted", nativeEvent, line);
+        const truncated = optionalV2Boolean(record, "truncated", nativeEvent, line);
+        const type = state === "starting" ? "child_started" : state === "completed" ? "child_completed" : "child_failed";
+        return [cleanEvent({
+                ...common,
+                type,
+                exit_code: Number.isInteger(record.exitCode) ? Number(record.exitCode) : undefined,
+                attributes: safeAttributes({
+                    ...commonAttributes,
+                    state,
+                    executor,
+                    exit_code: record.exitCode,
+                    signal: record.signal,
+                    timed_out: timedOut,
+                    aborted,
+                    truncated,
+                    reason: string(record.reason),
+                }),
+            })];
+    }
+    const workspaceId = requireV2String(record, "workspaceId", nativeEvent, line);
+    const receiptId = requireV2String(record, "receiptId", nativeEvent, line);
+    if (!/^[a-fA-F0-9]{64}$/.test(receiptId)) {
+        throw new Error(`invalid pi-daddy v2 check_receipt at line ${line}: receiptId must be sha256`);
+    }
+    const checkId = requireV2String(record, "checkId", nativeEvent, line);
+    const treeSha = requireV2String(record, "treeSha", nativeEvent, line);
+    if (!/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/.test(treeSha)) {
+        throw new Error(`invalid pi-daddy v2 check_receipt at line ${line}: treeSha must be a git object id`);
+    }
+    // The receipt's top-level `treeSha` is the candidate identity pi-daddy measured;
+    // `correlation.tree_sha` is a controller label the producer documents as opaque
+    // and non-authoritative, and its own builders emit the two independently. The
+    // adapter therefore promotes only the measured value into `digests.tree` and
+    // keeps the correlation copy in `digests.correlation_tree`. Requiring the two to
+    // agree rejected pi-daddy's own canonical receipt and, worse, let a controller
+    // string vouch for a measured one.
+    return [cleanEvent({
+            ...common,
+            workspace_id: workspaceId,
+            type: "check_receipt_recorded",
+            digests: { ...(common.digests ?? {}), tree: treeSha },
+            attributes: safeAttributes({
+                ...commonAttributes,
+                receipt_id: receiptId,
+                check_id: checkId,
+                check_receipt_id: string(correlation.check_receipt_id),
+            }),
+        })];
+}
+function requireV2Correlation(record, event, line) {
+    const correlation = object(record.correlation);
+    if (!correlation) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: correlation.run_id and correlation.task_id are required for workflow joins`);
+    }
+    const encoded = JSON.stringify(correlation);
+    if (Buffer.byteLength(encoded) > V2_CORRELATION_MAX_BYTES) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: correlation exceeds ${V2_CORRELATION_MAX_BYTES} bytes`);
+    }
+    const undeclared = Object.keys(correlation).filter((key) => !V2_CORRELATION_FIELDS.has(key));
+    if (undeclared.length > 0) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: correlation carries fields outside the pinned schema 1.0 contract [REDACTED field names]`);
+    }
+    for (const [key, value] of Object.entries(correlation)) {
+        if (value === undefined || value === null)
+            continue;
+        if (key === "assurance_scope") {
+            const size = Buffer.byteLength(JSON.stringify(value));
+            if (size > V2_CORRELATION_MAX_SCOPE_BYTES) {
+                throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: correlation assurance_scope exceeds ${V2_CORRELATION_MAX_SCOPE_BYTES} bytes`);
+            }
+            continue;
+        }
+        if (V2_CORRELATION_NUMERIC_FIELDS.has(key)) {
+            if (typeof value !== "number" || !Number.isFinite(value)) {
+                throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: correlation ${key} must be a finite number`);
+            }
+            continue;
+        }
+        if (typeof value !== "string") {
+            throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: correlation ${key} must be a string`);
+        }
+        if (value.length > V2_CORRELATION_MAX_FIELD_CHARS) {
+            throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: correlation ${key} exceeds ${V2_CORRELATION_MAX_FIELD_CHARS} characters`);
+        }
+        if (redactText(value) !== value) {
+            throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: correlation ${key} contains a sensitive value`);
+        }
+    }
+    if (!string(correlation.run_id) || !string(correlation.task_id)) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: correlation.run_id and correlation.task_id are required for workflow joins`);
+    }
+    return Object.fromEntries(Object.entries(correlation).filter(([, value]) => value !== undefined && value !== null));
+}
+function requireV2String(record, field, event, line) {
+    const value = string(record[field]);
+    if (!value)
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} is required`);
+    if (redactText(value) !== value)
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} contains a sensitive value`);
+    return value;
+}
+function requireV2Executor(record, event, line) {
+    const executor = requireV2String(record, "executor", event, line);
+    if (!V2_EXECUTORS.has(executor)) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: executor must be process or herdr`);
+    }
+    return executor;
+}
+function requireV2StringArray(record, field, event, line) {
+    const value = stringArray(record[field]);
+    if (!value)
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} must be an array of strings`);
+    if (value.some((entry) => redactText(entry) !== entry)) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} contains a sensitive value`);
+    }
+    return value;
+}
+function optionalV2StringArray(record, field, event, line) {
+    if (record[field] === undefined)
+        return undefined;
+    return requireV2StringArray(record, field, event, line);
+}
+function optionalV2SafeString(value, field, event, line) {
+    if (value === undefined)
+        return undefined;
+    const parsed = string(value);
+    if (!parsed)
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} must be a non-empty string`);
+    if (redactText(parsed) !== parsed)
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} contains a sensitive value`);
+    return parsed;
+}
+function optionalV2Enum(value, field, allowed, event, line) {
+    if (value === undefined)
+        return undefined;
+    const parsed = string(value);
+    if (!parsed || !allowed.has(parsed)) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} must be one of ${[...allowed].join(", ")}`);
+    }
+    return parsed;
+}
+function optionalV2EnumMap(value, field, allowed, event, line) {
+    if (value === undefined)
+        return undefined;
+    const parsed = object(value);
+    if (!parsed)
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} must be an object`);
+    const entries = Object.entries(parsed);
+    if (entries.some(([key, entry]) => !key || typeof entry !== "string" || !allowed.has(entry))) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} values must be one of ${[...allowed].join(", ")}`);
+    }
+    return Object.fromEntries(entries);
+}
+function optionalV2StringMap(value, field, event, line, validate = () => true) {
+    if (value === undefined)
+        return undefined;
+    const parsed = object(value);
+    if (!parsed)
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} must be an object`);
+    const entries = Object.entries(parsed);
+    if (entries.some(([key, entry]) => !key || typeof entry !== "string" || !validate(entry))) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} must map capabilities to valid strings`);
+    }
+    return Object.fromEntries(entries);
+}
+function optionalV2ApprovalUses(value, event, line) {
+    if (value === undefined)
+        return undefined;
+    const parsed = object(value);
+    if (!parsed)
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: approvalUses must be an object`);
+    const output = {};
+    for (const [capability, boundsValue] of Object.entries(parsed)) {
+        const bounds = object(boundsValue);
+        if (!capability || !bounds || !Number.isInteger(bounds.max) || !Number.isInteger(bounds.remaining) ||
+            Number(bounds.max) < 0 || Number(bounds.remaining) < 0 || Number(bounds.remaining) > Number(bounds.max)) {
+            throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: approvalUses requires integer max/remaining bounds`);
+        }
+        output[capability] = { max: Number(bounds.max), remaining: Number(bounds.remaining) };
+    }
+    return output;
+}
+function validateCapabilityPartition(requested, effective, denied, clipped, gated, approved, blocked, line) {
+    const groups = [effective, denied, clipped, gated];
+    if (groups.some((values) => new Set(values).size !== values.length)) {
+        throw new Error(`invalid pi-daddy v2 capability_decision at line ${line}: result capability arrays must not contain duplicates`);
+    }
+    const requestedSet = new Set(requested);
+    if (groups.some((values) => values.some((capability) => !requestedSet.has(capability)))) {
+        throw new Error(`invalid pi-daddy v2 capability_decision at line ${line}: effective, denied, clipped, and gatedBlocked must partition requested`);
+    }
+    const flattened = groups.flat();
+    if (new Set(flattened).size !== flattened.length) {
+        throw new Error(`invalid pi-daddy v2 capability_decision at line ${line}: effective, denied, clipped, and gatedBlocked must be disjoint subsets of requested`);
+    }
+    if ((approved ?? []).some((capability) => !requestedSet.has(capability) || (blocked ? !effective.includes(capability) && !gated.includes(capability) : !effective.includes(capability)))) {
+        throw new Error(`invalid pi-daddy v2 capability_decision at line ${line}: approved capabilities must be requested and reflected in the resolved decision`);
+    }
+}
+function validateApprovalEvidence(approved, scalarSource, sources, scopes, expiries, uses, line) {
+    const approvedSet = new Set(approved);
+    for (const [field, map] of [["approvalSources", sources], ["approvalScopes", scopes], ["approvalExpiresAt", expiries], ["approvalUses", uses]]) {
+        if (map && Object.keys(map).some((capability) => !approvedSet.has(capability))) {
+            throw new Error(`invalid pi-daddy v2 capability_decision at line ${line}: ${field} keys must be approved capabilities`);
+        }
+    }
+    if (approved.some((capability) => !sources?.[capability] && !scalarSource)) {
+        throw new Error(`invalid pi-daddy v2 capability_decision at line ${line}: each approved capability requires an approval source`);
+    }
+    if (approved.length === 0 && (scalarSource || sources || scopes || expiries || uses)) {
+        throw new Error(`invalid pi-daddy v2 capability_decision at line ${line}: approval evidence requires approved capabilities`);
+    }
+}
+function optionalV2Boolean(record, field, event, line) {
+    const value = record[field];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "boolean")
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: ${field} must be boolean`);
+    return value;
+}
+function approvalSubject(value) {
+    const agentType = string(value);
+    return agentType === undefined || agentType === "delegate" ? "<delegate>" : agentType;
+}
+function structuredRefusal(value, event, line) {
+    if (value === undefined)
+        return undefined;
+    const parsed = object(value);
+    const code = string(parsed?.code);
+    if (!parsed || !code || !string(parsed.message)) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: refusal requires code and message`);
+    }
+    if (!V2_REFUSAL_CODES.has(code)) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: refusal has unsupported code ${safeDiagnosticValue(code)}`);
+    }
+    const unknown = Object.keys(parsed).filter((key) => !V2_REFUSAL_FIELDS.has(key));
+    if (unknown.length > 0)
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: refusal carries unsupported fields`);
+    const details = parsed.details === undefined ? undefined : object(parsed.details);
+    if (parsed.details !== undefined && (!details || Object.values(details).some((entry) => !V2_REFUSAL_DETAIL_TYPES.has(entry === null ? "null" : typeof entry)))) {
+        throw new Error(`invalid pi-daddy v2 ${event} at line ${line}: refusal.details must contain scalar values`);
+    }
+    return parsed;
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
 function normalizeLegacyGrant(record, index) {
     const requiredArrays = ["requested", "parentGrant", "effective", "denied", "clipped", "gatedBlocked"];
     if (typeof record.ts !== "string" || typeof record.parentId !== "string" || typeof record.childId !== "string" ||
@@ -262,65 +928,6 @@ function normalizeLegacyGrant(record, index) {
     events.push(spawn);
     return events;
 }
-function normalizePiDaddyV1(record, seq, index) {
-    const recordType = string(record.record_type);
-    const action = string(record.action);
-    if (!recordType || !action || !string(record.ts))
-        throw new Error(`invalid pi-daddy governance v1 record at line ${index + 1}: record_type, action, and ts are required`);
-    let type;
-    if (recordType === "writer_lease") {
-        if (!new Set(["acquired", "refused", "conflict", "released"]).has(action))
-            throw new Error(`invalid writer_lease action ${JSON.stringify(action)} at line ${index + 1}`);
-        type = action === "conflict" ? "writer_lease_conflict" : `writer_lease_${action}`;
-    }
-    else if (recordType === "approval") {
-        if (!new Set(["granted", "used", "refused"]).has(action))
-            throw new Error(`invalid approval action ${JSON.stringify(action)} at line ${index + 1}`);
-        type = `approval_${action}`;
-    }
-    else if (recordType === "child_lifecycle") {
-        if (!new Set(["started", "completed", "refused"]).has(action))
-            throw new Error(`invalid child_lifecycle action ${JSON.stringify(action)} at line ${index + 1}`);
-        type = action === "refused" ? "child_spawn_refused" : `child_${action}`;
-    }
-    else if (recordType === "capability") {
-        if (!new Set(["requested", "granted", "refused"]).has(action))
-            throw new Error(`invalid capability action ${JSON.stringify(action)} at line ${index + 1}`);
-        type = `capability_${action}`;
-    }
-    else {
-        throw new Error(`unsupported pi-daddy governance v1 record_type ${JSON.stringify(recordType)} at line ${index + 1}`);
-    }
-    return cleanEvent({
-        event_version: TRAJECTORY_EVENT_VERSION,
-        seq,
-        type,
-        source: "pi-daddy-v1",
-        at: string(record.ts),
-        run_id: string(record.run_id),
-        task_id: string(record.task_id),
-        workspace_id: string(record.workspace_id),
-        context_id: string(record.context_id),
-        parent_id: string(record.parent_id),
-        child_id: string(record.child_id),
-        capability: string(record.capability),
-        requested_capabilities: stringArray(record.requested),
-        effective_capabilities: stringArray(record.effective),
-        refusal_code: string(record.refusal_code),
-        digests: anyDefined({ task: string(record.task_digest), definition: string(record.definition_digest) }),
-        approval: recordType === "approval" ? cleanObject({
-            id: string(record.approval_id),
-            capability: string(record.capability),
-            subject: string(record.subject),
-            source: string(record.source),
-            scope: string(record.scope),
-            approved_at: string(record.approved_at),
-            expires_at: string(record.expires_at),
-            used_at: string(record.used_at),
-        }) : undefined,
-        attributes: sanitizeAttributes(without(record, ["schema_version", "record_type", "ts", "action", "run_id", "task_id", "workspace_id", "context_id", "parent_id", "child_id", "capability", "requested", "effective", "refusal_code", "task_digest", "definition_digest", "approval_id", "subject", "source", "scope", "approved_at", "expires_at", "used_at"])),
-    });
-}
 function legacyRefusalCode(record) {
     const denied = stringArray(record.denied) ?? [];
     const gated = stringArray(record.gatedBlocked) ?? [];
@@ -357,7 +964,7 @@ function validatePrincipalIntegrity(records) {
     records.forEach((record, index) => {
         const line = index + 1;
         if (record.schema_version !== "1.0") {
-            throw new Error(`unsupported principal assurance schema version ${JSON.stringify(record.schema_version)} at line ${line}; expected "1.0"`);
+            throw new Error(`unsupported principal assurance schema version ${safeDiagnosticValue(record.schema_version)} at line ${line}; expected "1.0"`);
         }
         if (record.seq !== line)
             throw new Error(`principal assurance integrity failure at line ${line}: sequence mismatch`);
@@ -416,10 +1023,23 @@ function validTime(value) {
         return false;
     return day >= 1 && day <= new Date(Date.UTC(year, month, 0)).getUTCDate();
 }
+function safeDiagnosticValue(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(value);
+    if (typeof value === "string" && /^[A-Za-z0-9_.-]{1,64}$/.test(value) && redactText(value) === value)
+        return JSON.stringify(value);
+    return "[REDACTED invalid value]";
+}
+function sanitizePersistedError(error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    return redactText(raw)
+        .replace(/("?(?:password|passwd|secret|token|api[-_]?key|authorization|credential)"?\s*[:=]\s*"?)[^\s,}"']+/gi, "$1[REDACTED]")
+        .slice(0, 1_000);
+}
 function sanitizeAttributes(value) {
     const redacted = redactArgs(value);
     const sensitiveKey = /(secret|token|password|passphrase|api[_-]?key|authorization|cookie|credential)/i;
-    const freeTextKey = /^(request|command|stdout|stderr|output|prompt|content)$/i;
+    const freeTextKey = /^(request|command|stdout|stderr|output|prompt|content|reason|message|release_reason|diagnostic)$/i;
     const walk = (current, key = "") => {
         if (sensitiveKey.test(key))
             return "[REDACTED]";
@@ -446,15 +1066,19 @@ function parseJsonl(text, label) {
             return value;
         }
         catch (error) {
-            throw new Error(`${label} ledger line ${index + 1} is invalid JSON: ${error instanceof Error ? error.message : error}`);
+            throw new Error(`${label} ledger line ${index + 1} is invalid JSON [REDACTED parser detail]`);
         }
     });
 }
 function object(value) { return value && typeof value === "object" && !Array.isArray(value) ? value : undefined; }
 function string(value) { return typeof value === "string" && value.length ? value : undefined; }
 function stringArray(value) { return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : undefined; }
-function anyDefined(value) { return Object.values(value).some((entry) => entry !== undefined) ? value : undefined; }
+function anyDefined(value) {
+    const defined = cleanObject(value);
+    return Object.keys(defined).length > 0 ? defined : undefined;
+}
 function cleanObject(value) { return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined)); }
+function safeAttributes(value) { return sanitizeAttributes(cleanObject(value)); }
 function cleanEvent(event) { return cleanObject(event); }
 function without(record, keys) { const omitted = new Set(keys); return Object.fromEntries(Object.entries(record).filter(([key, value]) => !omitted.has(key) && value !== undefined)); }
 function walkFiles(root, relative = "") {