@odingard/guardian-sdk 0.1.0 → 0.2.0

package/dist-dts/contracts/policy-simulation.d.ts

@@ -0,0 +1,681 @@
+import { z } from "zod";
+import { type RecordedAuthorityEvaluationInput } from "./action.js";
+import { type AuthorityDecision } from "./authority.js";
+import { AgentIdSchema, CorrelationIdSchema, PrincipalIdSchema, RequestIdSchema, TenantIdSchema } from "./identifiers.js";
+/**
+ * WO-030: guardian.policy_simulation.v1 — policy simulation, authority
+ * diff, blast radius, shadow authority and the declared mode lifecycle
+ * (GUA-AUTHORITY-OS-001 §48–52, §79, §88–89, K15).
+ *
+ * §48 — the simulator answers "what would this policy allow?" over
+ * recorded history, synthetic scenarios, or current agents/resources.
+ * Every scenario is a recorded evaluation input; the simulator runs the
+ * SAME kernel verdicts as the live path against it, deterministically.
+ * Simulation never mutates live state and never fabricates an approval.
+ *
+ * §49 — the authority diff compares baseline and candidate outcomes: the
+ * verdict-count deltas and the materialized newly-allowed and
+ * newly-denied action-class lists.
+ *
+ * §50 — blast radius reports, deterministically, which agents, resources,
+ * action classes, counterparties, money, protected data, delegation and
+ * runtime windows the candidate expands.
+ *
+ * §51 — OBSERVE shadow mode computes the SAME ALLOW/ASK/DENY verdict but
+ * does not alter execution; the computed outcome is recorded as
+ * would_allow / would_ask / would_deny. would_* is a RECORD field, never
+ * a fourth verdict.
+ *
+ * §52 — the declared lifecycle OBSERVE → WARN → ASK-HEAVY → ENFORCE moves
+ * one adjacent step per recorded transition. Transitions are
+ * authority-bound, never silent, and cannot skip a stage.
+ *
+ * Truthfulness: this contract claims deterministic simulation, diff,
+ * blast radius, shadow recording and a declared lifecycle only. It does
+ * not predict real-world outcomes and never replaces human approval.
+ */
+export declare const POLICY_SIMULATION_CONTRACT_SCHEMA = "guardian.policy_simulation.v1";
+/**
+ * The declared shadow/lifecycle mode for an agent. Modes are ordered:
+ * a transition may only move one adjacent step and may never skip.
+ */
+export declare const AuthorityModeSchema: z.ZodEnum<{
+    observe: "observe";
+    warn: "warn";
+    ask_heavy: "ask_heavy";
+    enforce: "enforce";
+}>;
+export type AuthorityMode = z.infer<typeof AuthorityModeSchema>;
+/** Declared lifecycle order; index distance defines adjacency. */
+export declare const AUTHORITY_MODE_ORDER: readonly ["observe", "warn", "ask_heavy", "enforce"];
+export declare const AuthorityModeTransitionSchema: z.ZodObject<{
+    fromMode: z.ZodEnum<{
+        observe: "observe";
+        warn: "warn";
+        ask_heavy: "ask_heavy";
+        enforce: "enforce";
+    }>;
+    toMode: z.ZodEnum<{
+        observe: "observe";
+        warn: "warn";
+        ask_heavy: "ask_heavy";
+        enforce: "enforce";
+    }>;
+    atEpochMs: z.ZodNumber;
+    actor: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type AuthorityModeTransition = z.infer<typeof AuthorityModeTransitionSchema>;
+/** Recorded lifecycle state of one agent (tenant-scoped, CAS-versioned). */
+export declare const AuthorityModeStateSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"guardian.policy_simulation.v1">;
+    tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+    agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+    mode: z.ZodEnum<{
+        observe: "observe";
+        warn: "warn";
+        ask_heavy: "ask_heavy";
+        enforce: "enforce";
+    }>;
+    version: z.ZodNumber;
+    updatedBy: z.ZodNullable<z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">>;
+    updatedAtEpochMs: z.ZodNumber;
+    lastTransition: z.ZodNullable<z.ZodObject<{
+        fromMode: z.ZodEnum<{
+            observe: "observe";
+            warn: "warn";
+            ask_heavy: "ask_heavy";
+            enforce: "enforce";
+        }>;
+        toMode: z.ZodEnum<{
+            observe: "observe";
+            warn: "warn";
+            ask_heavy: "ask_heavy";
+            enforce: "enforce";
+        }>;
+        atEpochMs: z.ZodNumber;
+        actor: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AuthorityModeState = z.infer<typeof AuthorityModeStateSchema>;
+export declare const AuthorityModeCommandSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"set_mode">;
+    mode: z.ZodEnum<{
+        observe: "observe";
+        warn: "warn";
+        ask_heavy: "ask_heavy";
+        enforce: "enforce";
+    }>;
+    actor: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+    expectedVersion: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type AuthorityModeCommand = z.infer<typeof AuthorityModeCommandSchema>;
+/** The state a tenant's agents start in when no mode row exists. */
+export declare function initialAuthorityModeState(input: {
+    tenantId: z.infer<typeof TenantIdSchema>;
+    agentId: z.infer<typeof AgentIdSchema>;
+    nowEpochMs: number;
+}): AuthorityModeState;
+/**
+ * CAS mode transition (§52): one adjacent step per command; a recorded
+ * transition is appended to the state and never silent. Same-mode is
+ * not a transition and is rejected.
+ */
+export declare function transitionAuthorityMode(recordInput: unknown, commandInput: unknown, nowEpochMs: number): {
+    ok: true;
+    record: AuthorityModeState;
+} | {
+    ok: false;
+    reasonCode: "MALFORMED_RECORD" | "MALFORMED_COMMAND" | "STALE_VERSION" | "INVALID_TRANSITION";
+};
+/**
+ * A shadow verdict is what the kernel computed under OBSERVE/WARN — a
+ * record label, never a fourth AuthorityDecision.
+ */
+export declare const ShadowVerdictSchema: z.ZodEnum<{
+    would_allow: "would_allow";
+    would_ask: "would_ask";
+    would_deny: "would_deny";
+}>;
+export type ShadowVerdict = z.infer<typeof ShadowVerdictSchema>;
+/** Maps the kernel verdict to its recorded shadow label. */
+export declare function shadowVerdictFor(decision: AuthorityDecision["decision"]): ShadowVerdict;
+/** Modes under which execution is unaltered and verdicts are recorded. */
+export declare const SHADOW_MODES: readonly ["observe", "warn"];
+/** Digest-bound record of what an observed request would have done. */
+export declare const ShadowDecisionRecordSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"guardian.policy_simulation.v1">;
+    tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+    principalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+    agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+    requestId: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
+    correlationId: z.core.$ZodBranded<z.ZodString, "CorrelationId", "out">;
+    actionDigest: z.ZodString;
+    mode: z.ZodEnum<{
+        observe: "observe";
+        warn: "warn";
+    }>;
+    verdict: z.ZodEnum<{
+        would_allow: "would_allow";
+        would_ask: "would_ask";
+        would_deny: "would_deny";
+    }>;
+    reasonCode: z.ZodString;
+    actionDecisionRecordDigest: z.ZodNullable<z.ZodString>;
+    decidedAtEpochMs: z.ZodNumber;
+}, z.core.$strict>;
+export type ShadowDecisionRecord = z.infer<typeof ShadowDecisionRecordSchema>;
+export declare function shadowDecisionRecordDigest(record: ShadowDecisionRecord): string;
+/**
+ * Builds the digest-bound shadow record for an OBSERVE/WARN issuance:
+ * what the kernel computed, bound to the live action and decision-record
+ * digests. The record never enters the verdict itself.
+ */
+export declare function createShadowDecisionRecord(input: {
+    tenantId: z.infer<typeof TenantIdSchema>;
+    principalId: z.infer<typeof PrincipalIdSchema>;
+    agentId: z.infer<typeof AgentIdSchema>;
+    requestId: z.infer<typeof RequestIdSchema>;
+    correlationId: z.infer<typeof CorrelationIdSchema>;
+    actionDigest: string;
+    mode: "observe" | "warn";
+    decision: AuthorityDecision;
+    actionDecisionRecordDigest: string | null;
+    decidedAtEpochMs: number;
+}): ShadowDecisionRecord;
+/**
+ * One simulation scenario: the recorded evaluation input the SAME kernel
+ * would evaluate live — recorded history replayed, a synthetic input, or
+ * a current agent/resource pair rebuilt by the caller.
+ */
+export declare const PolicyScenarioSchema: z.ZodObject<{
+    scenarioId: z.ZodString;
+    evaluationInput: z.ZodObject<{
+        nowEpochMs: z.ZodNumber;
+        principal: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+            status: z.ZodEnum<{
+                active: "active";
+                disabled: "disabled";
+            }>;
+        }, z.core.$strict>;
+        agent: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+            ownerPrincipalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            status: z.ZodEnum<{
+                active: "active";
+                disabled: "disabled";
+                revoked: "revoked";
+            }>;
+            allowedInterfaces: z.ZodPipe<z.ZodArray<z.ZodEnum<{
+                mcp: "mcp";
+                rest: "rest";
+                internal: "internal";
+            }>>, z.ZodTransform<("mcp" | "rest" | "internal")[], ("mcp" | "rest" | "internal")[]>>;
+            boundRuntime: z.ZodOptional<z.ZodString>;
+            boundModel: z.ZodOptional<z.ZodString>;
+            parentAgentId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>;
+        }, z.core.$strict>;
+        request: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "RequestId", "out">;
+            tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+            principalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            action: z.core.$ZodBranded<z.ZodString, "ActionType", "out">;
+            resource: z.core.$ZodBranded<z.ZodString, "ResourceRef", "out">;
+            interface: z.ZodEnum<{
+                mcp: "mcp";
+                rest: "rest";
+                internal: "internal";
+            }>;
+            requestedAdapterId: z.core.$ZodBranded<z.ZodString, "AdapterId", "out">;
+            valueCents: z.ZodOptional<z.ZodNumber>;
+            uses: z.ZodNumber;
+            materialActionDigest: z.ZodOptional<z.ZodString>;
+            descriptiveContext: z.ZodOptional<z.ZodString>;
+            merchantId: z.ZodOptional<z.ZodString>;
+            merchantCategory: z.ZodOptional<z.ZodString>;
+            recurring: z.ZodOptional<z.ZodBoolean>;
+            taskId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+            intentId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "IntentId", "out">>;
+            planId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "PlanId", "out">>;
+        }, z.core.$strict>;
+        policy: z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "PolicyId", "out">;
+            version: z.ZodNumber;
+        }, z.core.$strict>;
+        authorityChain: z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "GrantId", "out">;
+            tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+            principalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            parentGrantId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>;
+            issuedBy: z.ZodObject<{
+                type: z.ZodLiteral<"principal">;
+                principalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            }, z.core.$strict>;
+            status: z.ZodEnum<{
+                active: "active";
+                disabled: "disabled";
+                revoked: "revoked";
+            }>;
+            version: z.ZodNumber;
+            delegable: z.ZodDefault<z.ZodBoolean>;
+            constraints: z.ZodObject<{
+                actions: z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>, z.ZodTransform<(string & z.core.$brand<"ActionType">)[], (string & z.core.$brand<"ActionType">)[]>>;
+                resources: z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ResourceRef", "out">>, z.ZodTransform<(string & z.core.$brand<"ResourceRef">)[], (string & z.core.$brand<"ResourceRef">)[]>>;
+                adapterIds: z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "AdapterId", "out">>, z.ZodTransform<(string & z.core.$brand<"AdapterId">)[], (string & z.core.$brand<"AdapterId">)[]>>;
+                maxValueCents: z.ZodOptional<z.ZodNumber>;
+                maxUsesPerRequest: z.ZodNumber;
+                notBeforeEpochMs: z.ZodOptional<z.ZodNumber>;
+                expiresAtEpochMs: z.ZodNumber;
+                approvalRequired: z.ZodBoolean;
+                askAboveValueCents: z.ZodOptional<z.ZodNumber>;
+                merchantAllowlist: z.ZodOptional<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
+                categoryAllowlist: z.ZodOptional<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
+                recurrence: z.ZodOptional<z.ZodEnum<{
+                    never: "never";
+                    allowed: "allowed";
+                }>>;
+                budgetIds: z.ZodOptional<z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "BudgetId", "out">>, z.ZodTransform<(string & z.core.$brand<"BudgetId">)[], (string & z.core.$brand<"BudgetId">)[]>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        revocations: z.ZodPipe<z.ZodArray<z.ZodObject<{
+            grantId: z.core.$ZodBranded<z.ZodString, "GrantId", "out">;
+            revokedAtEpochMs: z.ZodNumber;
+            reasonCode: z.ZodString;
+        }, z.core.$strict>>, z.ZodTransform<{
+            grantId: string & z.core.$brand<"GrantId">;
+            revokedAtEpochMs: number;
+            reasonCode: string;
+        }[], {
+            grantId: string & z.core.$brand<"GrantId">;
+            revokedAtEpochMs: number;
+            reasonCode: string;
+        }[]>>;
+        budgets: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "BudgetId", "out">;
+            scope: z.ZodEnum<{
+                agent: "agent";
+                task: "task";
+            }>;
+            taskId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "TaskId", "out">>;
+            limitCents: z.ZodNumber;
+            consumedCents: z.ZodNumber;
+            transactionLimit: z.ZodNumber;
+            consumedTransactions: z.ZodNumber;
+            expiresAtEpochMs: z.ZodOptional<z.ZodNumber>;
+            status: z.ZodEnum<{
+                active: "active";
+                exhausted: "exhausted";
+                revoked: "revoked";
+            }>;
+        }, z.core.$strict>>>, z.ZodTransform<{
+            id: string & z.core.$brand<"BudgetId">;
+            scope: "agent" | "task";
+            limitCents: number;
+            consumedCents: number;
+            transactionLimit: number;
+            consumedTransactions: number;
+            status: "active" | "exhausted" | "revoked";
+            taskId?: (string & z.core.$brand<"TaskId">) | undefined;
+            expiresAtEpochMs?: number | undefined;
+        }[], {
+            id: string & z.core.$brand<"BudgetId">;
+            scope: "agent" | "task";
+            limitCents: number;
+            consumedCents: number;
+            transactionLimit: number;
+            consumedTransactions: number;
+            status: "active" | "exhausted" | "revoked";
+            taskId?: (string & z.core.$brand<"TaskId">) | undefined;
+            expiresAtEpochMs?: number | undefined;
+        }[]>>;
+        pauses: z.ZodPipe<z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "PauseId", "out">;
+            scope: z.ZodEnum<{
+                agent: "agent";
+                principal: "principal";
+                grant: "grant";
+                connection: "connection";
+            }>;
+            agentId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>;
+            grantIds: z.ZodOptional<z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>, z.ZodTransform<(string & z.core.$brand<"GrantId">)[], (string & z.core.$brand<"GrantId">)[]>>>;
+            adapterIds: z.ZodOptional<z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "AdapterId", "out">>, z.ZodTransform<(string & z.core.$brand<"AdapterId">)[], (string & z.core.$brand<"AdapterId">)[]>>>;
+        }, z.core.$strict>>>, z.ZodTransform<{
+            id: string & z.core.$brand<"PauseId">;
+            scope: "agent" | "principal" | "grant" | "connection";
+            agentId?: (string & z.core.$brand<"AgentId">) | undefined;
+            grantIds?: (string & z.core.$brand<"GrantId">)[] | undefined;
+            adapterIds?: (string & z.core.$brand<"AdapterId">)[] | undefined;
+        }[], {
+            id: string & z.core.$brand<"PauseId">;
+            scope: "agent" | "principal" | "grant" | "connection";
+            agentId?: (string & z.core.$brand<"AgentId">) | undefined;
+            grantIds?: (string & z.core.$brand<"GrantId">)[] | undefined;
+            adapterIds?: (string & z.core.$brand<"AdapterId">)[] | undefined;
+        }[]>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type PolicyScenario = z.infer<typeof PolicyScenarioSchema>;
+/**
+ * The policy under test: a proposed policy reference and a declarative
+ * grant-set mutation applied to each scenario's authority chain. A human
+ * always activates policy; applying a candidate only ever changes a
+ * simulation input, never live state.
+ */
+export declare const PolicyCandidateSchema: z.ZodObject<{
+    policy: z.ZodOptional<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "PolicyId", "out">;
+        version: z.ZodNumber;
+    }, z.core.$strict>>;
+    upsertedGrants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.core.$ZodBranded<z.ZodString, "GrantId", "out">;
+        tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+        principalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        parentGrantId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>;
+        issuedBy: z.ZodObject<{
+            type: z.ZodLiteral<"principal">;
+            principalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+        }, z.core.$strict>;
+        status: z.ZodEnum<{
+            active: "active";
+            disabled: "disabled";
+            revoked: "revoked";
+        }>;
+        version: z.ZodNumber;
+        delegable: z.ZodDefault<z.ZodBoolean>;
+        constraints: z.ZodObject<{
+            actions: z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>, z.ZodTransform<(string & z.core.$brand<"ActionType">)[], (string & z.core.$brand<"ActionType">)[]>>;
+            resources: z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ResourceRef", "out">>, z.ZodTransform<(string & z.core.$brand<"ResourceRef">)[], (string & z.core.$brand<"ResourceRef">)[]>>;
+            adapterIds: z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "AdapterId", "out">>, z.ZodTransform<(string & z.core.$brand<"AdapterId">)[], (string & z.core.$brand<"AdapterId">)[]>>;
+            maxValueCents: z.ZodOptional<z.ZodNumber>;
+            maxUsesPerRequest: z.ZodNumber;
+            notBeforeEpochMs: z.ZodOptional<z.ZodNumber>;
+            expiresAtEpochMs: z.ZodNumber;
+            approvalRequired: z.ZodBoolean;
+            askAboveValueCents: z.ZodOptional<z.ZodNumber>;
+            merchantAllowlist: z.ZodOptional<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
+            categoryAllowlist: z.ZodOptional<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
+            recurrence: z.ZodOptional<z.ZodEnum<{
+                never: "never";
+                allowed: "allowed";
+            }>>;
+            budgetIds: z.ZodOptional<z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "BudgetId", "out">>, z.ZodTransform<(string & z.core.$brand<"BudgetId">)[], (string & z.core.$brand<"BudgetId">)[]>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    removedGrantIds: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>>;
+}, z.core.$strict>;
+export type PolicyCandidate = z.infer<typeof PolicyCandidateSchema>;
+/**
+ * Applies a candidate to an evaluation input: removed grant ids drop
+ * out, upserts replace same-id grants, remaining grants sort by id for
+ * determinism, and a proposed policy reference replaces the recorded one.
+ */
+export declare function applyPolicyCandidate(input: RecordedAuthorityEvaluationInput, candidateInput: unknown): RecordedAuthorityEvaluationInput;
+/**
+ * ASK-HEAVY posture (§52): the declared transform narrows every chain
+ * grant to approval-required, so the SAME kernel naturally returns ASK
+ * for anything satisfiable — a declarative input change, never a kernel
+ * branch. The recorded evaluation input binds the transformed chain.
+ */
+export declare function applyAskHeavyPosture(input: RecordedAuthorityEvaluationInput): RecordedAuthorityEvaluationInput;
+/** A live verdict as computed by the one kernel — three values only. */
+export declare const SimulationVerdictSchema: z.ZodEnum<{
+    ALLOW: "ALLOW";
+    ASK: "ASK";
+    DENY: "DENY";
+}>;
+export type SimulationVerdict = z.infer<typeof SimulationVerdictSchema>;
+export declare const SimulationOutcomeSchema: z.ZodObject<{
+    scenarioId: z.ZodString;
+    agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+    action: z.core.$ZodBranded<z.ZodString, "ActionType", "out">;
+    resource: z.ZodString;
+    verdict: z.ZodEnum<{
+        ALLOW: "ALLOW";
+        ASK: "ASK";
+        DENY: "DENY";
+    }>;
+    reasonCode: z.ZodString;
+}, z.core.$strict>;
+export type SimulationOutcome = z.infer<typeof SimulationOutcomeSchema>;
+export declare const AuthorityVerdictCountsSchema: z.ZodObject<{
+    allow: z.ZodNumber;
+    ask: z.ZodNumber;
+    deny: z.ZodNumber;
+}, z.core.$strict>;
+export type AuthorityVerdictCounts = z.infer<typeof AuthorityVerdictCountsSchema>;
+export declare function countOutcomes(outcomes: readonly Pick<SimulationOutcome, "verdict">[]): AuthorityVerdictCounts;
+export declare const AuthorityOutcomeChangeSchema: z.ZodObject<{
+    scenarioId: z.ZodString;
+    agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+    action: z.core.$ZodBranded<z.ZodString, "ActionType", "out">;
+    previousVerdict: z.ZodEnum<{
+        ALLOW: "ALLOW";
+        ASK: "ASK";
+        DENY: "DENY";
+    }>;
+    proposedVerdict: z.ZodEnum<{
+        ALLOW: "ALLOW";
+        ASK: "ASK";
+        DENY: "DENY";
+    }>;
+}, z.core.$strict>;
+export type AuthorityOutcomeChange = z.infer<typeof AuthorityOutcomeChangeSchema>;
+/**
+ * §49 diff: verdict-count deltas plus the materialized newly-allowed and
+ * newly-denied action classes (newly-asked materialized alongside).
+ */
+export declare const AuthorityDiffSchema: z.ZodObject<{
+    verdictDelta: z.ZodObject<{
+        allow: z.ZodNumber;
+        ask: z.ZodNumber;
+        deny: z.ZodNumber;
+    }, z.core.$strict>;
+    changes: z.ZodArray<z.ZodObject<{
+        scenarioId: z.ZodString;
+        agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+        action: z.core.$ZodBranded<z.ZodString, "ActionType", "out">;
+        previousVerdict: z.ZodEnum<{
+            ALLOW: "ALLOW";
+            ASK: "ASK";
+            DENY: "DENY";
+        }>;
+        proposedVerdict: z.ZodEnum<{
+            ALLOW: "ALLOW";
+            ASK: "ASK";
+            DENY: "DENY";
+        }>;
+    }, z.core.$strict>>;
+    newlyAllowedActionClasses: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>;
+    newlyDeniedActionClasses: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>;
+    newlyAskedActionClasses: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>;
+}, z.core.$strict>;
+export type AuthorityDiff = z.infer<typeof AuthorityDiffSchema>;
+/**
+ * Matches baseline and proposed outcomes by scenarioId; a scenario absent
+ * from either side diffs against DENY-by-absence only for its own side —
+ * scenarios present on one side only still appear in `changes` when the
+ * present side's verdict differs from the other's.
+ */
+export declare function diffAuthorityOutcomes(previous: readonly SimulationOutcome[], proposed: readonly SimulationOutcome[]): AuthorityDiff;
+/** Action classes treated as protected-data exposure in §50 reporting. */
+export declare function isProtectedDataActionClass(action: string): boolean;
+export declare const BlastRadiusSchema: z.ZodObject<{
+    agentsAffected: z.ZodArray<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>;
+    resourcesAffected: z.ZodArray<z.ZodString>;
+    newActionClasses: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>;
+    newCounterparties: z.ZodArray<z.ZodString>;
+    additionalMoneyExposureCents: z.ZodNumber;
+    additionalProtectedDataExposure: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>;
+    delegationExpansion: z.ZodObject<{
+        addedDelegableGrantIds: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>;
+    }, z.core.$strict>;
+    runtimeExpansion: z.ZodObject<{
+        widenedGrantIds: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>;
+        addedGrantIds: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>;
+        addedCoverageEpochMs: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type BlastRadius = z.infer<typeof BlastRadiusSchema>;
+/**
+ * §50 blast radius, computed deterministically from the two outcome sets,
+ * the scenario inputs and the declared candidate. `nowEpochMs` bounds the
+ * coverage arithmetic for added grants without a notBefore.
+ */
+export declare function computeBlastRadius(input: {
+    baselineScenarios: readonly PolicyScenario[];
+    baselineOutcomes: readonly SimulationOutcome[];
+    proposedOutcomes: readonly SimulationOutcome[];
+    candidate: PolicyCandidate;
+    nowEpochMs: number;
+}): BlastRadius;
+export declare const SimulationRunIdSchema: z.ZodString;
+export type SimulationRunId = z.infer<typeof SimulationRunIdSchema>;
+/**
+ * The digest-bound run record a human reviews before activating policy:
+ * both outcome sets, the §49 diff and the §50 blast radius, bound to the
+ * candidate digest so consequences cannot be detached from the proposal.
+ */
+export declare const PolicySimulationRunSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"guardian.policy_simulation.v1">;
+    runId: z.ZodString;
+    tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+    createdBy: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+    createdAtEpochMs: z.ZodNumber;
+    scenarioDigests: z.ZodArray<z.ZodString>;
+    candidate: z.ZodObject<{
+        policy: z.ZodOptional<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "PolicyId", "out">;
+            version: z.ZodNumber;
+        }, z.core.$strict>>;
+        upsertedGrants: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.core.$ZodBranded<z.ZodString, "GrantId", "out">;
+            tenantId: z.core.$ZodBranded<z.ZodString, "TenantId", "out">;
+            principalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            parentGrantId: z.ZodOptional<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>;
+            issuedBy: z.ZodObject<{
+                type: z.ZodLiteral<"principal">;
+                principalId: z.core.$ZodBranded<z.ZodString, "PrincipalId", "out">;
+            }, z.core.$strict>;
+            status: z.ZodEnum<{
+                active: "active";
+                disabled: "disabled";
+                revoked: "revoked";
+            }>;
+            version: z.ZodNumber;
+            delegable: z.ZodDefault<z.ZodBoolean>;
+            constraints: z.ZodObject<{
+                actions: z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>, z.ZodTransform<(string & z.core.$brand<"ActionType">)[], (string & z.core.$brand<"ActionType">)[]>>;
+                resources: z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "ResourceRef", "out">>, z.ZodTransform<(string & z.core.$brand<"ResourceRef">)[], (string & z.core.$brand<"ResourceRef">)[]>>;
+                adapterIds: z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "AdapterId", "out">>, z.ZodTransform<(string & z.core.$brand<"AdapterId">)[], (string & z.core.$brand<"AdapterId">)[]>>;
+                maxValueCents: z.ZodOptional<z.ZodNumber>;
+                maxUsesPerRequest: z.ZodNumber;
+                notBeforeEpochMs: z.ZodOptional<z.ZodNumber>;
+                expiresAtEpochMs: z.ZodNumber;
+                approvalRequired: z.ZodBoolean;
+                askAboveValueCents: z.ZodOptional<z.ZodNumber>;
+                merchantAllowlist: z.ZodOptional<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
+                categoryAllowlist: z.ZodOptional<z.ZodPipe<z.ZodArray<z.ZodString>, z.ZodTransform<string[], string[]>>>;
+                recurrence: z.ZodOptional<z.ZodEnum<{
+                    never: "never";
+                    allowed: "allowed";
+                }>>;
+                budgetIds: z.ZodOptional<z.ZodPipe<z.ZodArray<z.core.$ZodBranded<z.ZodString, "BudgetId", "out">>, z.ZodTransform<(string & z.core.$brand<"BudgetId">)[], (string & z.core.$brand<"BudgetId">)[]>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>>;
+        removedGrantIds: z.ZodDefault<z.ZodArray<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>>;
+    }, z.core.$strict>;
+    candidateDigest: z.ZodString;
+    baseline: z.ZodObject<{
+        counts: z.ZodObject<{
+            allow: z.ZodNumber;
+            ask: z.ZodNumber;
+            deny: z.ZodNumber;
+        }, z.core.$strict>;
+        outcomes: z.ZodArray<z.ZodObject<{
+            scenarioId: z.ZodString;
+            agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            action: z.core.$ZodBranded<z.ZodString, "ActionType", "out">;
+            resource: z.ZodString;
+            verdict: z.ZodEnum<{
+                ALLOW: "ALLOW";
+                ASK: "ASK";
+                DENY: "DENY";
+            }>;
+            reasonCode: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    proposed: z.ZodObject<{
+        counts: z.ZodObject<{
+            allow: z.ZodNumber;
+            ask: z.ZodNumber;
+            deny: z.ZodNumber;
+        }, z.core.$strict>;
+        outcomes: z.ZodArray<z.ZodObject<{
+            scenarioId: z.ZodString;
+            agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            action: z.core.$ZodBranded<z.ZodString, "ActionType", "out">;
+            resource: z.ZodString;
+            verdict: z.ZodEnum<{
+                ALLOW: "ALLOW";
+                ASK: "ASK";
+                DENY: "DENY";
+            }>;
+            reasonCode: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    diff: z.ZodObject<{
+        verdictDelta: z.ZodObject<{
+            allow: z.ZodNumber;
+            ask: z.ZodNumber;
+            deny: z.ZodNumber;
+        }, z.core.$strict>;
+        changes: z.ZodArray<z.ZodObject<{
+            scenarioId: z.ZodString;
+            agentId: z.core.$ZodBranded<z.ZodString, "AgentId", "out">;
+            action: z.core.$ZodBranded<z.ZodString, "ActionType", "out">;
+            previousVerdict: z.ZodEnum<{
+                ALLOW: "ALLOW";
+                ASK: "ASK";
+                DENY: "DENY";
+            }>;
+            proposedVerdict: z.ZodEnum<{
+                ALLOW: "ALLOW";
+                ASK: "ASK";
+                DENY: "DENY";
+            }>;
+        }, z.core.$strict>>;
+        newlyAllowedActionClasses: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>;
+        newlyDeniedActionClasses: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>;
+        newlyAskedActionClasses: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>;
+    }, z.core.$strict>;
+    blastRadius: z.ZodObject<{
+        agentsAffected: z.ZodArray<z.core.$ZodBranded<z.ZodString, "AgentId", "out">>;
+        resourcesAffected: z.ZodArray<z.ZodString>;
+        newActionClasses: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>;
+        newCounterparties: z.ZodArray<z.ZodString>;
+        additionalMoneyExposureCents: z.ZodNumber;
+        additionalProtectedDataExposure: z.ZodArray<z.core.$ZodBranded<z.ZodString, "ActionType", "out">>;
+        delegationExpansion: z.ZodObject<{
+            addedDelegableGrantIds: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>;
+        }, z.core.$strict>;
+        runtimeExpansion: z.ZodObject<{
+            widenedGrantIds: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>;
+            addedGrantIds: z.ZodArray<z.core.$ZodBranded<z.ZodString, "GrantId", "out">>;
+            addedCoverageEpochMs: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    runDigest: z.ZodString;
+}, z.core.$strict>;
+export type PolicySimulationRun = z.infer<typeof PolicySimulationRunSchema>;
+export declare function policySimulationRunDigest(run: Omit<PolicySimulationRun, "runDigest">): string;
+export declare function policyCandidateDigest(candidate: PolicyCandidate): string;
+export declare function policyScenarioDigest(scenario: PolicyScenario): string;