@axtary/actionpass 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -1,6 +1,18 @@
 import { type CryptoKey, type JWK, type KeyObject } from "jose";
 import { z } from "zod";
+import { type ActionPassStatusClaim } from "./status-list.js";
+import { type ActionProvenance } from "./provenance.js";
+import { type PolicyDecisionExplanation } from "./explain.js";
+export * from "./caep.js";
+export * from "./dev-key.js";
+export * from "./explain.js";
+export * from "./postgres.js";
+export * from "./provenance.js";
+export * from "./status-list.js";
 export declare const ACTION_SCHEMA_VERSION = "axtary.action.v0";
+export declare const ACTIONPASS_V0_VERSION = "axtary.actionpass.v0";
+export declare const ACTIONPASS_V1_VERSION = "axtary.actionpass.v1";
+export declare const ACTIONPASS_V2_VERSION = "axtary.actionpass.v2";
 export declare const ACTIONPASS_VERSION = "axtary.actionpass.v0";
 export declare const APPROVAL_ARTIFACT_VERSION = "axtary.approval.v0";
 export declare const ACTIONPASS_REVOCATION_VERSION = "axtary.actionpass_revocation.v0";
@@ -10,9 +22,25 @@ export declare const LEDGER_PROVIDER_EVIDENCE_VERSION = "axtary.ledger_provider_
 export declare const LEDGER_EXECUTION_OUTCOME_VERSION = "axtary.ledger_execution_outcome.v0";
 export declare const DEFAULT_EXPIRES_IN_SECONDS = 600;
 export declare const DEFAULT_SIGNING_ALGORITHM = "ES256";
+export declare const DPOP_PROOF_TYP = "dpop+jwt";
+export declare const DEFAULT_DPOP_MAX_AGE_SECONDS = 60;
+export declare const DEFAULT_DPOP_CLOCK_SKEW_SECONDS = 5;
 export type JsonValue = string | number | boolean | null | JsonValue[] | {
     [key: string]: JsonValue;
 };
+export declare const BudgetAmountSchema: z.ZodRecord<z.ZodString, z.ZodNumber>;
+export type BudgetAmount = z.infer<typeof BudgetAmountSchema>;
+export declare const ActionBudgetSchema: z.ZodObject<{
+    reservationId: z.ZodString;
+    cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    commitStatus: z.ZodEnum<{
+        pending: "pending";
+        committed: "committed";
+        rolled_back: "rolled_back";
+    }>;
+}, z.core.$strip>;
+export type ActionBudget = z.infer<typeof ActionBudgetSchema>;
 export declare const AxtaryDecisionSchema: z.ZodEnum<{
     allow: "allow";
     deny: "deny";
@@ -42,15 +70,45 @@ export declare const NormalizedActionSchema: z.ZodObject<{
         serverIdentity: z.ZodString;
         schemaVersion: z.ZodString;
         definitionHash: z.ZodString;
+        publisher: z.ZodOptional<z.ZodString>;
+        publisherKeyId: z.ZodOptional<z.ZodString>;
+        semver: z.ZodOptional<z.ZodString>;
+        priorDefinitionHash: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        schemaVersion: z.ZodDefault<z.ZodLiteral<"axtary.provenance.v0">>;
+        sources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                unknown: "unknown";
+                task: "task";
+                operator: "operator";
+                document: "document";
+                tool_output: "tool_output";
+                connector: "connector";
+            }>;
+            integrity: z.ZodEnum<{
+                unknown: "unknown";
+                trusted: "trusted";
+                untrusted: "untrusted";
+            }>;
+            resource: z.ZodOptional<z.ZodString>;
+            observedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        bindings: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            sourceIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     budget: z.ZodOptional<z.ZodObject<{
-        reservationId: z.ZodOptional<z.ZodString>;
-        limit: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
-        commitStatus: z.ZodOptional<z.ZodEnum<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
             pending: "pending";
             committed: "committed";
             rolled_back: "rolled_back";
-        }>>;
+        }>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type NormalizedAction = z.infer<typeof NormalizedActionSchema>;
@@ -72,6 +130,29 @@ export declare const PolicyDecisionSchema: z.ZodObject<{
         maxFilesChanged: z.ZodNumber;
         blockedPaths: z.ZodArray<z.ZodString>;
     }, z.core.$strip>;
+    rule: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        matchedRuleIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    obligations: z.ZodOptional<z.ZodObject<{
+        requiredApproverRoles: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        timeWindow: z.ZodOptional<z.ZodObject<{
+            startHourUtc: z.ZodNumber;
+            endHourUtc: z.ZodNumber;
+            daysOfWeek: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        rateLimit: z.ZodOptional<z.ZodObject<{
+            ruleId: z.ZodString;
+            maxActions: z.ZodNumber;
+            windowSeconds: z.ZodNumber;
+            scope: z.ZodEnum<{
+                resource: "resource";
+                actor: "actor";
+                tenant: "tenant";
+                tool: "tool";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type PolicyDecision = z.infer<typeof PolicyDecisionSchema>;
 export type ActionPassDecision = PolicyDecision;
@@ -82,6 +163,7 @@ export declare const ApprovalSchema: z.ZodObject<{
         policy_override: "policy_override";
     }>;
     approvedBy: z.ZodOptional<z.ZodString>;
+    approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
     approvalArtifact: z.ZodOptional<z.ZodString>;
     approvalArtifactHash: z.ZodOptional<z.ZodString>;
     actionHash: z.ZodOptional<z.ZodString>;
@@ -97,6 +179,7 @@ export declare const ApprovalArtifactSchema: z.ZodObject<{
         policy_override: "policy_override";
     }>;
     approvedBy: z.ZodString;
+    approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
     approvedAt: z.ZodString;
     actionHash: z.ZodString;
     payloadHash: z.ZodString;
@@ -107,8 +190,159 @@ export declare const ApprovalArtifactSchema: z.ZodObject<{
     expiresAt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ApprovalArtifact = z.infer<typeof ApprovalArtifactSchema>;
-export declare const ActionPassClaimsSchema: z.ZodObject<{
+export declare const ActionPassV0ClaimsSchema: z.ZodObject<{
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    exp: z.ZodNumber;
+    nbf: z.ZodNumber;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    tenant: z.ZodString;
+    humanOwner: z.ZodString;
+    agentRuntime: z.ZodString;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            human: "human";
+            policy_override: "policy_override";
+        }>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalArtifact: z.ZodOptional<z.ZodString>;
+        approvalArtifactHash: z.ZodOptional<z.ZodString>;
+        actionHash: z.ZodOptional<z.ZodString>;
+        payloadHash: z.ZodOptional<z.ZodString>;
+        approvedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    audit: z.ZodObject<{
+        traceId: z.ZodString;
+        parentPassId: z.ZodNullable<z.ZodString>;
+        ledgerHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
     apv: z.ZodLiteral<"axtary.actionpass.v0">;
+}, z.core.$strip>;
+export declare const ActionPassV1ClaimsSchema: z.ZodObject<{
+    cnf: z.ZodObject<{
+        jkt: z.ZodString;
+    }, z.core.$strip>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        depth: z.ZodNumber;
+        rootPassId: z.ZodString;
+    }, z.core.$strip>>;
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    exp: z.ZodNumber;
+    nbf: z.ZodNumber;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    tenant: z.ZodString;
+    humanOwner: z.ZodString;
+    agentRuntime: z.ZodString;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            human: "human";
+            policy_override: "policy_override";
+        }>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalArtifact: z.ZodOptional<z.ZodString>;
+        approvalArtifactHash: z.ZodOptional<z.ZodString>;
+        actionHash: z.ZodOptional<z.ZodString>;
+        payloadHash: z.ZodOptional<z.ZodString>;
+        approvedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    audit: z.ZodObject<{
+        traceId: z.ZodString;
+        parentPassId: z.ZodNullable<z.ZodString>;
+        ledgerHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    apv: z.ZodLiteral<"axtary.actionpass.v1">;
+}, z.core.$strip>;
+export declare const ActionPassV2ClaimsSchema: z.ZodObject<{
+    cnf: z.ZodObject<{
+        jkt: z.ZodString;
+    }, z.core.$strip>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        depth: z.ZodNumber;
+        rootPassId: z.ZodString;
+    }, z.core.$strip>>;
+    status: z.ZodObject<{
+        status_list: z.ZodObject<{
+            idx: z.ZodNumber;
+            uri: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
     iss: z.ZodString;
     sub: z.ZodString;
     aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
@@ -142,6 +376,17 @@ export declare const ActionPassClaimsSchema: z.ZodObject<{
         opaCompatible: z.ZodBoolean;
     }, z.core.$strip>;
     payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
     approval: z.ZodOptional<z.ZodObject<{
         mode: z.ZodEnum<{
             none: "none";
@@ -149,6 +394,7 @@ export declare const ActionPassClaimsSchema: z.ZodObject<{
             policy_override: "policy_override";
         }>;
         approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
         approvalArtifact: z.ZodOptional<z.ZodString>;
         approvalArtifactHash: z.ZodOptional<z.ZodString>;
         actionHash: z.ZodOptional<z.ZodString>;
@@ -160,8 +406,236 @@ export declare const ActionPassClaimsSchema: z.ZodObject<{
         parentPassId: z.ZodNullable<z.ZodString>;
         ledgerHash: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>;
+    apv: z.ZodLiteral<"axtary.actionpass.v2">;
 }, z.core.$strip>;
+export declare const ActionPassClaimsSchema: z.ZodUnion<readonly [z.ZodObject<{
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    exp: z.ZodNumber;
+    nbf: z.ZodNumber;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    tenant: z.ZodString;
+    humanOwner: z.ZodString;
+    agentRuntime: z.ZodString;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            human: "human";
+            policy_override: "policy_override";
+        }>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalArtifact: z.ZodOptional<z.ZodString>;
+        approvalArtifactHash: z.ZodOptional<z.ZodString>;
+        actionHash: z.ZodOptional<z.ZodString>;
+        payloadHash: z.ZodOptional<z.ZodString>;
+        approvedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    audit: z.ZodObject<{
+        traceId: z.ZodString;
+        parentPassId: z.ZodNullable<z.ZodString>;
+        ledgerHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    apv: z.ZodLiteral<"axtary.actionpass.v0">;
+}, z.core.$strip>, z.ZodObject<{
+    cnf: z.ZodObject<{
+        jkt: z.ZodString;
+    }, z.core.$strip>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        depth: z.ZodNumber;
+        rootPassId: z.ZodString;
+    }, z.core.$strip>>;
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    exp: z.ZodNumber;
+    nbf: z.ZodNumber;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    tenant: z.ZodString;
+    humanOwner: z.ZodString;
+    agentRuntime: z.ZodString;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            human: "human";
+            policy_override: "policy_override";
+        }>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalArtifact: z.ZodOptional<z.ZodString>;
+        approvalArtifactHash: z.ZodOptional<z.ZodString>;
+        actionHash: z.ZodOptional<z.ZodString>;
+        payloadHash: z.ZodOptional<z.ZodString>;
+        approvedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    audit: z.ZodObject<{
+        traceId: z.ZodString;
+        parentPassId: z.ZodNullable<z.ZodString>;
+        ledgerHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    apv: z.ZodLiteral<"axtary.actionpass.v1">;
+}, z.core.$strip>, z.ZodObject<{
+    cnf: z.ZodObject<{
+        jkt: z.ZodString;
+    }, z.core.$strip>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        depth: z.ZodNumber;
+        rootPassId: z.ZodString;
+    }, z.core.$strip>>;
+    status: z.ZodObject<{
+        status_list: z.ZodObject<{
+            idx: z.ZodNumber;
+            uri: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    iss: z.ZodString;
+    sub: z.ZodString;
+    aud: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    exp: z.ZodNumber;
+    nbf: z.ZodNumber;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    tenant: z.ZodString;
+    humanOwner: z.ZodString;
+    agentRuntime: z.ZodString;
+    intent: z.ZodObject<{
+        taskId: z.ZodString;
+        declaredGoal: z.ZodString;
+        maxDelegationDepth: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    capability: z.ZodObject<{
+        tool: z.ZodString;
+        resource: z.ZodString;
+        constraints: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+        step_up: "step_up";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    policy: z.ZodObject<{
+        nativeRule: z.ZodString;
+        version: z.ZodString;
+        cedarCompatible: z.ZodBoolean;
+        opaCompatible: z.ZodBoolean;
+    }, z.core.$strip>;
+    payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodString;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        commitStatus: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+        }>;
+    }, z.core.$strip>>;
+    approval: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodEnum<{
+            none: "none";
+            human: "human";
+            policy_override: "policy_override";
+        }>;
+        approvedBy: z.ZodOptional<z.ZodString>;
+        approverRoles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        approvalArtifact: z.ZodOptional<z.ZodString>;
+        approvalArtifactHash: z.ZodOptional<z.ZodString>;
+        actionHash: z.ZodOptional<z.ZodString>;
+        payloadHash: z.ZodOptional<z.ZodString>;
+        approvedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    audit: z.ZodObject<{
+        traceId: z.ZodString;
+        parentPassId: z.ZodNullable<z.ZodString>;
+        ledgerHash: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    apv: z.ZodLiteral<"axtary.actionpass.v2">;
+}, z.core.$strip>]>;
 export type ActionPassClaims = z.infer<typeof ActionPassClaimsSchema>;
+export type ActionPassV1Claims = z.infer<typeof ActionPassV1ClaimsSchema>;
+export type ActionPassV2Claims = z.infer<typeof ActionPassV2ClaimsSchema>;
+export declare const DpopProofClaimsSchema: z.ZodObject<{
+    htm: z.ZodString;
+    htu: z.ZodString;
+    iat: z.ZodNumber;
+    jti: z.ZodString;
+    ath: z.ZodString;
+    nonce: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DpopProofClaims = z.infer<typeof DpopProofClaimsSchema>;
 export declare const ActionPassRevocationSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"axtary.actionpass_revocation.v0">;
     passId: z.ZodString;
@@ -251,10 +725,12 @@ export declare const LedgerProviderSchema: z.ZodEnum<{
     slack: "slack";
     linear: "linear";
     docs: "docs";
+    drive: "drive";
     mcp: "mcp";
     aws: "aws";
     gcp: "gcp";
     jira: "jira";
+    postgres: "postgres";
 }>;
 export type LedgerProvider = z.infer<typeof LedgerProviderSchema>;
 export declare const LedgerProviderEvidenceDiffSchema: z.ZodObject<{
@@ -263,10 +739,12 @@ export declare const LedgerProviderEvidenceDiffSchema: z.ZodObject<{
         slack: "slack";
         linear: "linear";
         docs: "docs";
+        drive: "drive";
         mcp: "mcp";
         aws: "aws";
         gcp: "gcp";
         jira: "jira";
+        postgres: "postgres";
     }>;
     summary: z.ZodOptional<z.ZodString>;
     files: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -309,10 +787,12 @@ export declare const LedgerProviderEvidenceSchema: z.ZodObject<{
         slack: "slack";
         linear: "linear";
         docs: "docs";
+        drive: "drive";
         mcp: "mcp";
         aws: "aws";
         gcp: "gcp";
         jira: "jira";
+        postgres: "postgres";
     }>;
     tool: z.ZodString;
     operation: z.ZodString;
@@ -322,10 +802,12 @@ export declare const LedgerProviderEvidenceSchema: z.ZodObject<{
             slack: "slack";
             linear: "linear";
             docs: "docs";
+            drive: "drive";
             mcp: "mcp";
             aws: "aws";
             gcp: "gcp";
             jira: "jira";
+            postgres: "postgres";
         }>;
         kind: z.ZodString;
         id: z.ZodString;
@@ -344,10 +826,12 @@ export declare const LedgerProviderEvidenceSchema: z.ZodObject<{
             slack: "slack";
             linear: "linear";
             docs: "docs";
+            drive: "drive";
             mcp: "mcp";
             aws: "aws";
             gcp: "gcp";
             jira: "jira";
+            postgres: "postgres";
         }>;
         summary: z.ZodOptional<z.ZodString>;
         files: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -378,6 +862,113 @@ export declare const LedgerProviderEvidenceSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type LedgerProviderEvidence = z.infer<typeof LedgerProviderEvidenceSchema>;
+export type ConnectorProvider = "github" | "slack" | "linear" | "jira" | "aws" | "gcp" | "mcp" | "docs" | "drive" | "postgres";
+export type ConnectorCapabilityOperation = "read" | "write" | "external_message" | "identity_read" | "identity_mutation";
+export type ConnectorCapabilityStatus = "supported" | "demo_only" | "planned";
+export type ConnectorCapability = {
+    id: string;
+    provider: ConnectorProvider;
+    connector: string;
+    label: string;
+    tool: string;
+    operation: ConnectorCapabilityOperation;
+    status: ConnectorCapabilityStatus;
+    supportedModes: string[];
+    requiresActionPass: boolean;
+    defaultPolicy: "allow" | "deny" | "step_up" | "deny_until_scoped";
+    payloadFields: string[];
+    approvalTriggers: string[];
+    credentialBoundary: string;
+    smokeCheck: string | null;
+};
+export type ConnectorProviderMode = "fake" | "rest" | "app" | "web" | "graphql" | "local" | "local-wrapper" | "postgres" | "off" | "planned";
+export declare const GitHubNativeConnectorConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        fake: "fake";
+        rest: "rest";
+        app: "app";
+    }>>;
+    tokenEnv: z.ZodDefault<z.ZodString>;
+    apiBaseUrl: z.ZodDefault<z.ZodString>;
+    userAgent: z.ZodDefault<z.ZodString>;
+    appId: z.ZodOptional<z.ZodString>;
+    appIdEnv: z.ZodDefault<z.ZodString>;
+    installationId: z.ZodOptional<z.ZodString>;
+    installationIdEnv: z.ZodDefault<z.ZodString>;
+    privateKeyEnv: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type GitHubNativeConnectorConfig = z.infer<typeof GitHubNativeConnectorConfigSchema>;
+export declare const DEFAULT_GITHUB_NATIVE_CONNECTOR_CONFIG: GitHubNativeConnectorConfig;
+export declare const LinearNativeConnectorConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        fake: "fake";
+        graphql: "graphql";
+    }>>;
+    tokenEnv: z.ZodDefault<z.ZodString>;
+    apiUrl: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type LinearNativeConnectorConfig = z.infer<typeof LinearNativeConnectorConfigSchema>;
+export declare const DEFAULT_LINEAR_NATIVE_CONNECTOR_CONFIG: LinearNativeConnectorConfig;
+export declare const JiraNativeConnectorConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        fake: "fake";
+        rest: "rest";
+    }>>;
+    auth: z.ZodDefault<z.ZodEnum<{
+        api_token: "api_token";
+        oauth: "oauth";
+    }>>;
+    tokenEnv: z.ZodDefault<z.ZodString>;
+    emailEnv: z.ZodDefault<z.ZodString>;
+    siteUrl: z.ZodDefault<z.ZodString>;
+    cloudId: z.ZodOptional<z.ZodString>;
+    cloudIdEnv: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type JiraNativeConnectorConfig = z.infer<typeof JiraNativeConnectorConfigSchema>;
+export declare const DEFAULT_JIRA_NATIVE_CONNECTOR_CONFIG: JiraNativeConnectorConfig;
+export declare const PostgresNativeConnectorConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        postgres: "postgres";
+        off: "off";
+    }>>;
+    dsnEnv: z.ZodDefault<z.ZodString>;
+    allowedTables: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    allowedFunctions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    requireRls: z.ZodDefault<z.ZodBoolean>;
+    maxRows: z.ZodDefault<z.ZodNumber>;
+    statementTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    lockTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    idleTransactionTimeoutMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type PostgresNativeConnectorConfig = z.infer<typeof PostgresNativeConnectorConfigSchema>;
+export declare const DEFAULT_POSTGRES_NATIVE_CONNECTOR_CONFIG: PostgresNativeConnectorConfig;
+export declare const DriveNativeConnectorConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        rest: "rest";
+        off: "off";
+    }>>;
+    tokenEnv: z.ZodDefault<z.ZodString>;
+    selectedFileId: z.ZodOptional<z.ZodString>;
+    apiBaseUrl: z.ZodDefault<z.ZodString>;
+    allowedMimeTypes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    maxReadBytes: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type DriveNativeConnectorConfig = z.infer<typeof DriveNativeConnectorConfigSchema>;
+export declare const DEFAULT_DRIVE_NATIVE_CONNECTOR_CONFIG: DriveNativeConnectorConfig;
+export type NativeConnectorToolDescriptor = {
+    capability: ConnectorCapability;
+    normalizeEvidence: (action: NormalizedAction, payload: Record<string, JsonValue>) => LedgerProviderEvidence;
+};
+export type NativeConnectorGovernanceDescriptor<TConfig> = {
+    provider: ConnectorProvider;
+    connector: string;
+    mode: ConnectorProviderMode;
+    configSchema: z.ZodType<TConfig>;
+    defaultConfig: TConfig;
+    requiredScopes: readonly string[];
+    smokeCheck: string;
+    tools: readonly NativeConnectorToolDescriptor[];
+};
 export declare const LedgerExecutionOutcomeSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"axtary.ledger_execution_outcome.v0">;
     status: z.ZodEnum<{
@@ -389,10 +980,12 @@ export declare const LedgerExecutionOutcomeSchema: z.ZodObject<{
         slack: "slack";
         linear: "linear";
         docs: "docs";
+        drive: "drive";
         mcp: "mcp";
         aws: "aws";
         gcp: "gcp";
         jira: "jira";
+        postgres: "postgres";
     }>>;
     resultId: z.ZodOptional<z.ZodString>;
     resultUrl: z.ZodOptional<z.ZodString>;
@@ -400,15 +993,59 @@ export declare const LedgerExecutionOutcomeSchema: z.ZodObject<{
     resourceLabel: z.ZodOptional<z.ZodString>;
     failureReason: z.ZodOptional<z.ZodString>;
     errorClass: z.ZodOptional<z.ZodString>;
+    approvedPayloadHash: z.ZodOptional<z.ZodString>;
+    executedPayloadHash: z.ZodOptional<z.ZodString>;
     sideEffectProof: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
 }, z.core.$strict>;
 export type LedgerExecutionOutcome = z.infer<typeof LedgerExecutionOutcomeSchema>;
+export declare const DelegationLedgerEdgeSchema: z.ZodObject<{
+    parentPassId: z.ZodString;
+    childPassId: z.ZodString;
+    depth: z.ZodNumber;
+    rootPassId: z.ZodString;
+}, z.core.$strip>;
+export type DelegationLedgerEdge = z.infer<typeof DelegationLedgerEdgeSchema>;
+export declare const BudgetLedgerEventSchema: z.ZodObject<{
+    reservationId: z.ZodNullable<z.ZodString>;
+    scope: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        committed: "committed";
+        rolled_back: "rolled_back";
+        denied: "denied";
+    }>;
+    expiresAt: z.ZodNullable<z.ZodString>;
+    cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    committedBefore: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    committedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    reservedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type BudgetLedgerEvent = z.infer<typeof BudgetLedgerEventSchema>;
+export declare const LedgerAuditContextSchema: z.ZodObject<{
+    tenant: z.ZodNullable<z.ZodString>;
+    agentId: z.ZodString;
+    humanOwner: z.ZodString;
+    taskId: z.ZodString;
+    tool: z.ZodString;
+    resource: z.ZodString;
+}, z.core.$strip>;
+export type LedgerAuditContext = z.infer<typeof LedgerAuditContextSchema>;
 export declare const LedgerRecordSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<"axtary.ledger.v0">;
     id: z.ZodString;
     occurredAt: z.ZodString;
+    auditContext: z.ZodOptional<z.ZodObject<{
+        tenant: z.ZodNullable<z.ZodString>;
+        agentId: z.ZodString;
+        humanOwner: z.ZodString;
+        taskId: z.ZodString;
+        tool: z.ZodString;
+        resource: z.ZodString;
+    }, z.core.$strip>>;
     actionHash: z.ZodString;
     payloadHash: z.ZodString;
+    provenanceHash: z.ZodOptional<z.ZodString>;
     decision: z.ZodEnum<{
         allow: "allow";
         deny: "deny";
@@ -428,10 +1065,12 @@ export declare const LedgerRecordSchema: z.ZodObject<{
             slack: "slack";
             linear: "linear";
             docs: "docs";
+            drive: "drive";
             mcp: "mcp";
             aws: "aws";
             gcp: "gcp";
             jira: "jira";
+            postgres: "postgres";
         }>;
         tool: z.ZodString;
         operation: z.ZodString;
@@ -441,10 +1080,12 @@ export declare const LedgerRecordSchema: z.ZodObject<{
                 slack: "slack";
                 linear: "linear";
                 docs: "docs";
+                drive: "drive";
                 mcp: "mcp";
                 aws: "aws";
                 gcp: "gcp";
                 jira: "jira";
+                postgres: "postgres";
             }>;
             kind: z.ZodString;
             id: z.ZodString;
@@ -463,10 +1104,12 @@ export declare const LedgerRecordSchema: z.ZodObject<{
                 slack: "slack";
                 linear: "linear";
                 docs: "docs";
+                drive: "drive";
                 mcp: "mcp";
                 aws: "aws";
                 gcp: "gcp";
                 jira: "jira";
+                postgres: "postgres";
             }>;
             summary: z.ZodOptional<z.ZodString>;
             files: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -507,10 +1150,12 @@ export declare const LedgerRecordSchema: z.ZodObject<{
             slack: "slack";
             linear: "linear";
             docs: "docs";
+            drive: "drive";
             mcp: "mcp";
             aws: "aws";
             gcp: "gcp";
             jira: "jira";
+            postgres: "postgres";
         }>>;
         resultId: z.ZodOptional<z.ZodString>;
         resultUrl: z.ZodOptional<z.ZodString>;
@@ -518,10 +1163,34 @@ export declare const LedgerRecordSchema: z.ZodObject<{
         resourceLabel: z.ZodOptional<z.ZodString>;
         failureReason: z.ZodOptional<z.ZodString>;
         errorClass: z.ZodOptional<z.ZodString>;
+        approvedPayloadHash: z.ZodOptional<z.ZodString>;
+        executedPayloadHash: z.ZodOptional<z.ZodString>;
         sideEffectProof: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
     }, z.core.$strict>>;
     traceId: z.ZodOptional<z.ZodString>;
     actionPassId: z.ZodNullable<z.ZodString>;
+    delegation: z.ZodOptional<z.ZodObject<{
+        parentPassId: z.ZodString;
+        childPassId: z.ZodString;
+        depth: z.ZodNumber;
+        rootPassId: z.ZodString;
+    }, z.core.$strip>>;
+    budget: z.ZodOptional<z.ZodObject<{
+        reservationId: z.ZodNullable<z.ZodString>;
+        scope: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            committed: "committed";
+            rolled_back: "rolled_back";
+            denied: "denied";
+        }>;
+        expiresAt: z.ZodNullable<z.ZodString>;
+        cost: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        limit: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        committedBefore: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        committedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        reservedAfter: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>>;
     correlationId: z.ZodOptional<z.ZodString>;
     previousLedgerHash: z.ZodNullable<z.ZodString>;
     ledgerHash: z.ZodString;
@@ -554,11 +1223,30 @@ export type IssueActionPassInput = {
     parentPassId?: string | null;
     ledgerHash?: string | null;
     traceId?: string;
+    passId?: string;
+};
+export type IssueActionPassV1Input = IssueActionPassInput & {
+    holderPublicJwk: JWK;
+    delegation?: {
+        depth: number;
+        rootPassId: string;
+    };
+};
+export type IssueActionPassV2Input = IssueActionPassV1Input & {
+    status: ActionPassStatusClaim;
 };
 export type IssueActionPassResult = {
     token: string;
     claims: ActionPassClaims;
 };
+export type IssueActionPassV1Result = {
+    token: string;
+    claims: ActionPassV1Claims;
+};
+export type IssueActionPassV2Result = {
+    token: string;
+    claims: ActionPassV2Claims;
+};
 export type AuthorizeInput = {
     action: unknown;
     issuer: string;
@@ -590,9 +1278,38 @@ export type VerifyActionPassInput = {
     algorithms?: SigningAlgorithm[];
     clockTolerance?: string | number;
     currentDate?: Date;
+    dpopProof?: string;
+    dpopMethod?: string;
+    dpopUri?: string;
+    dpopNonce?: string;
+    dpopAlgorithms?: SigningAlgorithm[];
+    dpopMaxAgeSeconds?: number;
+    dpopClockSkewSeconds?: number;
+    dpopReplayStore?: DpopReplayStore;
     revokedPassIds?: Iterable<string>;
     revocations?: Iterable<ActionPassRevocation>;
     isRevoked?: (claims: ActionPassClaims) => boolean | string | Promise<boolean | string>;
+    getStatus?: (claims: ActionPassV2Claims) => number | string | Promise<number | string>;
+};
+export type ActionPassRevocationSource = Pick<VerifyActionPassInput, "revokedPassIds" | "revocations" | "isRevoked" | "getStatus">;
+export type CreateDpopProofInput = {
+    actionPass: string;
+    method: string;
+    uri: string;
+    signingKey: SigningKey;
+    publicJwk: JWK;
+    algorithm?: SigningAlgorithm;
+    now?: Date;
+    proofId?: string;
+    nonce?: string;
+};
+export type CreateDpopProofResult = {
+    proof: string;
+    claims: DpopProofClaims;
+    jkt: string;
+};
+export type DpopReplayStore = {
+    consume(proofId: string, expiresAt: Date, now?: Date): boolean | Promise<boolean>;
 };
 export type VerifyActionPassResult = {
     valid: true;
@@ -602,10 +1319,53 @@ export type VerifyActionPassResult = {
     valid: false;
     reason: string;
 };
+export type VerifyDelegationChainInput = {
+    /**
+     * Root-to-leaf chain. Every entry is signature/content verified; the leaf
+     * entry must additionally carry a fresh DPoP proof.
+     */
+    chain: VerifyActionPassInput[];
+    currentDate?: Date;
+    /**
+     * One authority-owned source applied to every root-to-leaf member. This is
+     * what makes revoking any ancestor invalidate all descendant presentations.
+     */
+    revocation?: ActionPassRevocationSource;
+};
+export type VerifyDelegationChainResult = {
+    valid: true;
+    claims: Array<ActionPassV1Claims | ActionPassV2Claims>;
+    actions: NormalizedAction[];
+} | {
+    valid: false;
+    reason: string;
+};
+export type DelegateActionPassV1Input = Omit<IssueActionPassV1Input, "action" | "decision" | "holderPublicJwk" | "parentPassId" | "delegation"> & {
+    parentChain: VerifyActionPassInput[];
+    childAction: unknown;
+    childDecision: PolicyDecision;
+    childHolderPublicJwk: JWK;
+    revocation?: ActionPassRevocationSource;
+};
+export type DelegateActionPassV1Result = IssueActionPassV1Result & {
+    delegation: DelegationLedgerEdge;
+};
+export type DelegateActionPassV2Input = Omit<IssueActionPassV2Input, "action" | "decision" | "holderPublicJwk" | "parentPassId" | "delegation" | "status"> & {
+    parentChain: VerifyActionPassInput[];
+    childAction: unknown;
+    childDecision: PolicyDecision;
+    childHolderPublicJwk: JWK;
+    childStatus: ActionPassStatusClaim;
+    revocation?: ActionPassRevocationSource;
+};
+export type DelegateActionPassV2Result = IssueActionPassV2Result & {
+    delegation: DelegationLedgerEdge;
+};
 export type CreateApprovalArtifactInput = {
     action: unknown;
     mode: "human" | "policy_override";
     approvedBy: string;
+    approverRoles?: string[];
     approvedAt?: Date;
     reason?: string;
     expiresAt?: Date;
@@ -635,7 +1395,53 @@ export declare function evaluateAction(actionInput: unknown, options?: PolicyOpt
 export declare function authorize(input: AuthorizeInput): Promise<AuthorizeResult>;
 export declare function createApprovalArtifact(input: CreateApprovalArtifactInput): CreateApprovalArtifactResult;
 export declare function issueActionPass(input: IssueActionPassInput): Promise<IssueActionPassResult>;
+export declare function issueActionPassV1(input: IssueActionPassV1Input): Promise<IssueActionPassV1Result>;
+export declare function issueActionPassV2(input: IssueActionPassV2Input): Promise<IssueActionPassV2Result>;
+export declare function delegateActionPassV1(input: DelegateActionPassV1Input): Promise<DelegateActionPassV1Result>;
+export declare function delegateActionPassV2(input: DelegateActionPassV2Input): Promise<DelegateActionPassV2Result>;
+export declare function createDpopProof(input: CreateDpopProofInput): Promise<CreateDpopProofResult>;
+export declare class InMemoryDpopReplayStore implements DpopReplayStore {
+    private readonly entries;
+    consume(proofId: string, expiresAt: Date, currentDate?: Date): boolean;
+}
+export type FileDpopReplayStoreOptions = {
+    lock?: {
+        staleMs?: number;
+        updateMs?: number;
+        retries?: number;
+        minTimeoutMs?: number;
+        maxTimeoutMs?: number;
+    };
+};
+/**
+ * Durable, inter-process replay store for DPoP proof `jti`s. A proof captured
+ * before a restart stays rejected after restart, for as long as it remains
+ * inside its own time window. Entries live only until their proof expires, so
+ * the on-disk set stays bounded to the in-flight window rather than growing
+ * unboundedly.
+ *
+ * This is a single-file local store, not a cross-host distributed one: it
+ * defends one machine's verifiers (shared across handlers/processes on that
+ * host). Authenticated cross-host distribution is out of scope here.
+ *
+ * Durability mirrors the local ledger: a `proper-lockfile` lease serializes the
+ * read-modify-write so `consume` is atomic across processes, appended lines are
+ * `fsync`ed before the lease releases, and the file is compacted in place once
+ * expired lines outnumber live ones so it cannot grow without bound.
+ */
+export declare class FileDpopReplayStore implements DpopReplayStore {
+    readonly filePath: string;
+    private readonly options;
+    constructor(filePath: string, options?: FileDpopReplayStoreOptions);
+    consume(proofId: string, expiresAt: Date, currentDate?: Date): Promise<boolean>;
+    private acquireLock;
+    private readLiveEntries;
+    private append;
+    private compact;
+}
 export declare function verifyActionPass(input: VerifyActionPassInput): Promise<VerifyActionPassResult>;
+export declare function verifyActionPassArtifact(input: VerifyActionPassInput): Promise<VerifyActionPassResult>;
+export declare function verifyDelegationChain(input: VerifyDelegationChainInput): Promise<VerifyDelegationChainResult>;
 export declare function revokeActionPass(input: RevokeActionPassInput): ActionPassRevocation;
 export declare class LocalActionPassTrustStore implements ActionPassTrustStore {
     readonly filePath: string;
@@ -652,6 +1458,8 @@ export declare function recordDecision(input: {
     action: unknown;
     decision: PolicyDecision;
     actionPassId?: string | null;
+    delegation?: DelegationLedgerEdge;
+    budget?: BudgetLedgerEvent;
     previousLedgerHash?: string | null;
     occurredAt?: Date;
     traceId?: string;
@@ -659,10 +1467,209 @@ export declare function recordDecision(input: {
     executionOutcome?: LedgerExecutionOutcome;
     correlationId?: string | null;
 }): LedgerRecord;
+/**
+ * Canonical reason token marking a ledger record as the tamper-evident
+ * revocation event for its pass. Matches the forensics `cascade_containment`
+ * convention (spec §9.5) and the trust-store revocation authority (spec §7).
+ */
+export declare const REVOCATION_LEDGER_REASON = "actionpass_revoked";
+/**
+ * Build a tamper-evident revocation event for a previously recorded pass. The
+ * event is a `deny` record naming the pass with `actionpass_revoked`, reusing
+ * the revoked record's action/payload hashes, policy, and audit context so the
+ * revocation is bound to the exact action it cancels. It carries no delegation
+ * edge or budget event (those describe the original action, not the
+ * revocation). The durable enforcement authority remains the trust store (§7);
+ * this record is the auditable logbook entry, not the enforcement source.
+ */
+export declare function recordActionPassRevocationEvent(input: {
+    revokedRecord: LedgerRecord;
+    revokedBy?: string;
+    reason?: string;
+    occurredAt?: Date;
+    previousLedgerHash?: string | null;
+}): LedgerRecord;
 export declare function hashPayload(payload: unknown): string;
+export declare function hashProvenance(provenance: ActionProvenance): string;
 export declare function hashAction(action: unknown): string;
+export declare const GITHUB_NATIVE_CONNECTOR_GOVERNANCE: NativeConnectorGovernanceDescriptor<GitHubNativeConnectorConfig>;
+export declare const LINEAR_NATIVE_CONNECTOR_GOVERNANCE: NativeConnectorGovernanceDescriptor<LinearNativeConnectorConfig>;
+export declare const JIRA_NATIVE_CONNECTOR_GOVERNANCE: NativeConnectorGovernanceDescriptor<JiraNativeConnectorConfig>;
+export declare const POSTGRES_NATIVE_CONNECTOR_GOVERNANCE: NativeConnectorGovernanceDescriptor<PostgresNativeConnectorConfig>;
+export declare const DRIVE_NATIVE_CONNECTOR_GOVERNANCE: NativeConnectorGovernanceDescriptor<DriveNativeConnectorConfig>;
+export declare const NATIVE_CONNECTOR_GOVERNANCE_REGISTRY: readonly [NativeConnectorGovernanceDescriptor<{
+    mode: "fake" | "rest" | "app";
+    tokenEnv: string;
+    apiBaseUrl: string;
+    userAgent: string;
+    appIdEnv: string;
+    installationIdEnv: string;
+    privateKeyEnv: string;
+    appId?: string | undefined;
+    installationId?: string | undefined;
+}>, NativeConnectorGovernanceDescriptor<{
+    mode: "fake" | "graphql";
+    tokenEnv: string;
+    apiUrl: string;
+}>, NativeConnectorGovernanceDescriptor<{
+    mode: "fake" | "rest";
+    auth: "api_token" | "oauth";
+    tokenEnv: string;
+    emailEnv: string;
+    siteUrl: string;
+    cloudIdEnv: string;
+    cloudId?: string | undefined;
+}>, NativeConnectorGovernanceDescriptor<{
+    mode: "postgres" | "off";
+    dsnEnv: string;
+    allowedTables: string[];
+    allowedFunctions: string[];
+    requireRls: boolean;
+    maxRows: number;
+    statementTimeoutMs: number;
+    lockTimeoutMs: number;
+    idleTransactionTimeoutMs: number;
+}>, NativeConnectorGovernanceDescriptor<{
+    mode: "rest" | "off";
+    tokenEnv: string;
+    apiBaseUrl: string;
+    allowedMimeTypes: string[];
+    maxReadBytes: number;
+    selectedFileId?: string | undefined;
+}>];
 export declare function providerEvidenceForAction(actionInput: unknown): LedgerProviderEvidence | undefined;
 export declare function hashJson(value: unknown): string;
 export declare function stableStringify(value: unknown): string;
+export declare function computeDpopAccessTokenHash(token: string): string;
+export declare function normalizeDpopMethod(method: string): string;
+export declare function normalizeDpopUri(uri: string): string;
+export declare function actionPassDpopTarget(actionInput: unknown): {
+    method: "POST";
+    uri: string;
+};
 export declare function validateApprovalArtifact(artifactInput: unknown, actionInput: unknown, now?: Date): string | null;
+export declare const AXTARY_DEFAULT_ISSUER = "axtary-dev";
+export declare const AXTARY_DEFAULT_TENANT = "local";
+export declare const AXTARY_DEFAULT_RUNTIME = "sdk";
+/** Flat authorization request — the shape from PRD §8.2. */
+export type AxtaryAuthorizeRequest = {
+    agent: string;
+    human: string;
+    intent: string;
+    tool: string;
+    resource: string;
+    payload?: Record<string, JsonValue>;
+    /** Agent runtime label; defaults to the instance runtime ("sdk"). */
+    runtime?: string;
+    /** Stable task id for ledger correlation; generated when omitted. */
+    task?: string;
+    /** Tenant; defaults to the instance tenant. */
+    tenant?: string;
+    constraints?: Record<string, JsonValue>;
+    budget?: ActionBudget;
+    toolDefinition?: NormalizedAction["toolDefinition"];
+    provenance?: ActionProvenance;
+    maxDelegationDepth?: number;
+};
+export type AxtaryPass = IssueActionPassResult;
+export type AxtaryAuthorizeResult = {
+    /** Alias of `decision.decision` so `result.status === "allow"` reads cleanly. */
+    status: AxtaryDecision;
+    decision: PolicyDecision;
+    reasons: string[];
+    explanation: PolicyDecisionExplanation;
+    payloadHash: string;
+    action: NormalizedAction;
+    pass: AxtaryPass | null;
+    ledger: LedgerRecord;
+};
+export type AxtaryAuthorizeOptions = {
+    policy?: PolicyOptions;
+    approval?: Approval;
+    approvalArtifact?: ApprovalArtifact;
+    now?: Date;
+};
+export type AxtaryExecutionOutcome = Omit<LedgerExecutionOutcome, "schemaVersion" | "sideEffectProof"> & {
+    sideEffectProof?: Record<string, JsonValue>;
+};
+export type AxtaryRecordInput = {
+    action: AxtaryAuthorizeRequest | NormalizedAction;
+    decision: PolicyDecision;
+    pass?: AxtaryPass | string | null;
+    outcome?: AxtaryExecutionOutcome;
+    correlationId?: string | null;
+    previousLedgerHash?: string | null;
+};
+export type AxtaryRevokeOptions = {
+    revokedBy?: string;
+    reason?: string;
+    revokedAt?: Date;
+};
+export type AxtaryConfig = {
+    issuer?: string;
+    tenant?: string;
+    runtime?: string;
+    /** Issuer signing key. Omit to use a persistent local dev key (see devKeypair). */
+    signingKey?: SigningKey;
+    signingKeyId?: string;
+    /** Public verification key matching `signingKey`; required for `verify`. */
+    verificationKey?: VerificationKey;
+    algorithm?: SigningAlgorithm;
+    /** Default policy options applied to every authorize call. */
+    policy?: PolicyOptions;
+    /** Override the dev keyring file path used when no signing key is configured. */
+    keyPath?: string;
+    /** Suppress the one-time dev-key warning. */
+    quiet?: boolean;
+};
+export declare class Axtary {
+    readonly issuer: string;
+    readonly tenant: string;
+    readonly runtime: string;
+    private readonly defaultPolicy?;
+    private readonly algorithm;
+    private readonly quiet;
+    private readonly configuredSigningKey?;
+    private readonly configuredKeyId?;
+    private readonly configuredVerificationKey?;
+    private readonly keyPath?;
+    private signerPromise?;
+    private ledgerHead;
+    private readonly revocations;
+    constructor(config?: AxtaryConfig);
+    /** Current local ledger head (hash of the last record this instance wrote). */
+    get ledgerHash(): string | null;
+    private resolveSigner;
+    private toNormalizedAction;
+    /**
+     * Decide an action and, for an allow, issue an ActionPass. Always returns a
+     * decision (the policy evaluation is keyless); a deny/step-up returns
+     * `pass: null`. Threads the local ledger head so successive calls chain.
+     */
+    authorize(request: AxtaryAuthorizeRequest | NormalizedAction, options?: AxtaryAuthorizeOptions): Promise<AxtaryAuthorizeResult>;
+    /**
+     * Verify a previously issued pass against an action. Accepts an authorize
+     * result, a pass object, or a raw token; the action defaults to the result's
+     * action when one is supplied. Fails closed for a pass this instance revoked.
+     */
+    verify(pass: AxtaryAuthorizeResult | AxtaryPass | string, action?: AxtaryAuthorizeRequest | NormalizedAction): Promise<VerifyActionPassResult>;
+    /**
+     * Append an execution result to the local ledger, chained after the decision
+     * record from `authorize`. Returns the tamper-evident record; durable
+     * persistence is the proxy/CLI's responsibility.
+     */
+    record(input: AxtaryRecordInput): LedgerRecord;
+    /**
+     * Revoke a pass by id. The revocation is held in this instance so a later
+     * `verify` of that pass fails closed. Durable cross-process revocation is the
+     * CLI/trust-store path (`axtary revoke`).
+     */
+    revoke(passId: string, options?: AxtaryRevokeOptions): ActionPassRevocation;
+    /** Deterministic, human-readable explanation of a decision (no model call). */
+    explain(decision: PolicyDecision | AxtaryAuthorizeResult): PolicyDecisionExplanation;
+}
+/** Create an Axtary SDK instance. */
+export declare function createAxtary(config?: AxtaryConfig): Axtary;
+/** Default Axtary SDK instance (PRD §8.2 `import { axtary }`). */
+export declare const axtary: Axtary;
 //# sourceMappingURL=index.d.ts.map