@odingard/guardian-sdk 0.1.0 → 0.2.0

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

@@ -14,6 +14,14 @@ export declare const ConnectionIdSchema: z.core.$ZodBranded<z.ZodString, "Connec
 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>;
@@ -30,4 +38,12 @@ 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

@@ -1,19 +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;

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

@@ -0,0 +1,218 @@
+import { z } from "zod";
+/**
+ * WO-025: guardian.lineage.v1 — derived-data lineage contract
+ * (GUA-AUTHORITY-OS-001 §17–20).
+ *
+ * Every data object records a human/policy-declared classification plus the
+ * lineage that produced it (sources, derivations, declared transformation
+ * records). Propagation is pure and deterministic:
+ *
+ *   effectiveClassification(object) =
+ *     the recorded resultClassification of the object's declared
+ *     transformation, when one exists;
+ *     otherwise the maximum of its own declared classification and the
+ *     effective classification of every recorded source.
+ *
+ * A model/agent assertion NEVER changes classification — the only path to a
+ * narrower result is a declared transformation record bound into the stored
+ * object (and into the material digest of the action that registered it).
+ * Missing lineage for a classified source fails closed.
+ */
+export declare const LINEAGE_CONTRACT_SCHEMA = "guardian.lineage.v1";
+/** Ordered data classification lattice (lowest → highest). */
+export declare const DataClassificationSchema: z.ZodEnum<{
+    financial: "financial";
+    internal: "internal";
+    public: "public";
+    pii: "pii";
+    phi: "phi";
+    credential: "credential";
+    confidential: "confidential";
+}>;
+export type DataClassification = z.infer<typeof DataClassificationSchema>;
+export declare const CLASSIFICATION_RANK: Record<DataClassification, number>;
+export declare function maxClassification(a: DataClassification, b: DataClassification): DataClassification;
+export declare function classificationExceeds(value: DataClassification, ceiling: DataClassification): boolean;
+export declare const DataSensitivitySchema: z.ZodEnum<{
+    low: "low";
+    moderate: "moderate";
+    high: "high";
+}>;
+export type DataSensitivity = z.infer<typeof DataSensitivitySchema>;
+/** A declared, policy-defined transformation record (§19). */
+export declare const DataTransformationSchema: z.ZodObject<{
+    type: z.ZodString;
+    resultClassification: z.ZodEnum<{
+        financial: "financial";
+        internal: "internal";
+        public: "public";
+        pii: "pii";
+        phi: "phi";
+        credential: "credential";
+        confidential: "confidential";
+    }>;
+}, z.core.$strict>;
+export type DataTransformation = z.infer<typeof DataTransformationSchema>;
+/** Upstream reference: another data object or the action that produced it. */
+export declare const DataSourceRefSchema: z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">, z.core.$ZodBranded<z.ZodString, "RequestId", "out">]>;
+export type DataSourceRef = z.infer<typeof DataSourceRefSchema>;
+export declare const DataObjectSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"guardian.lineage.v1">;
+    dataObjectId: z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">;
+    owner: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+    classification: z.ZodEnum<{
+        financial: "financial";
+        internal: "internal";
+        public: "public";
+        pii: "pii";
+        phi: "phi";
+        credential: "credential";
+        confidential: "confidential";
+    }>;
+    sources: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">, z.core.$ZodBranded<z.ZodString, "RequestId", "out">]>>>;
+    derivations: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">>>;
+    transformations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        resultClassification: z.ZodEnum<{
+            financial: "financial";
+            internal: "internal";
+            public: "public";
+            pii: "pii";
+            phi: "phi";
+            credential: "credential";
+            confidential: "confidential";
+        }>;
+    }, z.core.$strict>>>;
+    sensitivity: z.ZodEnum<{
+        low: "low";
+        moderate: "moderate";
+        high: "high";
+    }>;
+    authorizedUses: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    authorizedDisclosures: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    retentionSeconds: z.ZodOptional<z.ZodNumber>;
+    expiryEpochMs: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodNumber;
+}, z.core.$strict>;
+export type DataObject = z.infer<typeof DataObjectSchema>;
+/** Lineage policy declared on guardian.intent.v1 (`lineage` field). */
+export declare const LineagePolicySchema: 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>;
+export type LineagePolicy = z.infer<typeof LineagePolicySchema>;
+export declare const LineageEventKindSchema: z.ZodEnum<{
+    transform: "transform";
+    derive: "derive";
+    export: "export";
+    share: "share";
+    violation: "violation";
+}>;
+export type LineageEventKind = z.infer<typeof LineageEventKindSchema>;
+export declare const LineageEventSchema: z.ZodObject<{
+    lineageEventId: z.core.$ZodBranded<z.ZodString, "LineageEventId", "out">;
+    dataObjectId: z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">;
+    kind: z.ZodEnum<{
+        transform: "transform";
+        derive: "derive";
+        export: "export";
+        share: "share";
+        violation: "violation";
+    }>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodNumber;
+}, z.core.$strict>;
+export type LineageEvent = z.infer<typeof LineageEventSchema>;
+export type LineageResolution = {
+    ok: true;
+    effectiveClassification: DataClassification;
+    sourceRefs: readonly DataSourceRef[];
+    expired: boolean;
+} | {
+    ok: false;
+    reason: "missing";
+    dataObjectId: string;
+} | {
+    ok: false;
+    reason: "cycle";
+    dataObjectId: string;
+};
+/**
+ * Resolve the effective classification of a data object over its recorded
+ * lineage. `resolve` is the read-only data-object port; it must return null
+ * for unrecorded ids so missing lineage fails closed.
+ */
+export declare function effectiveClassification(object: DataObject, resolve: (dataObjectId: string) => DataObject | null | undefined, nowEpochMs: number): LineageResolution;
+/**
+ * Async variant of `effectiveClassification` for the gateway: resolves the
+ * root object through the injected read-only port, then walks upstream.
+ * Missing lineage for a classified source fails closed ("missing").
+ */
+export declare function resolveDataObjectLineage(dataObjectId: string, get: (id: string) => Promise<DataObject | null | undefined>, nowEpochMs: number): Promise<LineageResolution>;
+export declare const LineageMatchOutcomeSchema: z.ZodObject<{
+    dataObjectId: z.core.$ZodBranded<z.ZodString, "DataObjectId", "out">;
+    effectiveClassification: z.ZodEnum<{
+        financial: "financial";
+        internal: "internal";
+        public: "public";
+        pii: "pii";
+        phi: "phi";
+        credential: "credential";
+        confidential: "confidential";
+    }>;
+    effect: z.ZodEnum<{
+        allowed: "allowed";
+        deny: "deny";
+        require_approval: "require_approval";
+    }>;
+    expired: z.ZodBoolean;
+}, z.core.$strict>;
+export type LineageMatchOutcome = z.infer<typeof LineageMatchOutcomeSchema>;
+/**
+ * Evaluate a declared lineage policy over resolved objects. Pure: reports
+ * deny | require_approval | allowed with deterministic rule refs and never
+ * mutates authority.
+ */
+export declare function evaluateLineagePolicy(policy: LineagePolicy | undefined, resolved: readonly {
+    dataObjectId: string;
+    resolution: LineageResolution;
+}[]): {
+    verdict: "deny";
+    ruleId: string;
+    outcomes: LineageMatchOutcome[];
+} | {
+    verdict: "require_approval";
+    ruleId: string;
+    outcomes: LineageMatchOutcome[];
+} | {
+    verdict: "allowed";
+    outcomes: LineageMatchOutcome[];
+};
+/** Deterministic id for a data object registered by a derive/transform action. */
+export declare function derivedDataObjectId(input: {
+    tenantId: string;
+    actionRef: string;
+}): string;
+/** Deterministic id for a recorded lineage event row. */
+export declare function lineageEventId(input: {
+    tenantId: string;
+    actionRef: string;
+    dataObjectId: string;
+    kind: LineageEventKind;
+}): string;