@tangle-network/agent-interface 0.37.0 → 0.39.0

package/dist/agent-candidate-receipt-schema.d.ts

@@ -191,11 +191,10 @@ export declare const agentCandidateMaterializationReceiptSchema: z.ZodObject<{
         }, z.core.$strict>;
     }, z.core.$strict>;
     profileActivation: z.ZodObject<{
-        kind: z.ZodLiteral<"agent-candidate-profile-activation">;
-        profilePlan: z.ZodObject<{
-            kind: z.ZodLiteral<"agent-profile-workspace-plan">;
-            digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-            material: z.ZodType<{
+        profilePlan: z.ZodType<{
+            kind: "agent-profile-workspace-plan";
+            digest: `sha256:${string}`;
+            material: {
                 sourceProfileDigest: `sha256:${string}`;
                 harness: "claude-code" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
                 files: {
@@ -219,7 +218,30 @@ export declare const agentCandidateMaterializationReceiptSchema: z.ZodObject<{
                     kind: "public";
                     value: string;
                 } | undefined;
-            }, unknown, z.core.$ZodTypeInternals<{
+            };
+            artifact: {
+                locator: {
+                    kind: "s3";
+                    bucket: string;
+                    key: string;
+                    region?: string | undefined;
+                } | {
+                    kind: "ipfs";
+                    cid: string;
+                    path?: string | undefined;
+                };
+                sha256: `sha256:${string}`;
+                byteLength: number;
+            } | {
+                encoding: "base64";
+                content: string;
+                sha256: `sha256:${string}`;
+                byteLength: number;
+            };
+        }, unknown, z.core.$ZodTypeInternals<{
+            kind: "agent-profile-workspace-plan";
+            digest: `sha256:${string}`;
+            material: {
                 sourceProfileDigest: `sha256:${string}`;
                 harness: "claude-code" | "nanoclaw" | "codex" | "opencode" | "kimi-code" | "pi" | "gemini" | "hermes" | "openclaw" | "amp" | "factory-droids" | "acp" | "cli-base";
                 files: {
@@ -243,33 +265,34 @@ export declare const agentCandidateMaterializationReceiptSchema: z.ZodObject<{
                     kind: "public";
                     value: string;
                 } | undefined;
-            }, unknown>>;
-            artifact: z.ZodUnion<readonly [z.ZodObject<{
-                locator: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"s3">;
-                    bucket: z.ZodString;
-                    key: z.ZodString;
-                    region: z.ZodOptional<z.ZodString>;
-                }, z.core.$strict>, z.ZodObject<{
-                    kind: z.ZodLiteral<"ipfs">;
-                    cid: z.ZodString;
-                    path: z.ZodOptional<z.ZodString>;
-                }, z.core.$strict>], "kind">;
-                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-                byteLength: z.ZodNumber;
-            }, z.core.$strict>, z.ZodObject<{
-                encoding: z.ZodLiteral<"base64">;
-                content: z.ZodString;
-                sha256: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
-                byteLength: z.ZodNumber;
-            }, z.core.$strict>]>;
-        }, z.core.$strict>;
+            };
+            artifact: {
+                locator: {
+                    kind: "s3";
+                    bucket: string;
+                    key: string;
+                    region?: string | undefined;
+                } | {
+                    kind: "ipfs";
+                    cid: string;
+                    path?: string | undefined;
+                };
+                sha256: `sha256:${string}`;
+                byteLength: number;
+            } | {
+                encoding: "base64";
+                content: string;
+                sha256: `sha256:${string}`;
+                byteLength: number;
+            };
+        }, unknown>>;
         files: z.ZodArray<z.ZodObject<{
             path: z.ZodString;
             mode: z.ZodNumber;
             content: z.ZodString;
         }, z.core.$strict>>;
         digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        kind: z.ZodLiteral<"agent-candidate-profile-activation">;
     }, z.core.$strict>;
     executionPlan: z.ZodObject<{
         kind: z.ZodLiteral<"agent-candidate-execution-plan">;

package/dist/agent-candidate-schema.d.ts

@@ -52,25 +52,13 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
             allow: "allow";
             ask: "ask";
             deny: "deny";
-        }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
-            allow: "allow";
-            ask: "ask";
-            deny: "deny";
-        }>>]>>>;
+        }>, z.ZodType<Record<string, "allow" | "ask" | "deny">, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny">, unknown>>]>>>;
         tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
         mcp: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./agent-candidate.js").AgentCandidateMcpServer, unknown, z.core.$ZodTypeInternals<import("./agent-candidate.js").AgentCandidateMcpServer, unknown>>>>;
         subagents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             prompt: z.ZodOptional<z.ZodString>;
-            permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
-                allow: "allow";
-                ask: "ask";
-                deny: "deny";
-            }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
-                allow: "allow";
-                ask: "ask";
-                deny: "deny";
-            }>>]>>>;
-            tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+            permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
+            tools: z.ZodOptional<z.ZodType<Record<string, boolean>, unknown, z.core.$ZodTypeInternals<Record<string, boolean>, unknown>>>;
             description: z.ZodOptional<z.ZodString>;
             model: z.ZodOptional<z.ZodString>;
             maxSteps: z.ZodOptional<z.ZodNumber>;
@@ -548,16 +536,8 @@ export declare const agentCandidateBundleSchema: z.ZodObject<{
         }, z.core.$strict>>>>;
         modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             prompt: z.ZodOptional<z.ZodString>;
-            permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
-                allow: "allow";
-                ask: "ask";
-                deny: "deny";
-            }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
-                allow: "allow";
-                ask: "ask";
-                deny: "deny";
-            }>>]>>>;
-            tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+            permissions: z.ZodOptional<z.ZodType<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown, z.core.$ZodTypeInternals<Record<string, "allow" | "ask" | "deny" | Record<string, "allow" | "ask" | "deny">>, unknown>>>;
+            tools: z.ZodOptional<z.ZodType<Record<string, boolean>, unknown, z.core.$ZodTypeInternals<Record<string, boolean>, unknown>>>;
             description: z.ZodOptional<z.ZodString>;
             model: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;

package/dist/agent-candidate.d.ts

@@ -1,4 +1,5 @@
 import type { AgentProfile, AgentProfileFileMount, AgentProfileHookCommand, AgentProfileMode, AgentProfileModelHints, AgentProfileResources, AgentSubagentProfile, ReasoningEffort } from "./agent-profile.js";
+import type { AgentProfileActivationEvidence } from "./agent-profile-activation.js";
 import type { HarnessType } from "./harness.js";
 import type { AgentProfileImprovementExecutionRef, AgentProfileImprovementMeasuredComparison } from "./agent-profile-improvement.js";
 import type { AgentImprovementSource } from "./agent-improvement-source.js";
@@ -599,15 +600,8 @@ export interface AgentCandidateProfilePlanEvidence {
     artifact: AgentCandidateCapturedArtifact;
 }
 /** Exact native profile files and the canonical plan that activated them. */
-export interface AgentCandidateProfileActivation {
+export interface AgentCandidateProfileActivation extends AgentProfileActivationEvidence<AgentCandidateProfilePlanEvidence> {
     kind: "agent-candidate-profile-activation";
-    profilePlan: AgentCandidateProfilePlanEvidence;
-    files: Array<{
-        path: string;
-        mode: number;
-        content: string;
-    }>;
-    digest: Sha256Digest;
 }
 export interface AgentCandidateExecutionPlanEvidence {
     kind: "agent-candidate-execution-plan";

package/dist/agent-execution-preparation.d.ts

@@ -0,0 +1,366 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+import { type AgentProfile, type ReasoningEffort } from "./agent-profile.js";
+import type { AgentProfileActivationEvidence } from "./agent-profile-activation.js";
+import { type AgentProfileMaterializationAxis } from "./agent-profile-materialization.js";
+import { type HarnessType } from "./harness.js";
+import { type AgentWorkspaceExecutionBoundLeaseRecord, type AgentWorkspaceSealedLeaseRecord, type AgentWorkspaceSourceSnapshotPolicy } from "./agent-workspace-lease.js";
+export type AgentExecutionPreparationDisposition = "behavior" | "control" | "overridden" | "unsupported";
+export type AgentExecutionPreparationOwner = "runtime" | "executor";
+/** One exact profile path and how the prepared execution will handle it. */
+export interface AgentExecutionPreparationAxisResult {
+    axis: AgentProfileMaterializationAxis;
+    disposition: AgentExecutionPreparationDisposition;
+    owner: AgentExecutionPreparationOwner;
+    /** Public mechanism identifier; launch arguments are structurally refused. */
+    mechanism: string;
+    evidenceDigest?: Sha256Digest;
+    /** RFC 6901 JSON Pointer. Required when one axis has multiple requested paths. */
+    path?: string;
+    /**
+     * Sanitized public diagnostic prose for an override or unsupported path.
+     * The schema refuses recognized credential formats, but cannot identify
+     * arbitrary secret strings; producers remain responsible for redaction.
+     */
+    reason?: string;
+}
+export interface AgentExecutionPreparationReasoningEffort {
+    requested: ReasoningEffort;
+    resolved?: ReasoningEffort;
+    fidelity: "exact" | "clamped" | "unsupported";
+}
+export interface AgentExecutionPreparationResolvedModel {
+    /** Exact effective profile request; an explicit empty hint remains empty. */
+    requested: string;
+    /** Concrete non-empty model selected for execution. */
+    resolved: string;
+    /** Exact effective provider hint when present, including an explicit empty hint. */
+    provider?: string;
+    reasoningEffort?: AgentExecutionPreparationReasoningEffort;
+}
+export interface AgentExecutionPreparationWorkspace {
+    /** Public, non-secret lifecycle identity for the workspace lease. */
+    leaseId: string;
+    /** Provider that owns the private prepared workspace capability. */
+    provider: string;
+    /**
+     * Digest of the immutable allocation tuple (provider, lease/allocation id,
+     * and canonical root). This binds `leaseId` to its allocation; it is not a
+     * filesystem-content digest.
+     */
+    identityDigest: Sha256Digest;
+    isolation: "per-run" | "shared";
+    /** Canonical source snapshot before the isolated copy is prepared. */
+    sourceSnapshotDigest: Sha256Digest;
+    /** Public identity of the provider's exact snapshot/canonicalization policy. */
+    sourceSnapshotPolicy: AgentWorkspaceSourceSnapshotPolicy;
+    /** Canonical actual workspace after profile activation and before compute. */
+    preparedWorkspaceDigest: Sha256Digest;
+    profileActivationDigest: Sha256Digest;
+}
+export interface AgentExecutionPreparationMaterializer {
+    name: string;
+    version: string;
+}
+/**
+ * Executor acknowledgement emitted after all launch decisions are fixed and
+ * before any agent compute begins.
+ *
+ * `executionPlanDigest` is required to hash only public launch decisions plus
+ * caller-declared public secret-slot/reference identities. Secret values belong
+ * solely in the private prepared-executor closure/capability; hashing them here
+ * would leak equality and permit guessing low-entropy credentials. This receipt
+ * proves public plan identity, not possession of that private capability.
+ * Secret-capable MCP/hook slots structurally accept only tagged public values or
+ * opaque references. Other authored profile text and reference keys remain
+ * caller-declared public data; recognizable-pattern refusal is defense in depth,
+ * not proof that arbitrary text is non-secret.
+ */
+export interface AgentExecutionPreparationReceipt {
+    kind: "agent-execution-preparation";
+    schemaVersion: 1;
+    preparationId: string;
+    requestDigest: Sha256Digest;
+    authoredProfileDigest: Sha256Digest;
+    effectiveProfileDigest: Sha256Digest;
+    backend: string;
+    harness: HarnessType;
+    harnessVersion: string;
+    resolvedModel: AgentExecutionPreparationResolvedModel;
+    workspace: AgentExecutionPreparationWorkspace;
+    axisResults: AgentExecutionPreparationAxisResult[];
+    /** Caller-supplied digest of public decisions and secret-reference identities. */
+    executionPlanDigest: Sha256Digest;
+    materializer: AgentExecutionPreparationMaterializer;
+    expiresAtMs: number;
+    digest: Sha256Digest;
+}
+export interface BuildAgentExecutionPreparationReceiptInput {
+    preparationId: string;
+    requestDigest: Sha256Digest;
+    authoredProfile: AgentProfile;
+    effectiveProfile: AgentProfile;
+    backend: string;
+    harness: HarnessType;
+    harnessVersion: string;
+    resolvedModel: AgentExecutionPreparationResolvedModel;
+    /** Exact sealed public lease projection; owner authorization remains private. */
+    workspaceLease: AgentWorkspaceSealedLeaseRecord;
+    profileActivation: Pick<AgentProfileActivationEvidence, "digest">;
+    axisResults: readonly AgentExecutionPreparationAxisResult[];
+    /** Must digest public decisions and reference identities, not resolved values. */
+    executionPlanDigest: Sha256Digest;
+    materializer: AgentExecutionPreparationMaterializer;
+    expiresAtMs: number;
+    /** Clock used only to refuse already-expired preparations. */
+    nowMs?: number;
+}
+export interface ValidateAgentExecutionPreparationReceiptOptions {
+    receipt: unknown;
+    requestDigest: Sha256Digest;
+    authoredProfile: AgentProfile;
+    effectiveProfile: AgentProfile;
+    /** Expected public-plan identity; callers must not derive it from secret values. */
+    executionPlanDigest: Sha256Digest;
+    profileActivation: Pick<AgentProfileActivationEvidence, "digest">;
+    /** Bound lease closes the receipt→workspace link before compute begins. */
+    workspaceLease: AgentWorkspaceExecutionBoundLeaseRecord;
+    nowMs?: number;
+    preparationId?: string;
+    backend?: string;
+    harness?: HarnessType;
+    harnessVersion?: string;
+}
+export type AgentExecutionPreparationValidationIssueCode = "invalid-receipt" | "invalid-profile" | "invalid-workspace-lease" | "workspace-not-execution-bound" | "execution-binding-mismatch" | "digest-mismatch" | "expectation-mismatch" | "expired" | "missing-coverage" | "ambiguous-coverage" | "duplicate-coverage" | "conflicting-coverage" | "unrequested-coverage" | "invalid-disposition" | "strict-unsupported" | "model-fidelity";
+export interface AgentExecutionPreparationValidationIssue {
+    code: AgentExecutionPreparationValidationIssueCode;
+    message: string;
+    axis?: AgentProfileMaterializationAxis;
+    path?: string;
+}
+export type AgentExecutionPreparationValidationResult = {
+    ok: true;
+    receipt: AgentExecutionPreparationReceipt;
+    issues: [];
+} | {
+    ok: false;
+    issues: AgentExecutionPreparationValidationIssue[];
+};
+export declare const agentExecutionPreparationAxisResultSchema: z.ZodObject<{
+    axis: z.ZodEnum<{
+        permissions: "permissions";
+        tools: "tools";
+        mcp: "mcp";
+        connections: "connections";
+        subagents: "subagents";
+        hooks: "hooks";
+        modes: "modes";
+        metadata: "metadata";
+        description: "description";
+        name: "name";
+        files: "files";
+        version: "version";
+        tags: "tags";
+        harness: "harness";
+        confidential: "confidential";
+        extensions: "extensions";
+        skills: "skills";
+        commands: "commands";
+        instructions: "instructions";
+        systemPrompt: "systemPrompt";
+        modelDefault: "modelDefault";
+        modelSmall: "modelSmall";
+        modelProvider: "modelProvider";
+        modelReasoningEffort: "modelReasoningEffort";
+        modelMetadata: "modelMetadata";
+        resourceTools: "resourceTools";
+        resourceAgents: "resourceAgents";
+        resourceInstructions: "resourceInstructions";
+        resourceFailOnError: "resourceFailOnError";
+    }>;
+    disposition: z.ZodEnum<{
+        unsupported: "unsupported";
+        behavior: "behavior";
+        control: "control";
+        overridden: "overridden";
+    }>;
+    owner: z.ZodEnum<{
+        runtime: "runtime";
+        executor: "executor";
+    }>;
+    mechanism: z.ZodString;
+    evidenceDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
+    path: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const agentExecutionPreparationReasoningEffortSchema: z.ZodObject<{
+    requested: z.ZodEnum<{
+        none: "none";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        ultracode: "ultracode";
+    }>;
+    resolved: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        minimal: "minimal";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        ultracode: "ultracode";
+    }>>;
+    fidelity: z.ZodEnum<{
+        exact: "exact";
+        unsupported: "unsupported";
+        clamped: "clamped";
+    }>;
+}, z.core.$strict>;
+export declare const agentExecutionPreparationReceiptSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"agent-execution-preparation">;
+    schemaVersion: z.ZodLiteral<1>;
+    preparationId: z.ZodString;
+    requestDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    authoredProfileDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    effectiveProfileDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    backend: z.ZodString;
+    harness: z.ZodEnum<{
+        "claude-code": "claude-code";
+        nanoclaw: "nanoclaw";
+        codex: "codex";
+        opencode: "opencode";
+        "kimi-code": "kimi-code";
+        pi: "pi";
+        gemini: "gemini";
+        hermes: "hermes";
+        openclaw: "openclaw";
+        amp: "amp";
+        "factory-droids": "factory-droids";
+        acp: "acp";
+        "cli-base": "cli-base";
+    }>;
+    harnessVersion: z.ZodString;
+    resolvedModel: z.ZodObject<{
+        requested: z.ZodString;
+        resolved: z.ZodString;
+        provider: z.ZodOptional<z.ZodString>;
+        reasoningEffort: z.ZodOptional<z.ZodObject<{
+            requested: z.ZodEnum<{
+                none: "none";
+                minimal: "minimal";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                ultracode: "ultracode";
+            }>;
+            resolved: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                minimal: "minimal";
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                ultracode: "ultracode";
+            }>>;
+            fidelity: z.ZodEnum<{
+                exact: "exact";
+                unsupported: "unsupported";
+                clamped: "clamped";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    workspace: z.ZodObject<{
+        leaseId: z.ZodString;
+        provider: z.ZodString;
+        identityDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        isolation: z.ZodEnum<{
+            "per-run": "per-run";
+            shared: "shared";
+        }>;
+        sourceSnapshotDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        sourceSnapshotPolicy: z.ZodObject<{
+            kind: z.ZodLiteral<"provider-declared">;
+            name: z.ZodString;
+            version: z.ZodNumber;
+            digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        }, z.core.$strict>;
+        preparedWorkspaceDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+        profileActivationDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    }, z.core.$strict>;
+    axisResults: z.ZodArray<z.ZodObject<{
+        axis: z.ZodEnum<{
+            permissions: "permissions";
+            tools: "tools";
+            mcp: "mcp";
+            connections: "connections";
+            subagents: "subagents";
+            hooks: "hooks";
+            modes: "modes";
+            metadata: "metadata";
+            description: "description";
+            name: "name";
+            files: "files";
+            version: "version";
+            tags: "tags";
+            harness: "harness";
+            confidential: "confidential";
+            extensions: "extensions";
+            skills: "skills";
+            commands: "commands";
+            instructions: "instructions";
+            systemPrompt: "systemPrompt";
+            modelDefault: "modelDefault";
+            modelSmall: "modelSmall";
+            modelProvider: "modelProvider";
+            modelReasoningEffort: "modelReasoningEffort";
+            modelMetadata: "modelMetadata";
+            resourceTools: "resourceTools";
+            resourceAgents: "resourceAgents";
+            resourceInstructions: "resourceInstructions";
+            resourceFailOnError: "resourceFailOnError";
+        }>;
+        disposition: z.ZodEnum<{
+            unsupported: "unsupported";
+            behavior: "behavior";
+            control: "control";
+            overridden: "overridden";
+        }>;
+        owner: z.ZodEnum<{
+            runtime: "runtime";
+            executor: "executor";
+        }>;
+        mechanism: z.ZodString;
+        evidenceDigest: z.ZodOptional<z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>>;
+        path: z.ZodOptional<z.ZodString>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    executionPlanDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+    materializer: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    expiresAtMs: z.ZodNumber;
+    digest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
+/**
+ * Canonical RFC 8785/SHA-256 identity for one validated, public AgentProfile.
+ * Secret-capable MCP/hook fields are tagged. Other prompt, resource, metadata,
+ * and tool text is ordinary public profile data: it may legitimately discuss
+ * credentials, security incidents, or examples that resemble credentials, so
+ * pattern matching cannot decide whether it is secret. Resolve opaque secret
+ * references only after this public identity is fixed.
+ */
+export declare function canonicalAgentProfileDigest(profile: AgentProfile): Sha256Digest;
+/** Build, self-hash, and cross-check one pre-compute executor acknowledgement. */
+export declare function buildAgentExecutionPreparationReceipt(input: BuildAgentExecutionPreparationReceiptInput): AgentExecutionPreparationReceipt;
+/** Validate structure, bindings, expiry, model fidelity, and exact path coverage. */
+export declare function validateAgentExecutionPreparationReceipt(options: ValidateAgentExecutionPreparationReceiptOptions): AgentExecutionPreparationValidationResult;
+/** Throw one structured error when a preparation acknowledgement is invalid. */
+export declare function assertAgentExecutionPreparationReceipt(options: ValidateAgentExecutionPreparationReceiptOptions): AgentExecutionPreparationReceipt;
+export declare class AgentExecutionPreparationValidationError extends Error {
+    readonly issues: readonly AgentExecutionPreparationValidationIssue[];
+    constructor(issues: readonly AgentExecutionPreparationValidationIssue[]);
+}