@skill-harness/adapters 0.24.2 → 0.24.3

package/dist/pi-daddy-record-v1-contract.d.ts

@@ -0,0 +1,968 @@
+export declare const PI_DADDY_RECORD_V1_COMMIT = "38418793efb785bc582c4a233a18c40364ccd1be";
+export declare const PI_DADDY_RECORD_V1_VERSION = "0.44.3";
+export declare const PI_DADDY_RECORD_V1_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://github.com/mojomanyana/pi-daddy/contracts/ledger-record/v1/record.schema.json";
+    readonly title: "pi-daddy ledger record envelope v1";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["v", "seq", "prev", "at", "kind", "id", "body", "digest"];
+    readonly properties: {
+        readonly v: {
+            readonly const: 1;
+        };
+        readonly seq: {
+            readonly type: "integer";
+            readonly minimum: 1;
+        };
+        readonly prev: {
+            readonly anyOf: readonly [{
+                readonly type: "null";
+            }, {
+                readonly type: "string";
+                readonly pattern: "^[0-9a-f]{64}$";
+            }];
+            readonly description: "SHA-256 of the previous line's bytes; null for the first record";
+        };
+        readonly at: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly description: "the writer's clock, not the body's timestamp";
+        };
+        readonly kind: {
+            readonly type: "string";
+            readonly enum: readonly ["binding", "capability", "lifecycle", "approval", "lease", "check", "fact", "work", "control", "experiment", "activity", "advice"];
+        };
+        readonly id: {
+            readonly type: "string";
+            readonly minLength: 1;
+            readonly maxLength: 128;
+        };
+        readonly body: {
+            readonly description: "the record payload; a governance event validates against governance-event.schema.json";
+        };
+        readonly imported: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["path", "line"];
+            readonly properties: {
+                readonly path: {
+                    readonly type: "string";
+                };
+                readonly line: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+            };
+            readonly description: "present on records copied from a pre-format ledger; the source is left untouched";
+        };
+        readonly digest: {
+            readonly type: "string";
+            readonly pattern: "^[0-9a-f]{64}$";
+            readonly description: "SHA-256 of the canonical JSON of the record without this field";
+        };
+    };
+};
+export declare const PI_DADDY_RECORD_V1_GOVERNANCE_SCHEMA: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://github.com/mojomanyana/pi-daddy/contracts/ledger-record/v1/governance-event.schema.json";
+    readonly title: "pi-daddy ledgerVersion 3 event";
+    readonly description: "One JSON object per JSONL line. Version 3 adds unique execution identity and explicit parent execution identity; legacy and v2 lines are intentionally outside this schema.";
+    readonly oneOf: readonly [{
+        readonly $ref: "#/$defs/capabilityDecision";
+    }, {
+        readonly $ref: "#/$defs/workspaceLease";
+    }, {
+        readonly $ref: "#/$defs/childLifecycle";
+    }, {
+        readonly $ref: "#/$defs/costGate";
+    }, {
+        readonly $ref: "#/$defs/sessionConfig";
+    }, {
+        readonly $ref: "#/$defs/episodeOutcome";
+    }];
+    readonly $defs: {
+        readonly timestamp: {
+            readonly type: "string";
+            readonly format: "date-time";
+            readonly pattern: ":[0-5][0-9](?:\\.[0-9]+)?(?:[Zz]|[+-][0-9]{2}:[0-9]{2})$";
+        };
+        readonly episodeId: {
+            readonly type: "string";
+            readonly pattern: "^episode:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89aAbB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$";
+        };
+        readonly correlation: {
+            readonly type: "object";
+            readonly description: "Non-authoritative controller metadata under the pinned 1.0 contract. String and aggregate byte limits are additionally enforced by the runtime and cannot be represented exactly in JSON Schema.";
+            readonly properties: {
+                readonly schema_version: {
+                    readonly const: "1.0";
+                };
+                readonly run_id: {
+                    readonly $ref: "#/$defs/ledgerCorrelationIdentifier";
+                };
+                readonly task_id: {
+                    readonly $ref: "#/$defs/ledgerCorrelationIdentifier";
+                };
+                readonly workspace_id: {
+                    readonly $ref: "#/$defs/ledgerCorrelationIdentifier";
+                };
+                readonly context_id: {
+                    readonly $ref: "#/$defs/ledgerCorrelationIdentifier";
+                };
+                readonly phase: {
+                    readonly $ref: "#/$defs/ledgerCorrelationIdentifier";
+                };
+                readonly assurance: {
+                    readonly $ref: "#/$defs/ledgerCorrelationIdentifier";
+                };
+                readonly assurance_effective: {
+                    readonly $ref: "#/$defs/ledgerCorrelationIdentifier";
+                };
+                readonly policy_label: {
+                    readonly $ref: "#/$defs/ledgerCorrelationIdentifier";
+                };
+                readonly assurance_source: {
+                    readonly $ref: "#/$defs/ledgerCorrelationIdentifier";
+                };
+                readonly assurance_scope: {
+                    readonly oneOf: readonly [{
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "entire-run";
+                            };
+                            readonly selectors: {
+                                readonly type: "array";
+                                readonly maxItems: 0;
+                            };
+                        };
+                        readonly required: readonly ["type", "selectors"];
+                        readonly additionalProperties: false;
+                    }, {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly type: {
+                                readonly const: "selectors";
+                            };
+                            readonly selectors: {
+                                readonly type: "array";
+                                readonly minItems: 1;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                            };
+                        };
+                        readonly required: readonly ["type", "selectors"];
+                        readonly additionalProperties: false;
+                    }];
+                };
+                readonly activated_at: {
+                    readonly type: "string";
+                    readonly maxLength: 512;
+                };
+                readonly plan_digest: {
+                    readonly type: "string";
+                    readonly maxLength: 512;
+                };
+                readonly definition_digest: {
+                    readonly type: "string";
+                    readonly maxLength: 512;
+                };
+                readonly task_digest: {
+                    readonly type: "string";
+                    readonly maxLength: 512;
+                };
+                readonly base_sha: {
+                    readonly type: "string";
+                    readonly maxLength: 512;
+                };
+                readonly head_sha: {
+                    readonly type: "string";
+                    readonly maxLength: 512;
+                };
+                readonly tree_sha: {
+                    readonly type: "string";
+                    readonly maxLength: 512;
+                };
+                readonly event_seq: {
+                    readonly type: "number";
+                };
+                readonly last_change_seq: {
+                    readonly type: "number";
+                };
+                readonly last_authority_seq: {
+                    readonly type: "number";
+                };
+                readonly check_receipt_id: {
+                    readonly type: "string";
+                    readonly maxLength: 512;
+                };
+            };
+            readonly additionalProperties: false;
+        };
+        readonly ledgerDisplayIdentifier: {
+            readonly type: "string";
+            readonly pattern: "^[A-Za-z0-9@*][A-Za-z0-9@*._:/-]{0,511}$";
+        };
+        readonly ledgerCorrelationIdentifier: {
+            readonly type: "string";
+            readonly pattern: "^[A-Za-z0-9@*][A-Za-z0-9@*._:/-]{0,127}$";
+        };
+        readonly ledgerCapabilityIdentifier: {
+            readonly type: "string";
+            readonly pattern: "^(?:tool:|ext:|skill:|agent:|workspace:|context:)[A-Za-z0-9@*][A-Za-z0-9@*._/-]{0,255}$";
+        };
+        readonly refusalCode: {
+            readonly type: "string";
+            readonly enum: readonly ["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", "MODEL_UNRESOLVED", "GRANT_STORE_INVALID", "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_NOT_AUTHORIZED", "WORKSPACE_WRITE_CONFLICT", "WORKSPACE_LEASE_STALE", "LEDGER_DAMAGED", "CONTEXT_REQUEST_INVALID"];
+        };
+        readonly refusal: {
+            readonly type: "object";
+            readonly properties: {
+                readonly code: {
+                    readonly $ref: "#/$defs/refusalCode";
+                };
+                readonly message: {
+                    readonly type: "string";
+                };
+                readonly details: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: readonly ["string", "number", "boolean", "null"];
+                    };
+                };
+            };
+            readonly required: readonly ["code", "message"];
+            readonly additionalProperties: false;
+        };
+        readonly approvalSource: {
+            readonly type: "string";
+            readonly enum: readonly ["prompt", "session", "persisted", "inherited"];
+        };
+        readonly approvalScope: {
+            readonly type: "string";
+            readonly enum: readonly ["once", "session", "always"];
+        };
+        readonly approvalUse: {
+            readonly type: "object";
+            readonly properties: {
+                readonly max: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly remaining: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+            };
+            readonly required: readonly ["max", "remaining"];
+            readonly additionalProperties: false;
+        };
+        readonly definitionDigest: {
+            readonly type: "object";
+            readonly properties: {
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly source: {
+                    readonly type: "string";
+                };
+                readonly sha256: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-fA-F0-9]{64}$";
+                };
+            };
+            readonly required: readonly ["name", "source", "sha256"];
+            readonly additionalProperties: false;
+        };
+        readonly capabilityDecision: {
+            readonly type: "object";
+            readonly properties: {
+                readonly ledgerVersion: {
+                    readonly const: 3;
+                };
+                readonly event: {
+                    readonly const: "capability_decision";
+                };
+                readonly ts: {
+                    readonly $ref: "#/$defs/timestamp";
+                };
+                readonly episodeId: {
+                    readonly $ref: "#/$defs/episodeId";
+                };
+                readonly parentId: {
+                    readonly $ref: "#/$defs/ledgerDisplayIdentifier";
+                };
+                readonly childId: {
+                    readonly $ref: "#/$defs/ledgerDisplayIdentifier";
+                };
+                readonly depth: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly agentType: {
+                    readonly $ref: "#/$defs/ledgerDisplayIdentifier";
+                };
+                readonly requested: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/ledgerCapabilityIdentifier";
+                    };
+                };
+                readonly parentGrant: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/ledgerCapabilityIdentifier";
+                    };
+                };
+                readonly effective: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/ledgerCapabilityIdentifier";
+                    };
+                };
+                readonly denied: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/ledgerCapabilityIdentifier";
+                    };
+                };
+                readonly clipped: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/ledgerCapabilityIdentifier";
+                    };
+                };
+                readonly gatedBlocked: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/ledgerCapabilityIdentifier";
+                    };
+                };
+                readonly blocked: {
+                    readonly type: "boolean";
+                };
+                readonly reason: {
+                    readonly type: "string";
+                };
+                readonly approved: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/$defs/ledgerCapabilityIdentifier";
+                    };
+                };
+                readonly approvalSource: {
+                    readonly $ref: "#/$defs/approvalSource";
+                };
+                readonly approvalSources: {
+                    readonly type: "object";
+                    readonly propertyNames: {
+                        readonly $ref: "#/$defs/ledgerCapabilityIdentifier";
+                    };
+                    readonly additionalProperties: {
+                        readonly $ref: "#/$defs/approvalSource";
+                    };
+                };
+                readonly approvalScopes: {
+                    readonly type: "object";
+                    readonly propertyNames: {
+                        readonly $ref: "#/$defs/ledgerCapabilityIdentifier";
+                    };
+                    readonly additionalProperties: {
+                        readonly $ref: "#/$defs/approvalScope";
+                    };
+                };
+                readonly approvalExpiresAt: {
+                    readonly type: "object";
+                    readonly propertyNames: {
+                        readonly $ref: "#/$defs/ledgerCapabilityIdentifier";
+                    };
+                    readonly additionalProperties: {
+                        readonly $ref: "#/$defs/timestamp";
+                    };
+                };
+                readonly approvalUses: {
+                    readonly type: "object";
+                    readonly propertyNames: {
+                        readonly $ref: "#/$defs/ledgerCapabilityIdentifier";
+                    };
+                    readonly additionalProperties: {
+                        readonly $ref: "#/$defs/approvalUse";
+                    };
+                };
+                readonly approvalScope: {
+                    readonly $ref: "#/$defs/approvalScope";
+                };
+                readonly humanDenied: {
+                    readonly const: true;
+                };
+                readonly gateOutcome: {
+                    readonly type: "string";
+                    readonly enum: readonly ["declined", "dismissed", "no-ui", "error"];
+                };
+                readonly definitionDigest: {
+                    readonly $ref: "#/$defs/definitionDigest";
+                };
+                readonly definitionHash: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-f0-9]{64}$";
+                };
+                readonly definitionPackageVersion: {
+                    readonly type: "string";
+                    readonly pattern: "^[0-9A-Za-z][0-9A-Za-z.+_-]{0,127}$";
+                };
+                readonly handoff: {
+                    readonly type: "object";
+                    readonly description: "the context handoff this child received (ADR-0078); absent means nothing crossed";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["mode", "sections", "bytes", "truncatedBytes"];
+                    readonly properties: {
+                        readonly mode: {
+                            readonly enum: readonly ["files", "pruned", "summary", "fork"];
+                        };
+                        readonly sections: {
+                            readonly type: "integer";
+                            readonly minimum: 0;
+                        };
+                        readonly bytes: {
+                            readonly type: "integer";
+                            readonly minimum: 0;
+                        };
+                        readonly truncatedBytes: {
+                            readonly type: "integer";
+                            readonly minimum: 0;
+                        };
+                        readonly keptTurns: {
+                            readonly type: "integer";
+                            readonly minimum: 0;
+                        };
+                        readonly droppedTurns: {
+                            readonly type: "integer";
+                            readonly minimum: 0;
+                        };
+                        readonly rule: {
+                            readonly type: "string";
+                        };
+                    };
+                };
+                readonly executor: {
+                    readonly type: "string";
+                    readonly enum: readonly ["process", "herdr"];
+                };
+                readonly taskFrom: {
+                    readonly $ref: "#/$defs/ledgerDisplayIdentifier";
+                };
+                readonly taskDigest: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-fA-F0-9]{64}$";
+                };
+                readonly correlation: {
+                    readonly $ref: "#/$defs/correlation";
+                };
+                readonly refusal: {
+                    readonly $ref: "#/$defs/refusal";
+                };
+                readonly executionId: {
+                    readonly $ref: "#/$defs/executionId";
+                };
+                readonly parentExecutionId: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/executionId";
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly taskFromExecutionId: {
+                    readonly $ref: "#/$defs/executionId";
+                };
+            };
+            readonly required: readonly ["ledgerVersion", "event", "ts", "executionId", "parentExecutionId", "parentId", "childId", "depth", "requested", "parentGrant", "effective", "denied", "clipped", "gatedBlocked", "blocked", "executor", "taskDigest"];
+            readonly additionalProperties: false;
+        };
+        readonly workspaceLease: {
+            readonly type: "object";
+            readonly properties: {
+                readonly ledgerVersion: {
+                    readonly const: 3;
+                };
+                readonly event: {
+                    readonly const: "workspace_lease";
+                };
+                readonly ts: {
+                    readonly $ref: "#/$defs/timestamp";
+                };
+                readonly episodeId: {
+                    readonly $ref: "#/$defs/episodeId";
+                };
+                readonly childId: {
+                    readonly $ref: "#/$defs/ledgerDisplayIdentifier";
+                };
+                readonly workspaceId: {
+                    readonly $ref: "#/$defs/ledgerDisplayIdentifier";
+                };
+                readonly root: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly access: {
+                    readonly type: "string";
+                    readonly enum: readonly ["read", "write"];
+                };
+                readonly outcome: {
+                    readonly type: "string";
+                    readonly enum: readonly ["acquired", "uncontended", "refused", "released", "released-unrecorded", "lost", "retained", "timeout", "recovered"];
+                };
+                readonly recovered: {
+                    readonly oneOf: readonly [{
+                        readonly type: "boolean";
+                    }, {
+                        readonly const: "unknown";
+                    }];
+                };
+                readonly releaseReason: {
+                    readonly type: "string";
+                };
+                readonly refusal: {
+                    readonly $ref: "#/$defs/refusal";
+                };
+                readonly correlation: {
+                    readonly $ref: "#/$defs/correlation";
+                };
+                readonly executionId: {
+                    readonly $ref: "#/$defs/executionId";
+                };
+                readonly parentExecutionId: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/executionId";
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+            };
+            readonly required: readonly ["ledgerVersion", "event", "ts", "executionId", "parentExecutionId", "childId", "workspaceId", "root", "access", "outcome"];
+            readonly additionalProperties: false;
+        };
+        readonly childLifecycle: {
+            readonly type: "object";
+            readonly properties: {
+                readonly ledgerVersion: {
+                    readonly const: 3;
+                };
+                readonly event: {
+                    readonly const: "child_lifecycle";
+                };
+                readonly ts: {
+                    readonly $ref: "#/$defs/timestamp";
+                };
+                readonly episodeId: {
+                    readonly $ref: "#/$defs/episodeId";
+                };
+                readonly childId: {
+                    readonly $ref: "#/$defs/ledgerDisplayIdentifier";
+                };
+                readonly state: {
+                    readonly type: "string";
+                    readonly enum: readonly ["starting", "running", "completed", "failed"];
+                };
+                readonly executor: {
+                    readonly type: "string";
+                    readonly enum: readonly ["process", "herdr"];
+                };
+                readonly exitCode: {
+                    readonly type: readonly ["integer", "null"];
+                };
+                readonly signal: {
+                    readonly oneOf: readonly [{
+                        readonly type: "string";
+                        readonly enum: readonly ["SIGABRT", "SIGALRM", "SIGBUS", "SIGCHLD", "SIGCONT", "SIGFPE", "SIGHUP", "SIGILL", "SIGINT", "SIGIO", "SIGIOT", "SIGKILL", "SIGPIPE", "SIGPOLL", "SIGPROF", "SIGPWR", "SIGQUIT", "SIGSEGV", "SIGSTKFLT", "SIGSTOP", "SIGSYS", "SIGTERM", "SIGTRAP", "SIGTSTP", "SIGTTIN", "SIGTTOU", "SIGUNUSED", "SIGURG", "SIGUSR1", "SIGUSR2", "SIGVTALRM", "SIGWINCH", "SIGXCPU", "SIGXFSZ", "SIGBREAK", "SIGLOST", "SIGINFO"];
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly timedOut: {
+                    readonly const: true;
+                };
+                readonly aborted: {
+                    readonly const: true;
+                };
+                readonly truncated: {
+                    readonly const: true;
+                };
+                readonly reason: {
+                    readonly type: "string";
+                };
+                readonly correlation: {
+                    readonly $ref: "#/$defs/correlation";
+                };
+                readonly executionId: {
+                    readonly $ref: "#/$defs/executionId";
+                };
+                readonly parentExecutionId: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/executionId";
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly deadlineAt: {
+                    readonly $ref: "#/$defs/timestamp";
+                };
+                readonly idleTimeoutMs: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                    readonly description: "the inactivity bound in milliseconds that governed this child beside the deadlineAt ceiling";
+                };
+                readonly resolvedModel: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/resolvedModel";
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly modelSource: {
+                    readonly $ref: "#/$defs/modelSource";
+                };
+                readonly thinkingLevel: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/thinkingLevel";
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly thinkingSource: {
+                    readonly $ref: "#/$defs/thinkingSource";
+                };
+                readonly tokenDetail: {
+                    readonly $ref: "#/$defs/tokenDetail";
+                };
+                readonly usage: {
+                    readonly $ref: "#/$defs/childUsage";
+                };
+                readonly compactionCount: {
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly usageUnavailable: {
+                    readonly enum: readonly ["session-missing", "session-invalid", "usage-missing"];
+                };
+                readonly exportedEnvironment: {
+                    readonly type: "array";
+                    readonly minItems: 3;
+                    readonly maxItems: 3;
+                    readonly uniqueItems: true;
+                    readonly items: {
+                        readonly enum: readonly ["PI_DADDY_EPISODE", "PI_DADDY_DEFINITION", "PI_DADDY_EXECUTION"];
+                    };
+                };
+                readonly definitionHash: {
+                    readonly type: "string";
+                    readonly pattern: "^[a-f0-9]{64}$";
+                };
+                readonly definitionPackageVersion: {
+                    readonly type: "string";
+                    readonly pattern: "^[0-9A-Za-z][0-9A-Za-z.+_-]{0,127}$";
+                };
+                readonly herdrPaneId: {
+                    readonly $ref: "#/$defs/ledgerDisplayIdentifier";
+                };
+                readonly herdrAgentName: {
+                    readonly $ref: "#/$defs/ledgerDisplayIdentifier";
+                };
+            };
+            readonly required: readonly ["ledgerVersion", "event", "ts", "executionId", "parentExecutionId", "childId", "state", "executor"];
+            readonly additionalProperties: false;
+            readonly not: {
+                readonly required: readonly ["usage", "usageUnavailable"];
+            };
+            readonly allOf: readonly [{
+                readonly if: {
+                    readonly properties: {
+                        readonly state: {
+                            readonly enum: readonly ["starting", "running"];
+                        };
+                    };
+                    readonly required: readonly ["state"];
+                };
+                readonly then: {
+                    readonly required: readonly ["deadlineAt"];
+                };
+            }, {
+                readonly if: {
+                    readonly anyOf: readonly [{
+                        readonly required: readonly ["herdrPaneId"];
+                    }, {
+                        readonly required: readonly ["herdrAgentName"];
+                    }];
+                };
+                readonly then: {
+                    readonly required: readonly ["herdrPaneId", "herdrAgentName"];
+                    readonly properties: {
+                        readonly executor: {
+                            readonly const: "herdr";
+                        };
+                    };
+                };
+            }];
+        };
+        readonly resolvedModel: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["provider", "modelId"];
+            readonly properties: {
+                readonly provider: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly modelId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+        };
+        readonly thinkingLevel: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["level", "source"];
+            readonly properties: {
+                readonly level: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly source: {
+                    readonly enum: readonly ["explicit", "session", "advisor", "definition", "global", "pi"];
+                };
+            };
+        };
+        readonly modelSource: {
+            readonly enum: readonly ["explicit", "session", "definition", "global", "pi"];
+        };
+        readonly thinkingSource: {
+            readonly enum: readonly ["explicit", "session", "advisor", "definition", "global", "pi"];
+        };
+        readonly tokenDetail: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "reasoningTokens"];
+            readonly properties: {
+                readonly inputTokens: {
+                    readonly $ref: "#/$defs/reportedTokenCount";
+                };
+                readonly outputTokens: {
+                    readonly $ref: "#/$defs/reportedTokenCount";
+                };
+                readonly cacheReadTokens: {
+                    readonly $ref: "#/$defs/reportedTokenCount";
+                };
+                readonly cacheWriteTokens: {
+                    readonly $ref: "#/$defs/reportedTokenCount";
+                };
+                readonly reasoningTokens: {
+                    readonly $ref: "#/$defs/reportedTokenCount";
+                };
+            };
+        };
+        readonly reportedTokenCount: {
+            readonly oneOf: readonly [{
+                readonly type: "number";
+                readonly exclusiveMinimum: 0;
+            }, {
+                readonly type: "null";
+            }];
+        };
+        readonly childUsage: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly required: readonly ["input", "output", "cacheRead", "cacheWrite", "totalTokens", "cost"];
+            readonly properties: {
+                readonly input: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                readonly output: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                readonly cacheRead: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                readonly cacheWrite: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                readonly reasoning: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                readonly totalTokens: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                readonly cost: {
+                    readonly type: "object";
+                    readonly additionalProperties: false;
+                    readonly required: readonly ["input", "output", "cacheRead", "cacheWrite", "total"];
+                    readonly properties: {
+                        readonly input: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                        };
+                        readonly output: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                        };
+                        readonly cacheRead: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                        };
+                        readonly cacheWrite: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                        };
+                        readonly total: {
+                            readonly type: "number";
+                            readonly minimum: 0;
+                        };
+                    };
+                };
+            };
+        };
+        readonly executionId: {
+            readonly type: "string";
+            readonly pattern: "^exec:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89aAbB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$";
+        };
+        readonly costGate: {
+            readonly type: "object";
+            readonly properties: {
+                readonly ledgerVersion: {
+                    readonly const: 3;
+                };
+                readonly event: {
+                    readonly const: "cost_gate";
+                };
+                readonly ts: {
+                    readonly $ref: "#/$defs/timestamp";
+                };
+                readonly episodeId: {
+                    readonly $ref: "#/$defs/episodeId";
+                };
+                readonly executionId: {
+                    readonly $ref: "#/$defs/executionId";
+                };
+                readonly parentExecutionId: {
+                    readonly oneOf: readonly [{
+                        readonly $ref: "#/$defs/executionId";
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly childId: {
+                    readonly $ref: "#/$defs/ledgerDisplayIdentifier";
+                };
+                readonly gate: {
+                    readonly const: "episode_cost";
+                };
+                readonly cost: {
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                readonly ceiling: {
+                    readonly type: "number";
+                    readonly exclusiveMinimum: 0;
+                };
+                readonly outcome: {
+                    readonly enum: readonly ["continued", "stopped"];
+                };
+                readonly newCeiling: {
+                    readonly type: "number";
+                    readonly exclusiveMinimum: 0;
+                };
+            };
+            readonly required: readonly ["ledgerVersion", "event", "ts", "episodeId", "executionId", "parentExecutionId", "childId", "gate", "cost", "ceiling", "outcome"];
+            readonly additionalProperties: false;
+        };
+        readonly sessionConfig: {
+            readonly type: "object";
+            readonly properties: {
+                readonly ledgerVersion: {
+                    readonly const: 3;
+                };
+                readonly event: {
+                    readonly const: "session_config";
+                };
+                readonly ts: {
+                    readonly $ref: "#/$defs/timestamp";
+                };
+                readonly episodeId: {
+                    readonly $ref: "#/$defs/episodeId";
+                };
+                readonly outcome: {
+                    readonly enum: readonly ["kept", "changed"];
+                };
+                readonly trigger: {
+                    readonly enum: readonly ["first-delegation", "grants-models"];
+                };
+                readonly overrides: {
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly model: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly thinking: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                        readonly required: readonly ["model", "thinking"];
+                        readonly additionalProperties: false;
+                    };
+                };
+            };
+            readonly required: readonly ["ledgerVersion", "event", "ts", "episodeId", "outcome", "trigger", "overrides"];
+            readonly additionalProperties: false;
+        };
+        readonly episodeOutcome: {
+            readonly type: "object";
+            readonly properties: {
+                readonly ledgerVersion: {
+                    readonly const: 3;
+                };
+                readonly event: {
+                    readonly const: "episode_outcome";
+                };
+                readonly ts: {
+                    readonly $ref: "#/$defs/timestamp";
+                };
+                readonly episodeId: {
+                    readonly $ref: "#/$defs/episodeId";
+                };
+                readonly commit: {
+                    readonly type: "string";
+                    readonly pattern: "^[0-9a-f]{40}$";
+                };
+                readonly survived: {
+                    readonly type: "boolean";
+                };
+                readonly ci: {
+                    readonly enum: readonly ["green", "red", "none"];
+                };
+                readonly amended: {
+                    readonly type: "boolean";
+                };
+                readonly corrected: {
+                    readonly type: "boolean";
+                };
+                readonly label: {
+                    readonly enum: readonly ["positive", "negative", "unknown"];
+                };
+            };
+            readonly required: readonly ["ledgerVersion", "event", "ts", "episodeId", "commit", "survived", "ci", "amended", "corrected", "label"];
+            readonly additionalProperties: false;
+        };
+    };
+};