@skill-harness/adapters 0.10.0 → 0.12.0

package/dist/trajectory.js

@@ -2,8 +2,9 @@ import { createHash } from "node:crypto";
 import { readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { TRAJECTORY_EVENT_VERSION, deserializeTrajectoryEvents, matchesGlob, redactArgs, redactText } from "@skill-harness/core";
-import { assertSupportedSchema, declaredPropertyNames, validateClosedSchema } from "./closed-schema.js";
+import { assertSupportedSchema, assertSupportedSchemaV3, declaredPropertyNames, validateClosedSchema, validateClosedSchemaV3, } from "./closed-schema.js";
 import { PI_DADDY_CONTRACT_COMMIT, PI_DADDY_LEDGER_V2_SCHEMA } from "./pi-daddy-ledger-v2.js";
+import { PI_DADDY_LEDGER_V3_CONTRACT_COMMIT, PI_DADDY_LEDGER_V3_SCHEMA } from "./pi-daddy-ledger-v3.js";
 /** Read and normalize declared workspace-local native ledger files. */
 export function collectTrajectorySources(cwd, sources) {
     const files = walkFiles(cwd);
@@ -29,15 +30,19 @@ export function collectTrajectorySources(cwd, sources) {
                 const normalized = source.adapter === "principal-assurance-v1"
                     ? normalizePrincipalAssuranceLedger(text)
                     : source.adapter === "pi-daddy-v1"
-                        ? normalizePiDaddyLedger(text)
-                        : deserializeTrajectoryEvents(text);
+                        ? normalizePiDaddyLegacyLedger(text)
+                        : source.adapter === "pi-daddy-ledger-v3"
+                            ? normalizePiDaddyLedgerV3(text)
+                            : deserializeTrajectoryEvents(text);
                 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)) {
                     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 stream = source.adapter === "pi-daddy-v1" || source.adapter === "pi-daddy-ledger-v3"
+                            ? 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");
@@ -137,6 +142,26 @@ export function normalizePiTraces(traces) {
     }
     return events;
 }
+const PRINCIPAL_ASSURANCE_SOURCES = new Set([
+    "default", "flag", "alias", "natural-language", "policy", "user", "user-downgrade",
+]);
+function validatePrincipalAssurance(record, line) {
+    if (record.assurance === undefined)
+        return;
+    const assurance = object(record.assurance);
+    if (!assurance || typeof assurance.source !== "string" || !PRINCIPAL_ASSURANCE_SOURCES.has(assurance.source)) {
+        throw new Error(`invalid principal assurance v1 event at line ${line}: assurance.source is not a recognized source`);
+    }
+    const scope = object(assurance.scope);
+    if (!scope || Object.keys(scope).some((key) => key !== "type" && key !== "selectors") ||
+        (scope.type !== "entire-run" && scope.type !== "selectors") || !Array.isArray(scope.selectors) ||
+        scope.selectors.some((selector) => typeof selector !== "string" || !selector) ||
+        new Set(scope.selectors).size !== scope.selectors.length ||
+        (scope.type === "entire-run" && scope.selectors.length !== 0) ||
+        (scope.type === "selectors" && scope.selectors.length === 0)) {
+        throw new Error(`invalid principal assurance v1 event at line ${line}: assurance.scope is not a closed structured scope`);
+    }
+}
 /** Normalize principal-pi-skills' immutable assurance event schema v1.0. */
 export function normalizePrincipalAssuranceLedger(text) {
     const records = parseJsonl(text, "principal assurance");
@@ -148,6 +173,7 @@ export function normalizePrincipalAssuranceLedger(text) {
         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`);
         }
+        validatePrincipalAssurance(record, index + 1);
         const packet = object(record.packet);
         const definitionDigests = object(packet?.definition_digests);
         const definition = typeof record.definition_digest === "string"
@@ -184,10 +210,28 @@ export function normalizePrincipalAssuranceLedger(text) {
     });
 }
 /**
- * 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.
+ * Normalize pi-daddy's public ledgers: unversioned 0.17 GrantRecord lines,
+ * frozen ledgerVersion 2 events, and separately pinned production ledgerVersion
+ * 3 events. Explicit version dispatch precedes legacy fallback, so an unknown or
+ * malformed new record is never reinterpreted as an old grant.
  */
+/** Historical selector behavior: unversioned 0.17 and frozen ledger v2 only. */
+export function normalizePiDaddyLegacyLedger(text) {
+    const records = parseJsonl(text, "pi-daddy");
+    const explicitV3 = records.findIndex((record) => record.ledgerVersion === 3);
+    if (explicitV3 >= 0)
+        throw new Error(`pi-daddy-v1 selector does not admit ledgerVersion 3 at line ${explicitV3 + 1}; use pi-daddy-ledger-v3`);
+    return normalizePiDaddyLedger(text);
+}
+/** Separately versioned selector: every line must be an explicit ledgerVersion 3 event. */
+export function normalizePiDaddyLedgerV3(text) {
+    const records = parseJsonl(text, "pi-daddy");
+    const wrong = records.findIndex((record) => record.ledgerVersion !== 3);
+    if (wrong >= 0)
+        throw new Error(`pi-daddy-ledger-v3 requires explicit ledgerVersion 3 at line ${wrong + 1}`);
+    return normalizePiDaddyLedger(text);
+}
+/** Programmatic mixed-version dispatcher; source declarations use explicit selectors above. */
 export function normalizePiDaddyLedger(text) {
     const records = parseJsonl(text, "pi-daddy");
     validatePiDaddyTimestampOrder(records);
@@ -195,23 +239,30 @@ export function normalizePiDaddyLedger(text) {
     let seq = 1;
     records.forEach((record, 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`);
+            if (record.ledgerVersion === 2) {
+                // 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;
             }
-            // 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.ledgerVersion === 3) {
+                requireV3Discriminator(record, index + 1);
+                assertPinnedV3Contract(record, index + 1);
+                for (const event of normalizePiDaddyV3(record, index))
+                    out.push({ ...event, seq: seq++ });
+                return;
+            }
+            throw new Error(`unsupported pi-daddy ledgerVersion ${safeDiagnosticValue(record.ledgerVersion)} at line ${index + 1}; expected 2, 3, or an unversioned 0.17 GrantRecord`);
         }
         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`);
+            throw new Error(`pi-daddy schema_version/record_type at line ${index + 1} is not a public pi-daddy ledger format; expected ledgerVersion 2, ledgerVersion 3, 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`);
+            throw new Error(`pi-daddy event [REDACTED invalid value] at line ${index + 1} is missing explicit ledgerVersion 2 or 3`);
         }
         for (const event of normalizeLegacyGrant(record, index))
             out.push({ ...event, seq: seq++ });
@@ -257,6 +308,33 @@ function assertPinnedV2Contract(record, line) {
     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)}]`);
 }
+/** The five public `ledgerVersion: 3` event discriminators. */
+const V3_EVENTS = new Set(["capability_decision", "workspace_lease", "child_lifecycle", "check_receipt", "workflow_fact"]);
+function requireV3Discriminator(record, line) {
+    const nativeEvent = string(record.event);
+    if (!nativeEvent || !V3_EVENTS.has(nativeEvent)) {
+        throw new Error(`invalid pi-daddy v3 event at line ${line}: event discriminator is required and must be capability_decision, workspace_lease, child_lifecycle, check_receipt, or workflow_fact`);
+    }
+    return nativeEvent;
+}
+let pinnedV3ContractChecked = false;
+let pinnedV3ContractFieldNames;
+function assertPinnedV3Contract(record, line) {
+    if (!pinnedV3ContractChecked) {
+        assertSupportedSchemaV3(PI_DADDY_LEDGER_V3_SCHEMA, "pinned pi-daddy ledger v3 schema");
+        pinnedV3ContractFieldNames = declaredPropertyNames(PI_DADDY_LEDGER_V3_SCHEMA);
+        pinnedV3ContractChecked = true;
+    }
+    const violations = validateClosedSchemaV3(PI_DADDY_LEDGER_V3_SCHEMA, record, { knownFieldNames: pinnedV3ContractFieldNames });
+    if (violations.length === 0)
+        return;
+    const nativeEvent = string(record.event);
+    const label = nativeEvent && V3_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 v3 ${label} at line ${line}: closed contract violation — ${first.path ? `${first.path} ` : ""}${first.message}${extra}` +
+        ` [pi-daddy ${PI_DADDY_LEDGER_V3_CONTRACT_COMMIT.slice(0, 12)}]`);
+}
 const V2_LEASE_OUTCOMES = new Set([
     "acquired", "uncontended", "refused", "released", "released-unrecorded", "lost", "retained", "timeout", "recovered",
 ]);
@@ -281,23 +359,14 @@ const V2_CORRELATION_NUMERIC_FIELDS = new Set(["event_seq", "last_change_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".
+ * pi-daddy's canonical refusal vocabulary, derived directly from the immutable
+ * pinned schema. The producer's `src/refusals.ts` is vendored and digest-checked
+ * separately, while the real-builder verifier proves its production export is
+ * set-equal to this schema-derived runtime set. There is no second list here to
+ * forget when pi-daddy adds a contract-valid code.
  */
-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",
-]);
+export const V2_REFUSAL_CODES = new Set(PI_DADDY_LEDGER_V2_SCHEMA.$defs.refusalCode.enum);
+export const V3_REFUSAL_CODES = new Set(PI_DADDY_LEDGER_V3_SCHEMA.$defs.refusalCode.enum);
 /**
  * Every vocabulary the adapter restates from the pinned contract, paired with the
  * place in the schema it must equal.
@@ -340,6 +409,11 @@ 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}`]);
+    if (record.ledgerVersion === 3) {
+        return record.event === "workflow_fact"
+            ? JSON.stringify(["v3-fact", string(record.factId) ?? `missing-fact:${index}`])
+            : JSON.stringify(["v3-execution", string(record.executionId) ?? `missing-execution:${index}`]);
+    }
     const correlation = object(record.correlation);
     return JSON.stringify([
         string(correlation?.run_id) ?? `missing-run:${index}`,
@@ -351,6 +425,11 @@ function piDaddyStreamKey(record, index) {
 function normalizedPiDaddyStreamKey(event, index) {
     if (event.source === "pi-daddy-0.17")
         return JSON.stringify(["legacy", event.child_id ?? `missing-child:${index}`]);
+    if (event.source === "pi-daddy-v3") {
+        return event.workflow_fact_id
+            ? JSON.stringify(["v3-fact", event.workflow_fact_id])
+            : JSON.stringify(["v3-execution", event.execution_id ?? `missing-execution:${index}`]);
+    }
     const correlation = object(event.attributes?.correlation);
     return JSON.stringify([
         event.run_id ?? `missing-run:${index}`,
@@ -368,9 +447,9 @@ function sameRawCorrelationIdentity(left, right) {
 function validatePiDaddyTimestampOrder(records) {
     const highWaterByChild = new Map();
     records.forEach((record, index) => {
-        const supportedV2 = record.ledgerVersion === 2;
+        const supportedVersion = record.ledgerVersion === 2 || record.ledgerVersion === 3;
         const legacy = record.ledgerVersion === undefined && record.schema_version === undefined && record.event === undefined;
-        if (!supportedV2 && !legacy)
+        if (!supportedVersion && !legacy)
             return;
         const at = string(record.ts);
         if (!validTime(at))
@@ -387,17 +466,17 @@ function validatePiDaddyTimestampOrder(records) {
 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")
+    if ((receipt?.ledgerVersion !== 2 && receipt?.ledgerVersion !== 3) || receipt.event !== "check_receipt" || release?.ledgerVersion !== receipt.ledgerVersion || 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 &&
+    const previousLease = records.slice(0, index - 1).reverse().find((record) => record.ledgerVersion === receipt.ledgerVersion && 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")
+    if (adapter !== "pi-daddy-v1" && adapter !== "pi-daddy-ledger-v3")
         return false;
     const receipt = events[index];
     const release = events[index - 1];
@@ -662,6 +741,246 @@ function normalizePiDaddyV2(record, index) {
             }),
         })];
 }
+function normalizePiDaddyV3(record, index) {
+    const line = index + 1;
+    const nativeEvent = requireV3Discriminator(record, line);
+    const at = requireV3String(record, "ts", nativeEvent, line);
+    const correlation = object(record.correlation) ?? {};
+    const correlationDigests = anyDefined({
+        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 correlationAttributes = safeAttributes({
+        ledger_version: 3,
+        native_event: nativeEvent,
+        correlation: Object.keys(correlation).length ? sanitizeAttributes(correlation) : undefined,
+        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 === "workflow_fact") {
+        return [cleanEvent({
+                event_version: TRAJECTORY_EVENT_VERSION,
+                type: "workflow_fact",
+                source: "pi-daddy-v3",
+                at,
+                run_id: string(correlation.run_id),
+                task_id: string(correlation.task_id),
+                workspace_id: string(correlation.workspace_id),
+                context_id: string(correlation.context_id),
+                phase: string(correlation.phase),
+                workflow_fact_id: requireV3String(record, "factId", nativeEvent, line),
+                digests: correlationDigests,
+                attributes: safeAttributes({
+                    ...correlationAttributes,
+                    source: string(record.source),
+                    provenance: string(record.provenance),
+                    fact_kind: string(record.kind),
+                    fact_subject: string(record.subject),
+                    fact_state: string(record.state),
+                }),
+            })];
+    }
+    const executionId = requireV3String(record, "executionId", nativeEvent, line);
+    const parentExecutionId = record.parentExecutionId === null ? null : requireV3String(record, "parentExecutionId", nativeEvent, line);
+    if (parentExecutionId === executionId)
+        throw new Error(`invalid pi-daddy v3 ${nativeEvent} at line ${line}: an execution cannot be its own parent`);
+    const childId = requireV3String(record, "childId", nativeEvent, line);
+    const carriesTopWorkspace = nativeEvent === "workspace_lease" || nativeEvent === "check_receipt";
+    const topWorkspace = carriesTopWorkspace ? string(record.workspaceId) : undefined;
+    const correlationWorkspace = string(correlation.workspace_id);
+    if (topWorkspace && correlationWorkspace && topWorkspace !== correlationWorkspace) {
+        throw new Error(`invalid pi-daddy v3 ${nativeEvent} at line ${line}: workspaceId disagrees with correlation.workspace_id`);
+    }
+    const common = {
+        event_version: TRAJECTORY_EVENT_VERSION,
+        source: "pi-daddy-v3",
+        at,
+        run_id: string(correlation.run_id),
+        task_id: string(correlation.task_id),
+        workspace_id: topWorkspace,
+        context_id: string(correlation.context_id),
+        child_id: childId,
+        execution_id: executionId,
+        parent_execution_id: parentExecutionId,
+        phase: string(correlation.phase),
+        digests: correlationDigests,
+    };
+    if (nativeEvent === "capability_decision") {
+        const requested = record.requested;
+        const parentGrant = record.parentGrant;
+        const effective = record.effective;
+        const denied = record.denied;
+        const clipped = record.clipped;
+        const gated = record.gatedBlocked;
+        const approved = record.approved;
+        validateCapabilityPartition(requested, effective, denied, clipped, gated, approved, Boolean(record.blocked), line, 3);
+        const approvalSources = object(record.approvalSources);
+        const approvalScopes = object(record.approvalScopes);
+        const approvalExpiresAt = object(record.approvalExpiresAt);
+        const approvalUses = object(record.approvalUses);
+        if (approvalUses && Object.values(approvalUses).some((use) => !object(use) || !Number.isInteger(use.max) || !Number.isInteger(use.remaining) || use.max < 0 || use.remaining < 0 || use.remaining > use.max))
+            throw new Error(`invalid pi-daddy v3 capability_decision at line ${line}: approvalUses requires remaining <= max integer bounds`);
+        validateApprovalEvidence(approved ?? [], string(record.approvalSource), approvalSources, approvalScopes, approvalExpiresAt, approvalUses, line, 3);
+        const refusal = structuredRefusal(record.refusal, nativeEvent, line, 3);
+        if (!record.blocked && refusal)
+            throw new Error(`invalid pi-daddy v3 capability_decision at line ${line}: an allowed decision cannot carry a refusal`);
+        const definition = object(record.definitionDigest);
+        const taskDigest = requireV3String(record, "taskDigest", nativeEvent, line);
+        const trustedDefinition = string(definition?.sha256);
+        const normalizedRequested = [...new Set(requested)];
+        const attributes = safeAttributes({
+            ...correlationAttributes,
+            depth: record.depth,
+            agent_type: string(record.agentType),
+            executor: string(record.executor),
+            task_from: string(record.taskFrom),
+            parent_grant: parentGrant,
+            denied,
+            clipped,
+            gated_blocked: gated,
+            blocked: record.blocked,
+            reason: string(record.reason),
+            approved,
+            approval_source: string(record.approvalSource),
+            approval_sources: approvalSources,
+            approval_scope: string(record.approvalScope),
+            approval_scopes: approvalScopes,
+            approval_expires_at: approvalExpiresAt,
+            approval_uses: approvalUses,
+            human_denied: record.humanDenied,
+            gate_outcome: string(record.gateOutcome),
+            definition_name: string(definition?.name),
+            definition_source: string(definition?.source),
+            structured_refusal: refusal,
+        });
+        const base = {
+            ...common,
+            parent_id: requireV3String(record, "parentId", nativeEvent, line),
+            task_from_execution_id: string(record.taskFromExecutionId),
+            requested_capabilities: normalizedRequested,
+            effective_capabilities: effective,
+            digests: anyDefined({ ...correlationDigests, task: taskDigest, definition: trustedDefinition }),
+            attributes,
+        };
+        const refusalCode = string(refusal?.code);
+        const events = normalizedRequested.map((capability) => ({ ...base, type: "capability_requested", capability }));
+        for (const capability of approved ?? []) {
+            events.push(cleanEvent({
+                ...base,
+                type: "approval_used",
+                capability,
+                approval: cleanObject({
+                    capability,
+                    subject: approvalSubject(record.agentType),
+                    source: string(approvalSources?.[capability]) ?? string(record.approvalSource),
+                    scope: string(approvalScopes?.[capability]) ?? string(record.approvalScope),
+                    expires_at: string(approvalExpiresAt?.[capability]),
+                    used_at: at,
+                }),
+                attributes: safeAttributes({ ...attributes, approval_uses: object(approvalUses?.[capability]) }),
+            }));
+        }
+        const approvedSet = new Set(approved ?? []);
+        if (!record.blocked)
+            events.push(...effective.map((capability) => ({ ...base, type: "capability_granted", capability })));
+        events.push(...[...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 = requireV3String(record, "workspaceId", nativeEvent, line);
+        const access = requireV3String(record, "access", nativeEvent, line);
+        const outcome = requireV3String(record, "outcome", nativeEvent, line);
+        const refusal = structuredRefusal(record.refusal, nativeEvent, line, 3);
+        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({
+                    ...correlationAttributes,
+                    root: string(record.root),
+                    access,
+                    outcome,
+                    recovered: record.recovered,
+                    release_reason: string(record.releaseReason),
+                    structured_refusal: refusal,
+                }),
+            })];
+    }
+    if (nativeEvent === "child_lifecycle") {
+        const state = requireV3String(record, "state", nativeEvent, line);
+        const type = state === "starting" ? "child_started" : state === "running" ? "child_running" : state === "completed" ? "child_completed" : "child_failed";
+        return [cleanEvent({
+                ...common,
+                type,
+                deadline_at: string(record.deadlineAt),
+                exit_code: Number.isInteger(record.exitCode) ? Number(record.exitCode) : undefined,
+                attributes: safeAttributes({
+                    ...correlationAttributes,
+                    state,
+                    executor: string(record.executor),
+                    exit_code: record.exitCode,
+                    signal: record.signal,
+                    timed_out: record.timedOut,
+                    aborted: record.aborted,
+                    truncated: record.truncated,
+                    reason: string(record.reason),
+                    deadline_at: string(record.deadlineAt),
+                    herdr_pane_id: string(record.herdrPaneId),
+                    herdr_agent_name: string(record.herdrAgentName),
+                }),
+            })];
+    }
+    const workspaceId = requireV3String(record, "workspaceId", nativeEvent, line);
+    const receiptId = requireV3String(record, "receiptId", nativeEvent, line);
+    const treeSha = requireV3String(record, "treeSha", nativeEvent, line);
+    if (!/^(?:[a-fA-F0-9]{40}|[a-fA-F0-9]{64})$/.test(treeSha)) {
+        throw new Error(`invalid pi-daddy v3 check_receipt at line ${line}: treeSha must be a git object id for normalized tree evidence`);
+    }
+    return [cleanEvent({
+            ...common,
+            workspace_id: workspaceId,
+            type: "check_receipt_recorded",
+            digests: anyDefined({ ...correlationDigests, tree: treeSha }),
+            attributes: safeAttributes({
+                ...correlationAttributes,
+                receipt_id: receiptId,
+                check_id: string(record.checkId),
+                check_receipt_id: string(correlation.check_receipt_id),
+            }),
+        })];
+}
+function requireV3String(record, field, event, line) {
+    const value = string(record[field]);
+    if (!value)
+        throw new Error(`invalid pi-daddy v3 ${event} at line ${line}: ${field} is required`);
+    if (redactText(value) !== value)
+        throw new Error(`invalid pi-daddy v3 ${event} at line ${line}: ${field} contains a sensitive value`);
+    return value;
+}
 function requireV2Correlation(record, event, line) {
     const correlation = object(record.correlation);
     if (!correlation) {
@@ -795,35 +1114,35 @@ function optionalV2ApprovalUses(value, event, line) {
     }
     return output;
 }
-function validateCapabilityPartition(requested, effective, denied, clipped, gated, approved, blocked, line) {
+function validateCapabilityPartition(requested, effective, denied, clipped, gated, approved, blocked, line, version = 2) {
     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`);
+        throw new Error(`invalid pi-daddy v${version} 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`);
+        throw new Error(`invalid pi-daddy v${version} 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`);
+        throw new Error(`invalid pi-daddy v${version} 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`);
+        throw new Error(`invalid pi-daddy v${version} 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) {
+function validateApprovalEvidence(approved, scalarSource, sources, scopes, expiries, uses, line, version = 2) {
     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`);
+            throw new Error(`invalid pi-daddy v${version} 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`);
+        throw new Error(`invalid pi-daddy v${version} 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`);
+        throw new Error(`invalid pi-daddy v${version} capability_decision at line ${line}: approval evidence requires approved capabilities`);
     }
 }
 function optionalV2Boolean(record, field, event, line) {
@@ -838,23 +1157,24 @@ function approvalSubject(value) {
     const agentType = string(value);
     return agentType === undefined || agentType === "delegate" ? "<delegate>" : agentType;
 }
-function structuredRefusal(value, event, line) {
+function structuredRefusal(value, event, line, version = 2) {
     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`);
+        throw new Error(`invalid pi-daddy v${version} ${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 refusalCodes = version === 3 ? V3_REFUSAL_CODES : V2_REFUSAL_CODES;
+    if (!refusalCodes.has(code)) {
+        throw new Error(`invalid pi-daddy v${version} ${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`);
+        throw new Error(`invalid pi-daddy v${version} ${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`);
+        throw new Error(`invalid pi-daddy v${version} ${event} at line ${line}: refusal.details must contain scalar values`);
     }
     return parsed;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@skill-harness/adapters",
-    "version": "0.10.0",
+    "version": "0.12.0",
     "description": "skill-harness harness adapters — pi runner + claude-code judge routing (internal API)",
     "type": "module",
     "license": "MIT",
@@ -37,9 +37,9 @@
         "node": ">=20"
     },
     "scripts": {
-        "prepack": "cp ../../LICENSE ./LICENSE"
+        "prepack": "node ../../scripts/release-pack.mjs --guard"
     },
     "dependencies": {
-        "@skill-harness/core": "0.10.0"
+        "@skill-harness/core": "0.12.0"
     }
 }