@odingard/guardian-sdk 0.0.0-stage → 0.2.0

package/dist-dts/contracts/files.d.ts

@@ -0,0 +1,61 @@
+import { z } from "zod";
+/**
+ * WO-013 — files surface. Representative read/write/share/delete through the
+ * file adapter on a deterministic local file store (lowest-burden provider).
+ */
+export declare const FILE_PATH_MAX_LENGTH = 512;
+export declare const FILE_CONTENT_MAX_LENGTH = 64000;
+export declare const FILE_GRANTEE_MAX_LENGTH = 256;
+export declare const FILE_ALLOWLIST_MAX_ENTRIES = 64;
+/**
+ * Canonical file path: `/` + non-empty segments of `[A-Za-z0-9._~-]`.
+ * No `.` or `..` segments, no `//`, no trailing slash, no root `/`.
+ * Canonical form is required so path/share allowlist prefix checks cannot
+ * be escaped by traversal or duplicate separators.
+ */
+export declare function isCanonicalFilePath(value: string): boolean;
+export declare const FilePathSchema: z.ZodString;
+/** Grantee / counterparty token: an opaque principal label (email or id). */
+export declare const CounterpartyTokenSchema: z.ZodString;
+export declare const FILE_READ_SCHEMA = "odingard.guardian.file.read.v1";
+export declare const FILE_WRITE_SCHEMA = "odingard.guardian.file.write.v1";
+export declare const FILE_SHARE_SCHEMA = "odingard.guardian.file.share.v1";
+export declare const FILE_DELETE_SCHEMA = "odingard.guardian.file.delete.v1";
+export declare const FileReadParametersV1Schema: z.ZodObject<{
+    schema: z.ZodLiteral<"odingard.guardian.file.read.v1">;
+    connectionId: z.core.$ZodBranded<z.ZodString, "ConnectionId", "out">;
+    path: z.ZodString;
+}, z.core.$strict>;
+export type FileReadParametersV1 = z.infer<typeof FileReadParametersV1Schema>;
+export declare const FileWriteParametersV1Schema: z.ZodObject<{
+    schema: z.ZodLiteral<"odingard.guardian.file.write.v1">;
+    connectionId: z.core.$ZodBranded<z.ZodString, "ConnectionId", "out">;
+    path: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strict>;
+export type FileWriteParametersV1 = z.infer<typeof FileWriteParametersV1Schema>;
+export declare const FileShareParametersV1Schema: z.ZodObject<{
+    schema: z.ZodLiteral<"odingard.guardian.file.share.v1">;
+    connectionId: z.core.$ZodBranded<z.ZodString, "ConnectionId", "out">;
+    path: z.ZodString;
+    grantee: z.ZodString;
+    expiresAtEpochMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type FileShareParametersV1 = z.infer<typeof FileShareParametersV1Schema>;
+export declare const FileDeleteParametersV1Schema: z.ZodObject<{
+    schema: z.ZodLiteral<"odingard.guardian.file.delete.v1">;
+    connectionId: z.core.$ZodBranded<z.ZodString, "ConnectionId", "out">;
+    path: z.ZodString;
+}, z.core.$strict>;
+export type FileDeleteParametersV1 = z.infer<typeof FileDeleteParametersV1Schema>;
+/**
+ * Fail-closed prefix match over canonical paths: `path` must equal an
+ * allowlist entry or sit under an entry that ends with `/`. A trailing-slash
+ * prefix cannot be escaped because `..` and `//` are excluded by canonical
+ * form.
+ */
+export declare function filePathWithinAllowlist(path: string, allowlist: readonly string[]): boolean;
+export declare function fileReadVerificationProjection(input: FileReadParametersV1): unknown;
+export declare function fileWriteVerificationProjection(input: FileWriteParametersV1): unknown;
+export declare function fileShareVerificationProjection(input: FileShareParametersV1): unknown;
+export declare function fileDeleteVerificationProjection(input: FileDeleteParametersV1): unknown;

package/dist-dts/contracts/identifiers.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+export declare const TenantIdSchema: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+export declare const PrincipalIdSchema: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+export declare const AgentIdSchema: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+export declare const GrantIdSchema: z.core.$ZodBranded<z.ZodString, "GrantId", "out">;
+export declare const PolicyIdSchema: z.core.$ZodBranded<z.ZodString, "PolicyId", "out">;
+export declare const RequestIdSchema: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
+export declare const ApprovalIdSchema: z.core.$ZodBranded<z.ZodString, "ApprovalId", "out">;
+export declare const CapabilityIdSchema: z.core.$ZodBranded<z.ZodString, "CapabilityId", "out">;
+export declare const CorrelationIdSchema: z.core.$ZodBranded<z.ZodString, "CorrelationId", "out">;
+export declare const EvidenceIdSchema: z.core.$ZodBranded<z.ZodString, "EvidenceId", "out">;
+export declare const AdapterIdSchema: z.core.$ZodBranded<z.ZodString, "AdapterId", "out">;
+export declare const ConnectionIdSchema: z.core.$ZodBranded<z.ZodString, "ConnectionId", "out">;
+export declare const AttemptIdSchema: z.core.$ZodBranded<z.ZodString, "AttemptId", "out">;
+export declare const BudgetIdSchema: z.core.$ZodBranded<z.ZodString, "BudgetId", "out">;
+export declare const TaskIdSchema: z.core.$ZodBranded<z.ZodString, "TaskId", "out">;
+export declare const PauseIdSchema: z.core.$ZodBranded<z.ZodString, "PauseId", "out">;
+export declare const ScopeIdSchema: z.core.$ZodBranded<z.ZodString, "ScopeId", "out">;
+export declare const MembershipIdSchema: z.core.$ZodBranded<z.ZodString, "MembershipId", "out">;
+export declare const IntentIdSchema: z.core.$ZodBranded<z.ZodString, "IntentId", "out">;
+export declare const PlanIdSchema: z.core.$ZodBranded<z.ZodString, "PlanId", "out">;
+export declare const DataObjectIdSchema: z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">;
+export declare const LineageEventIdSchema: z.core.$ZodBranded<z.ZodString, "LineageEventId", "out">;
+export declare const TransactionIdSchema: z.core.$ZodBranded<z.ZodString, "TransactionId", "out">;
+export declare const NonceSchema: z.core.$ZodBranded<z.ZodString, "Nonce", "out">;
+export type TenantId = z.infer<typeof TenantIdSchema>;
+export type PrincipalId = z.infer<typeof PrincipalIdSchema>;
+export type AgentId = z.infer<typeof AgentIdSchema>;
+export type GrantId = z.infer<typeof GrantIdSchema>;
+export type PolicyId = z.infer<typeof PolicyIdSchema>;
+export type RequestId = z.infer<typeof RequestIdSchema>;
+export type ApprovalId = z.infer<typeof ApprovalIdSchema>;
+export type CapabilityId = z.infer<typeof CapabilityIdSchema>;
+export type CorrelationId = z.infer<typeof CorrelationIdSchema>;
+export type EvidenceId = z.infer<typeof EvidenceIdSchema>;
+export type AdapterId = z.infer<typeof AdapterIdSchema>;
+export type ConnectionId = z.infer<typeof ConnectionIdSchema>;
+export type AttemptId = z.infer<typeof AttemptIdSchema>;
+export type BudgetId = z.infer<typeof BudgetIdSchema>;
+export type TaskId = z.infer<typeof TaskIdSchema>;
+export type PauseId = z.infer<typeof PauseIdSchema>;
+export type ScopeId = z.infer<typeof ScopeIdSchema>;
+export type MembershipId = z.infer<typeof MembershipIdSchema>;
+export type IntentId = z.infer<typeof IntentIdSchema>;
+export type PlanId = z.infer<typeof PlanIdSchema>;
+export type DataObjectId = z.infer<typeof DataObjectIdSchema>;
+export type LineageEventId = z.infer<typeof LineageEventIdSchema>;
+export type TransactionId = z.infer<typeof TransactionIdSchema>;
+export type Nonce = z.infer<typeof NonceSchema>;

package/dist-dts/contracts/index.d.ts

@@ -0,0 +1,41 @@
+export * from "./action.js";
+export * from "./action-pack.js";
+export * from "./action-registry.js";
+export * from "./agent-state.js";
+export * from "./api.js";
+export * from "./action-parameters.js";
+export * from "./assurance.js";
+export * from "./approval.js";
+export * from "./authority.js";
+export * from "./authority-state.js";
+export * from "./authority-graph.js";
+export * from "./billing.js";
+export * from "./calendar.js";
+export * from "./canonical-json.js";
+export * from "./capability.js";
+export * from "./commerce.js";
+export * from "./denial.js";
+export * from "./digest.js";
+export * from "./identifiers.js";
+export * from "./intent.js";
+export * from "./lineage.js";
+export * from "./evidence.js";
+export * from "./plan.js";
+export * from "./policy-simulation.js";
+export * from "./receipt.js";
+export * from "./tools.js";
+export * from "./transaction.js";
+export * from "./email.js";
+export * from "./execution.js";
+export * from "./files.js";
+export * from "./local.js";
+export * from "./multi-principal.js";
+export * from "./multiparty.js";
+export * from "./obligation.js";
+export * from "./prerequisite.js";
+export * from "./protected-data.js";
+export * from "./safety-envelope.js";
+export * from "./sequence.js";
+export * from "./sources.js";
+export * from "./resource-claims.js";
+export * from "./runtime.js";

package/dist-dts/contracts/intent.d.ts

@@ -0,0 +1,335 @@
+import { z } from "zod";
+/**
+ * WO-022: guardian.intent.v1 — first-class Intent Authority.
+ *
+ * An intent is a human-authored container that NARROWS what an agent may do
+ * for a bounded objective: which agents may act, which action families,
+ * which resources and counterparties, and how much value/activity the
+ * container may commit. Intents never enlarge authority — the gateway
+ * pre-gate intersects the intent's allowlists with the agent's existing
+ * authority chain, so an empty intersection denies. An intent is a
+ * declarative input to the one authority kernel (directive §89, K15);
+ * it grants no authority of its own.
+ *
+ * `obligations` and `prerequisites` are WO-023 declarative inputs
+ * (guardian.obligation.v1 / guardian.prerequisite.v1): they are evaluated
+ * deterministically at the gateway pre-gate — a failed or unsettleable
+ * entry denies, human-facing entries route through the existing ASK
+ * machinery, and nothing here ever enlarges authority.
+ * `dataBudget`/`networkBudget` are tracked-only counters — they are
+ * recorded at capability issue but do not deny.
+ */
+export declare const INTENT_CONTRACT_SCHEMA = "guardian.intent.v1";
+export declare const IntentStatusSchema: z.ZodEnum<{
+    draft: "draft";
+    active: "active";
+    revoked: "revoked";
+    expired: "expired";
+    paused: "paused";
+    completed: "completed";
+}>;
+export type IntentStatus = z.infer<typeof IntentStatusSchema>;
+export declare function canTransitionIntent(from: IntentStatus, to: IntentStatus): boolean;
+/** Absolute denials match an action id exactly or `family:<name>`. */
+export declare const AbsoluteDenialSchema: z.ZodString;
+/** Per-kind protected_data caps inside an intent (subset of §7 protected_data_rules). */
+export declare const IntentProtectedDataRuleSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        view: "view";
+        use: "use";
+        disclose: "disclose";
+        persist: "persist";
+    }>;
+    maxCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type IntentProtectedDataRule = z.infer<typeof IntentProtectedDataRuleSchema>;
+export declare const IntentContractSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"guardian.intent.v1">;
+    intentId: z.core.$ZodBranded<z.ZodString, "IntentId", "out">;
+    tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+    principal: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+    title: z.ZodString;
+    purpose: z.ZodString;
+    desiredOutcome: z.ZodString;
+    start: z.ZodNumber;
+    expires: z.ZodNumber;
+    authorizedAgents: z.ZodArray<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>;
+    allowedActionFamilies: z.ZodArray<z.ZodString>;
+    allowedResources: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ResourceRef", "out">>>;
+    counterparties: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    moneyBudgetCents: z.ZodOptional<z.ZodNumber>;
+    toolBudget: z.ZodOptional<z.ZodNumber>;
+    timeBudgetMs: z.ZodOptional<z.ZodNumber>;
+    dataBudget: z.ZodOptional<z.ZodNumber>;
+    networkBudget: z.ZodOptional<z.ZodNumber>;
+    protectedDataRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            view: "view";
+            use: "use";
+            disclose: "disclose";
+            persist: "persist";
+        }>;
+        maxCount: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+    delegationDepth: z.ZodOptional<z.ZodNumber>;
+    obligations: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodEnum<{
+            log: "log";
+            retain_receipt: "retain_receipt";
+            notify: "notify";
+            delay: "delay";
+            cooling_period: "cooling_period";
+            delete_after_use: "delete_after_use";
+            redact: "redact";
+            encrypt: "encrypt";
+            tokenize: "tokenize";
+            minimize: "minimize";
+            verify_counterparty: "verify_counterparty";
+            verify_resource: "verify_resource";
+            verify_effect: "verify_effect";
+            attest_runtime: "attest_runtime";
+            require_consent: "require_consent";
+            require_location: "require_location";
+            require_device: "require_device";
+            require_network: "require_network";
+            require_contract: "require_contract";
+            step_up: "step_up";
+            second_approver: "second_approver";
+            quorum: "quorum";
+            authenticate: "authenticate";
+        }>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
+    }, z.core.$strict>, z.ZodPipe<z.ZodEnum<{
+        log: "log";
+        retain_receipt: "retain_receipt";
+        notify: "notify";
+        delay: "delay";
+        cooling_period: "cooling_period";
+        delete_after_use: "delete_after_use";
+        redact: "redact";
+        encrypt: "encrypt";
+        tokenize: "tokenize";
+        minimize: "minimize";
+        verify_counterparty: "verify_counterparty";
+        verify_resource: "verify_resource";
+        verify_effect: "verify_effect";
+        attest_runtime: "attest_runtime";
+        require_consent: "require_consent";
+        require_location: "require_location";
+        require_device: "require_device";
+        require_network: "require_network";
+        require_contract: "require_contract";
+        step_up: "step_up";
+        second_approver: "second_approver";
+        quorum: "quorum";
+        authenticate: "authenticate";
+    }>, z.ZodTransform<{
+        type: "log" | "retain_receipt" | "notify" | "delay" | "cooling_period" | "delete_after_use" | "redact" | "encrypt" | "tokenize" | "minimize" | "verify_counterparty" | "verify_resource" | "verify_effect" | "attest_runtime" | "require_consent" | "require_location" | "require_device" | "require_network" | "require_contract" | "step_up" | "second_approver" | "quorum" | "authenticate";
+    }, "log" | "retain_receipt" | "notify" | "delay" | "cooling_period" | "delete_after_use" | "redact" | "encrypt" | "tokenize" | "minimize" | "verify_counterparty" | "verify_resource" | "verify_effect" | "attest_runtime" | "require_consent" | "require_location" | "require_device" | "require_network" | "require_contract" | "step_up" | "second_approver" | "quorum" | "authenticate">>]>>;
+    prerequisites: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            merchant_verified: "merchant_verified";
+            counterparty_verified: "counterparty_verified";
+            budget_available: "budget_available";
+            capability_present: "capability_present";
+            address_authority: "address_authority";
+            human_approval: "human_approval";
+        }>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodString>]>>>;
+    }, z.core.$strict>>>;
+    sequences: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        a: z.ZodOptional<z.ZodObject<{
+            action: z.ZodOptional<z.ZodString>;
+            resource: z.ZodOptional<z.ZodString>;
+            counterparty: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        b: z.ZodOptional<z.ZodObject<{
+            action: z.ZodOptional<z.ZodString>;
+            resource: z.ZodOptional<z.ZodString>;
+            counterparty: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        combinator: z.ZodEnum<{
+            then: "then";
+            plus: "plus";
+            within_minutes: "within_minutes";
+            using_result_of: "using_result_of";
+            affecting_resource_of: "affecting_resource_of";
+            after_protected_data: "after_protected_data";
+        }>;
+        windowMinutes: z.ZodOptional<z.ZodNumber>;
+        effect: z.ZodEnum<{
+            deny: "deny";
+            require_approval: "require_approval";
+        }>;
+    }, z.core.$strict>>>;
+    lineage: z.ZodOptional<z.ZodObject<{
+        maxClassification: z.ZodOptional<z.ZodEnum<{
+            financial: "financial";
+            internal: "internal";
+            public: "public";
+            pii: "pii";
+            phi: "phi";
+            credential: "credential";
+            confidential: "confidential";
+        }>>;
+        requireApprovalAbove: z.ZodOptional<z.ZodEnum<{
+            financial: "financial";
+            internal: "internal";
+            public: "public";
+            pii: "pii";
+            phi: "phi";
+            credential: "credential";
+            confidential: "confidential";
+        }>>;
+    }, z.core.$strict>>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        minLevel: z.ZodOptional<z.ZodEnum<{
+            T0_UNKNOWN: "T0_UNKNOWN";
+            T1_IDENTIFIED: "T1_IDENTIFIED";
+            T2_VERIFIED: "T2_VERIFIED";
+            T3_ATTESTED: "T3_ATTESTED";
+            T4_HARDWARE_BACKED: "T4_HARDWARE_BACKED";
+        }>>;
+        requireApprovalBelow: z.ZodOptional<z.ZodEnum<{
+            T0_UNKNOWN: "T0_UNKNOWN";
+            T1_IDENTIFIED: "T1_IDENTIFIED";
+            T2_VERIFIED: "T2_VERIFIED";
+            T3_ATTESTED: "T3_ATTESTED";
+            T4_HARDWARE_BACKED: "T4_HARDWARE_BACKED";
+        }>>;
+    }, z.core.$strict>>;
+    approvalStructure: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodLiteral<"guardian.multiparty.v1">;
+        structureId: z.ZodString;
+        members: z.ZodArray<z.ZodObject<{
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        requirement: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"single">;
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"nOfM">;
+            n: z.ZodNumber;
+            members: z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unanimous">;
+            members: z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"roleQuorum">;
+            role: z.ZodString;
+            n: z.ZodNumber;
+            m: z.ZodNumber;
+        }, z.core.$strict>], "kind">;
+        specificRequired: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>>;
+        veto: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>>;
+        separationOfDuties: z.ZodOptional<z.ZodObject<{
+            mutuallyExclusive: z.ZodArray<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        temporaryApprovers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            expiresAtEpochMs: z.ZodNumber;
+        }, z.core.$strict>>>;
+        delegatedApprovers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            memberId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            delegatedBy: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        }, z.core.$strict>>>;
+        emergencyApprovers: z.ZodOptional<z.ZodArray<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>>;
+        coolingPeriod: z.ZodOptional<z.ZodObject<{
+            seconds: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    authoritySources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    transaction: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodLiteral<"guardian.transaction.v1">;
+        stages: z.ZodArray<z.ZodEnum<{
+            PROPOSE: "PROPOSE";
+            PREPARE: "PREPARE";
+            AUTHORIZE: "AUTHORIZE";
+            LOCK: "LOCK";
+            COMMIT: "COMMIT";
+            VERIFY: "VERIFY";
+            SETTLE: "SETTLE";
+        }>>;
+        deadlineMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    safetyEnvelope: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodLiteral<"guardian.safety_envelope.v1">;
+        allowedZone: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        forbiddenZone: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxSpeed: z.ZodOptional<z.ZodNumber>;
+        maxForce: z.ZodOptional<z.ZodNumber>;
+        maxPayload: z.ZodOptional<z.ZodNumber>;
+        timeWindow: z.ZodOptional<z.ZodObject<{
+            startMinutesOfDay: z.ZodNumber;
+            endMinutesOfDay: z.ZodNumber;
+        }, z.core.$strict>>;
+        proximityConstraints: z.ZodOptional<z.ZodObject<{
+            minHumanDistance: z.ZodNumber;
+        }, z.core.$strict>>;
+        environmentConditions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        supervisionRequired: z.ZodOptional<z.ZodBoolean>;
+        failSafeAction: z.ZodOptional<z.ZodString>;
+        emergencyStop: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    absoluteDenials: z.ZodArray<z.ZodString>;
+    approvalPolicy: z.ZodEnum<{
+        default: "default";
+        always_ask: "always_ask";
+    }>;
+    authorityVersion: z.ZodNumber;
+    status: z.ZodEnum<{
+        draft: "draft";
+        active: "active";
+        revoked: "revoked";
+        expired: "expired";
+        paused: "paused";
+        completed: "completed";
+    }>;
+    version: z.ZodNumber;
+    createdAtEpochMs: z.ZodNumber;
+    updatedAtEpochMs: z.ZodNumber;
+}, z.core.$strict>;
+export type IntentContract = z.infer<typeof IntentContractSchema>;
+export declare const IntentTransitionRequestSchema: z.ZodObject<{
+    to: z.ZodEnum<{
+        draft: "draft";
+        active: "active";
+        revoked: "revoked";
+        expired: "expired";
+        paused: "paused";
+        completed: "completed";
+    }>;
+}, z.core.$strict>;
+export type IntentTransitionRequest = z.infer<typeof IntentTransitionRequestSchema>;
+/** Pure transition: returns the next contract or a reason code. */
+export declare function transitionIntent(intent: IntentContract, to: IntentStatus, nowEpochMs: number): {
+    ok: true;
+    intent: IntentContract;
+} | {
+    ok: false;
+    reasonCode: string;
+};
+/** Deterministic expiry: an active/paused intent past its expiry reads as expired. */
+export declare function effectiveIntentStatus(intent: IntentContract, nowEpochMs: number): IntentStatus;
+export type IntentPreGateFailure = "INTENT_NOT_FOUND" | "INTENT_TENANT_MISMATCH" | "INTENT_PRINCIPAL_MISMATCH" | "INTENT_NOT_ACTIVE" | "INTENT_NOT_YET_STARTED" | "INTENT_EXPIRED" | "INTENT_TIME_BUDGET_EXCEEDED" | "INTENT_AGENT_NOT_AUTHORIZED" | "INTENT_ACTION_DENIED" | "INTENT_DELEGATION_DEPTH_EXCEEDED" | "INTENT_TASK_NOT_IN_PLAN" | "INTENT_PROTECTED_DATA_DENIED" | "INTENT_BUDGET_EXCEEDED";
+export interface IntentPreGateInput {
+    readonly intent: IntentContract | null;
+    readonly tenantId: string;
+    readonly principalId: string;
+    readonly agentId: string;
+    readonly actionId: string;
+    readonly actionFamily: string | null;
+    readonly nowEpochMs: number;
+    /** Delegation depth of the acting agent (0 = no parent chain). */
+    readonly agentDelegationDepth: number;
+    /** Plan task membership: when the action carries taskId, whether a plan
+     *  under this intent contains that task; undefined = no plans exist. */
+    readonly taskInPlan: boolean | undefined;
+    /** For protected_data.* actions: the kind suffix (use|view|disclose|persist). */
+    readonly protectedDataKind: IntentProtectedDataRule["kind"] | null;
+}
+/** Pure pre-gate evaluator. Returns the failed rule name or null (pass). */
+export declare function evaluateIntentPreGate(input: IntentPreGateInput): IntentPreGateFailure | null;