@tangle-network/agent-interface 0.37.0 → 0.38.0

package/dist/agent-profile-activation.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+/** One exact native file applied before an agent process starts. */
+export interface AgentProfileActivationFileEvidence {
+    path: string;
+    mode: number;
+    content: string;
+}
+/**
+ * Shared evidence carried by every exact profile activation.
+ *
+ * The plan type remains owned by the producer because ordinary agent runs and
+ * sealed benchmark runs have different plan contracts. The applied file bytes
+ * and activation identity are shared so those producers cannot invent
+ * competing activation evidence.
+ */
+export interface AgentProfileActivationEvidence<TProfilePlan = unknown> {
+    profilePlan: TProfilePlan;
+    files: AgentProfileActivationFileEvidence[];
+    digest: Sha256Digest;
+}
+/** Runtime validator for one exact native profile file. */
+export declare const agentProfileActivationFileEvidenceSchema: z.ZodObject<{
+    path: z.ZodString;
+    mode: z.ZodNumber;
+    content: z.ZodString;
+}, z.core.$strict>;
+/**
+ * Compose the shared activation evidence with a producer-owned exact plan.
+ * Candidate materialization uses this factory and adds its stronger plan/file
+ * consistency checks around the resulting schema.
+ */
+export declare function createAgentProfileActivationEvidenceSchema<TProfilePlan>(profilePlanSchema: z.ZodType<TProfilePlan>): z.ZodObject<{
+    profilePlan: z.ZodType<TProfilePlan, unknown, z.core.$ZodTypeInternals<TProfilePlan, 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>>;
+}, z.core.$strict>;

package/dist/agent-profile-activation.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { isSafeRelativePath, isWellFormedUnicode, sha256DigestSchema, } from "./agent-candidate-schema-common.js";
+/** Runtime validator for one exact native profile file. */
+export const agentProfileActivationFileEvidenceSchema = z.strictObject({
+    path: z
+        .string()
+        .refine((value) => isSafeRelativePath(value, false), "profile activation file must use a canonical relative path"),
+    mode: z.number().int().min(0).max(0o777),
+    content: z
+        .string()
+        .refine(isWellFormedUnicode, "profile activation content must be valid Unicode"),
+});
+/**
+ * Compose the shared activation evidence with a producer-owned exact plan.
+ * Candidate materialization uses this factory and adds its stronger plan/file
+ * consistency checks around the resulting schema.
+ */
+export function createAgentProfileActivationEvidenceSchema(profilePlanSchema) {
+    return z.strictObject({
+        profilePlan: profilePlanSchema,
+        files: z.array(agentProfileActivationFileEvidenceSchema),
+        digest: sha256DigestSchema,
+    });
+}

package/dist/agent-profile-materialization.d.ts

@@ -0,0 +1,34 @@
+import type { AgentProfile } from "./agent-profile.js";
+/**
+ * The 29 canonical AgentProfile leaves that can affect one execution.
+ *
+ * Compound parents such as `model`, `prompt`, and `resources` are deliberately
+ * absent. A producer must report the exact requested leaf instead of claiming
+ * a parent while silently dropping one of its children.
+ */
+export declare const AGENT_PROFILE_MATERIALIZATION_AXES: readonly ["name", "description", "version", "tags", "systemPrompt", "instructions", "modelDefault", "modelSmall", "modelProvider", "modelReasoningEffort", "modelMetadata", "harness", "permissions", "tools", "mcp", "connections", "subagents", "files", "resourceTools", "skills", "resourceAgents", "commands", "resourceInstructions", "resourceFailOnError", "hooks", "modes", "confidential", "metadata", "extensions"];
+/** One exact leaf of the public AgentProfile contract. */
+export type AgentProfileMaterializationAxis = (typeof AGENT_PROFILE_MATERIALIZATION_AXES)[number];
+/** Compatibility name used by runtimes that distinguish canonical axes. */
+export type CanonicalAgentProfileMaterializationAxis = AgentProfileMaterializationAxis;
+/** One requested profile leaf and its canonical RFC 6901 JSON Pointer. */
+export interface AgentProfileMaterializationRequest {
+    axis: AgentProfileMaterializationAxis;
+    path: string;
+}
+/**
+ * Return every canonical profile leaf that contains a meaningful request.
+ * Every explicit value is a request, including empty strings, empty
+ * collections, `null`, `false`, and `0`. Only an absent/undefined leaf is
+ * omitted.
+ */
+export declare function profileMaterializationAxes(profile: AgentProfile): readonly AgentProfileMaterializationAxis[];
+/**
+ * Expand requested axes into exact JSON Pointer paths.
+ *
+ * Compound maps and arrays produce one row per explicit scalar leaf. An empty
+ * compound value produces its axis-root path. This prevents an executor from
+ * acknowledging one tool, server, resource, or instruction while claiming the
+ * whole axis, without losing an explicit request to clear that axis.
+ */
+export declare function profileMaterializationRequests(profile: AgentProfile): readonly AgentProfileMaterializationRequest[];

package/dist/agent-profile-materialization.js

@@ -0,0 +1,243 @@
+/**
+ * The 29 canonical AgentProfile leaves that can affect one execution.
+ *
+ * Compound parents such as `model`, `prompt`, and `resources` are deliberately
+ * absent. A producer must report the exact requested leaf instead of claiming
+ * a parent while silently dropping one of its children.
+ */
+export const AGENT_PROFILE_MATERIALIZATION_AXES = [
+    "name",
+    "description",
+    "version",
+    "tags",
+    "systemPrompt",
+    "instructions",
+    "modelDefault",
+    "modelSmall",
+    "modelProvider",
+    "modelReasoningEffort",
+    "modelMetadata",
+    "harness",
+    "permissions",
+    "tools",
+    "mcp",
+    "connections",
+    "subagents",
+    "files",
+    "resourceTools",
+    "skills",
+    "resourceAgents",
+    "commands",
+    "resourceInstructions",
+    "resourceFailOnError",
+    "hooks",
+    "modes",
+    "confidential",
+    "metadata",
+    "extensions",
+];
+const profileProperties = [
+    "prompt",
+    "model",
+    "harness",
+    "permissions",
+    "tools",
+    "mcp",
+    "connections",
+    "subagents",
+    "resources",
+    "hooks",
+    "modes",
+    "confidential",
+    "metadata",
+    "extensions",
+];
+const profilePropertiesAreExhaustive = true;
+void profilePropertiesAreExhaustive;
+const AXIS_DESCRIPTORS = [
+    { axis: "name", rootPath: "/name", value: (profile) => profile.name },
+    {
+        axis: "description",
+        rootPath: "/description",
+        value: (profile) => profile.description,
+    },
+    { axis: "version", rootPath: "/version", value: (profile) => profile.version },
+    { axis: "tags", rootPath: "/tags", value: (profile) => profile.tags },
+    {
+        axis: "systemPrompt",
+        rootPath: "/prompt/systemPrompt",
+        value: (profile) => profile.prompt?.systemPrompt,
+    },
+    {
+        axis: "instructions",
+        rootPath: "/prompt/instructions",
+        value: (profile) => profile.prompt?.instructions,
+    },
+    {
+        axis: "modelDefault",
+        rootPath: "/model/default",
+        value: (profile) => profile.model?.default,
+    },
+    {
+        axis: "modelSmall",
+        rootPath: "/model/small",
+        value: (profile) => profile.model?.small,
+    },
+    {
+        axis: "modelProvider",
+        rootPath: "/model/provider",
+        value: (profile) => profile.model?.provider,
+    },
+    {
+        axis: "modelReasoningEffort",
+        rootPath: "/model/reasoningEffort",
+        value: (profile) => profile.model?.reasoningEffort,
+    },
+    {
+        axis: "modelMetadata",
+        rootPath: "/model/metadata",
+        value: (profile) => profile.model?.metadata,
+    },
+    { axis: "harness", rootPath: "/harness", value: (profile) => profile.harness },
+    {
+        axis: "permissions",
+        rootPath: "/permissions",
+        value: (profile) => profile.permissions,
+    },
+    { axis: "tools", rootPath: "/tools", value: (profile) => profile.tools },
+    { axis: "mcp", rootPath: "/mcp", value: (profile) => profile.mcp },
+    {
+        axis: "connections",
+        rootPath: "/connections",
+        value: (profile) => profile.connections,
+    },
+    {
+        axis: "subagents",
+        rootPath: "/subagents",
+        value: (profile) => profile.subagents,
+    },
+    {
+        axis: "files",
+        rootPath: "/resources/files",
+        value: (profile) => profile.resources?.files,
+    },
+    {
+        axis: "resourceTools",
+        rootPath: "/resources/tools",
+        value: (profile) => profile.resources?.tools,
+    },
+    {
+        axis: "skills",
+        rootPath: "/resources/skills",
+        value: (profile) => profile.resources?.skills,
+    },
+    {
+        axis: "resourceAgents",
+        rootPath: "/resources/agents",
+        value: (profile) => profile.resources?.agents,
+    },
+    {
+        axis: "commands",
+        rootPath: "/resources/commands",
+        value: (profile) => profile.resources?.commands,
+    },
+    {
+        axis: "resourceInstructions",
+        rootPath: "/resources/instructions",
+        value: (profile) => profile.resources?.instructions,
+    },
+    {
+        axis: "resourceFailOnError",
+        rootPath: "/resources/failOnError",
+        value: (profile) => profile.resources?.failOnError,
+    },
+    { axis: "hooks", rootPath: "/hooks", value: (profile) => profile.hooks },
+    { axis: "modes", rootPath: "/modes", value: (profile) => profile.modes },
+    {
+        axis: "confidential",
+        rootPath: "/confidential",
+        value: (profile) => profile.confidential,
+    },
+    {
+        axis: "metadata",
+        rootPath: "/metadata",
+        value: (profile) => profile.metadata,
+    },
+    {
+        axis: "extensions",
+        rootPath: "/extensions",
+        value: (profile) => profile.extensions,
+    },
+];
+const axisDescriptorsAreExhaustive = true;
+void axisDescriptorsAreExhaustive;
+/**
+ * Return every canonical profile leaf that contains a meaningful request.
+ * Every explicit value is a request, including empty strings, empty
+ * collections, `null`, `false`, and `0`. Only an absent/undefined leaf is
+ * omitted.
+ */
+export function profileMaterializationAxes(profile) {
+    const axes = [];
+    for (const descriptor of AXIS_DESCRIPTORS) {
+        if (descriptor.value(profile) !== undefined) {
+            axes.push(descriptor.axis);
+        }
+    }
+    return axes;
+}
+/**
+ * Expand requested axes into exact JSON Pointer paths.
+ *
+ * Compound maps and arrays produce one row per explicit scalar leaf. An empty
+ * compound value produces its axis-root path. This prevents an executor from
+ * acknowledging one tool, server, resource, or instruction while claiming the
+ * whole axis, without losing an explicit request to clear that axis.
+ */
+export function profileMaterializationRequests(profile) {
+    const requests = [];
+    for (const descriptor of AXIS_DESCRIPTORS) {
+        const paths = materializationValuePaths(descriptor.value(profile), descriptor.rootPath);
+        for (const path of paths) {
+            requests.push({ axis: descriptor.axis, path });
+        }
+    }
+    return requests;
+}
+function materializationValuePaths(root, rootPath) {
+    const paths = [];
+    visitMaterializationValue(root, rootPath, [], paths);
+    return paths;
+}
+function visitMaterializationValue(value, path, ancestors, paths) {
+    if (value === undefined)
+        return false;
+    if (value === null || typeof value !== "object") {
+        paths.push(path);
+        return true;
+    }
+    if (ancestors.includes(value)) {
+        paths.push(path);
+        return true;
+    }
+    const nextAncestors = [...ancestors, value];
+    const entries = Array.isArray(value)
+        ? Array.from({ length: value.length }, (_, index) => [
+            String(index),
+            Object.prototype.hasOwnProperty.call(value, index)
+                ? value[index]
+                : undefined,
+        ])
+        : Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+    let childRequested = false;
+    for (const [key, child] of entries) {
+        childRequested =
+            visitMaterializationValue(child, `${path}/${escapeJsonPointerSegment(key)}`, nextAncestors, paths) || childRequested;
+    }
+    if (!childRequested)
+        paths.push(path);
+    return true;
+}
+function escapeJsonPointerSegment(value) {
+    return value.replace(/~/g, "~0").replace(/\//g, "~1");
+}

package/dist/agent-profile.d.ts

@@ -3,8 +3,13 @@
  *
  * These model portable agent intent at the application boundary. Individual
  * backends translate this shape into their own native profile/configuration
- * formats internally. This package is the canonical public home for these
- * symbols.
+ * formats internally. Profile content participates in unsalted public identity.
+ * Prompts, resources, metadata, commands, paths, and secret-reference keys are
+ * caller-declared public data; recognizable credential patterns are refused as
+ * defense in depth, not as proof that arbitrary text is non-secret. MCP and hook
+ * secret-capable fields structurally require tagged public values or opaque
+ * secret references, which a private executor resolves only after identity is
+ * fixed. This package is the canonical public home for these symbols.
  */
 import type { HarnessType } from "./harness.js";
 /**
@@ -96,7 +101,8 @@ export interface AgentProfileResources {
  * A backend without a matching native tier may clamp down to its strongest supported level, but it
  * must never turn reasoning on for `none` or silently increase a requested effort.
  */
-export type ReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "ultracode";
+export declare const REASONING_EFFORTS: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "ultracode"];
+export type ReasoningEffort = (typeof REASONING_EFFORTS)[number];
 /**
  * Model selection hints for backends.
  */
@@ -136,6 +142,37 @@ export interface AgentProfilePrompt {
      */
     instructions?: string[];
 }
+/** Deliberately public configuration included in profile identity. */
+export interface AgentProfilePublicConfigValue {
+    kind: "public";
+    value: string;
+}
+/**
+ * Opaque reference resolved only inside the private prepared executor.
+ * `key` is caller-declared public identity naming provider/operator-owned
+ * secret material; callers must not put the secret value in it.
+ */
+export interface AgentProfileSecretRef {
+    kind: "secret-ref";
+    key: string;
+    /** Apply no decoration or a `Bearer ` prefix after private resolution. */
+    format?: "raw" | "bearer";
+}
+/** A configuration value is public bytes or an opaque secret identity. */
+export type AgentProfileConfigValue = AgentProfilePublicConfigValue | AgentProfileSecretRef;
+/**
+ * Private executor port for resolving one public secret-reference identity.
+ * Implementations return the raw undecorated value. Consumers must fail
+ * preparation on missing or blank values and must keep resolved values out of
+ * profiles, public plans, digests, receipts, diagnostics, and logs.
+ */
+export interface AgentProfileSecretProvider {
+    get(key: string): Promise<string | undefined>;
+}
+/** Mark an exact configuration value as public profile material. */
+export declare function defineAgentProfilePublicConfig(value: string): AgentProfilePublicConfigValue;
+/** Create a secret reference whose key is caller-declared public identity. */
+export declare function defineAgentProfileSecretRef(key: string, format?: AgentProfileSecretRef["format"]): AgentProfileSecretRef;
 /**
  * Generic subagent definition.
  */
@@ -153,7 +190,7 @@ export interface AgentProfileHookCommand {
     timeoutMs?: number;
     blocking?: boolean;
     matcher?: string;
-    env?: Record<string, string>;
+    env?: Record<string, AgentProfileConfigValue>;
 }
 export interface AgentProfileMode {
     description?: string;
@@ -198,8 +235,8 @@ interface AgentProfileLocalMcpServer extends AgentProfileMcpServerBase {
     enabled?: true;
     transport?: "stdio";
     command: string;
-    args?: string[];
-    env?: Record<string, string>;
+    args?: AgentProfileConfigValue[];
+    env?: Record<string, AgentProfileConfigValue>;
     cwd?: string;
     url?: never;
     headers?: never;
@@ -212,7 +249,7 @@ interface AgentProfileRemoteMcpServer extends AgentProfileMcpServerBase {
     env?: never;
     cwd?: never;
     url: string;
-    headers?: Record<string, string>;
+    headers?: Record<string, AgentProfileConfigValue>;
 }
 interface AgentProfileDisabledMcpServer extends AgentProfileMcpServerBase {
     enabled: false;

package/dist/agent-profile.js

@@ -3,8 +3,13 @@
  *
  * These model portable agent intent at the application boundary. Individual
  * backends translate this shape into their own native profile/configuration
- * formats internally. This package is the canonical public home for these
- * symbols.
+ * formats internally. Profile content participates in unsalted public identity.
+ * Prompts, resources, metadata, commands, paths, and secret-reference keys are
+ * caller-declared public data; recognizable credential patterns are refused as
+ * defense in depth, not as proof that arbitrary text is non-secret. MCP and hook
+ * secret-capable fields structurally require tagged public values or opaque
+ * secret references, which a private executor resolves only after identity is
+ * fixed. This package is the canonical public home for these symbols.
  */
 /**
  * Helper for creating typed inline resource refs.
@@ -24,6 +29,38 @@ export function defineGitHubResource(path, options = {}) {
         name: options.name,
     };
 }
+/**
+ * Portable reasoning/thinking effort. Backends map it to their native control at materialization:
+ * codex `model_reasoning_effort`, kimi `--thinking`/`--no-thinking`, claude thinking budget.
+ * Ordered low→high:
+ *   - `none`     — extended thinking OFF (no reasoning budget at all)
+ *   - `minimal`  — thinking ON, the lowest budget (distinct from `none`)
+ *   - `low` / `medium` / `high` / `xhigh`
+ *   - `ultracode` — maximum (Claude Code's `max` and Codex's `ultra` reconcile here).
+ * A backend without a matching native tier may clamp down to its strongest supported level, but it
+ * must never turn reasoning on for `none` or silently increase a requested effort.
+ */
+export const REASONING_EFFORTS = Object.freeze([
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "ultracode",
+]);
+/** Mark an exact configuration value as public profile material. */
+export function defineAgentProfilePublicConfig(value) {
+    return { kind: "public", value };
+}
+/** Create a secret reference whose key is caller-declared public identity. */
+export function defineAgentProfileSecretRef(key, format) {
+    return {
+        kind: "secret-ref",
+        key,
+        ...(format === undefined ? {} : { format }),
+    };
+}
 /**
  * Helper for declaring typed profiles in application code.
  */

package/dist/agent-workspace-lease.d.ts

@@ -0,0 +1,138 @@
+import { z } from "zod";
+import type { Sha256Digest } from "./agent-candidate.js";
+export declare const AGENT_WORKSPACE_LEASE_PHASES: readonly ["copy-ready", "workspace-sealed", "execution-bound", "destroying", "cleanup-failed", "destroyed"];
+export type AgentWorkspaceLeasePhase = (typeof AGENT_WORKSPACE_LEASE_PHASES)[number];
+/**
+ * Public identity of the provider-owned rules used to capture workspace state.
+ * The digest binds the exact canonical policy document retained by the provider;
+ * this descriptor does not claim that every provider captures the same fields.
+ */
+export interface AgentWorkspaceSourceSnapshotPolicy {
+    kind: "provider-declared";
+    name: string;
+    version: number;
+    digest: Sha256Digest;
+}
+/** Public allocation identity. `root` locates bytes; it grants no authority. */
+export interface AgentWorkspaceAllocationIdentity {
+    provider: string;
+    root: string;
+    /** Digest of the provider, lease/allocation identity, and canonical root. */
+    identityDigest: Sha256Digest;
+}
+interface AgentWorkspaceLeaseRecordBase {
+    kind: "agent-workspace-lease";
+    schemaVersion: 1;
+    leaseId: string;
+    ownerId: string;
+    workspace: AgentWorkspaceAllocationIdentity;
+    isolation: "per-run" | "shared";
+    sourceSnapshotDigest: Sha256Digest;
+    /** Governs both the source and prepared workspace digest interpretation. */
+    sourceSnapshotPolicy: AgentWorkspaceSourceSnapshotPolicy;
+    createdAtMs: number;
+    updatedAtMs: number;
+    expiresAtMs: number;
+}
+interface AgentWorkspaceUnpreparedEvidence {
+    preparedWorkspaceDigest?: never;
+    profileActivationDigest?: never;
+    executionPreparationDigest?: never;
+}
+interface AgentWorkspaceSealedEvidence {
+    preparedWorkspaceDigest: Sha256Digest;
+    profileActivationDigest: Sha256Digest;
+    executionPreparationDigest?: never;
+}
+interface AgentWorkspaceExecutionBoundEvidence {
+    preparedWorkspaceDigest: Sha256Digest;
+    profileActivationDigest: Sha256Digest;
+    executionPreparationDigest: Sha256Digest;
+}
+export type AgentWorkspaceCopyReadyLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceUnpreparedEvidence & {
+    phase: "copy-ready";
+    cleanupAttempts: 0;
+    cleanupError?: never;
+};
+export type AgentWorkspaceSealedLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceSealedEvidence & {
+    phase: "workspace-sealed";
+    cleanupAttempts: 0;
+    cleanupError?: never;
+};
+export type AgentWorkspaceExecutionBoundLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceExecutionBoundEvidence & {
+    phase: "execution-bound";
+    cleanupAttempts: 0;
+    cleanupError?: never;
+};
+type AgentWorkspaceCleanupEvidence = AgentWorkspaceUnpreparedEvidence | AgentWorkspaceSealedEvidence | AgentWorkspaceExecutionBoundEvidence;
+export type AgentWorkspaceDestroyingLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceCleanupEvidence & {
+    phase: "destroying";
+    cleanupAttempts: number;
+    cleanupError?: never;
+};
+export type AgentWorkspaceCleanupFailedLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceCleanupEvidence & {
+    phase: "cleanup-failed";
+    cleanupAttempts: number;
+    /** Sanitized public diagnostic; providers remain responsible for redaction. */
+    cleanupError: string;
+};
+export type AgentWorkspaceDestroyedLeaseRecordMaterial = AgentWorkspaceLeaseRecordBase & AgentWorkspaceCleanupEvidence & {
+    phase: "destroyed";
+    cleanupAttempts: number;
+    cleanupError?: never;
+};
+export type AgentWorkspaceLeaseRecordMaterial = AgentWorkspaceCopyReadyLeaseRecordMaterial | AgentWorkspaceSealedLeaseRecordMaterial | AgentWorkspaceExecutionBoundLeaseRecordMaterial | AgentWorkspaceDestroyingLeaseRecordMaterial | AgentWorkspaceCleanupFailedLeaseRecordMaterial | AgentWorkspaceDestroyedLeaseRecordMaterial;
+type WithDigest<Material> = Material extends unknown ? Material & {
+    digest: Sha256Digest;
+} : never;
+/** Self-hashed public projection. Private authorization and durable state stay out. */
+export type AgentWorkspaceLeaseRecord = WithDigest<AgentWorkspaceLeaseRecordMaterial>;
+export type AgentWorkspaceCopyReadyLeaseRecord = WithDigest<AgentWorkspaceCopyReadyLeaseRecordMaterial>;
+export type AgentWorkspaceSealedLeaseRecord = WithDigest<AgentWorkspaceSealedLeaseRecordMaterial>;
+export type AgentWorkspaceExecutionBoundLeaseRecord = WithDigest<AgentWorkspaceExecutionBoundLeaseRecordMaterial>;
+export type AgentWorkspaceDestroyingLeaseRecord = WithDigest<AgentWorkspaceDestroyingLeaseRecordMaterial>;
+export type AgentWorkspaceCleanupFailedLeaseRecord = WithDigest<AgentWorkspaceCleanupFailedLeaseRecordMaterial>;
+export type AgentWorkspaceDestroyedLeaseRecord = WithDigest<AgentWorkspaceDestroyedLeaseRecordMaterial>;
+/**
+ * Request-only owner capability. Providers persist at most a one-way digest;
+ * this value never belongs in a public lease or execution receipt.
+ */
+export interface AgentWorkspaceLeaseAuthorization {
+    leaseId: string;
+    ownerToken: string;
+}
+export interface AgentWorkspaceSealRequest extends AgentWorkspaceLeaseAuthorization {
+    profileActivationDigest: Sha256Digest;
+}
+export interface AgentWorkspaceExecutionBindingRequest extends AgentWorkspaceLeaseAuthorization {
+    executionPreparationDigest: Sha256Digest;
+}
+export interface AgentWorkspaceLeaseRenewalRequest extends AgentWorkspaceLeaseAuthorization {
+    expiresAtMs: number;
+}
+export declare const agentWorkspaceLeasePhaseSchema: z.ZodEnum<{
+    "copy-ready": "copy-ready";
+    "workspace-sealed": "workspace-sealed";
+    "execution-bound": "execution-bound";
+    destroying: "destroying";
+    "cleanup-failed": "cleanup-failed";
+    destroyed: "destroyed";
+}>;
+export declare const agentWorkspaceSourceSnapshotPolicySchema: 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>;
+export declare const agentWorkspaceAllocationIdentitySchema: z.ZodObject<{
+    provider: z.ZodString;
+    root: z.ZodString;
+    identityDigest: z.ZodType<`sha256:${string}`, unknown, z.core.$ZodTypeInternals<`sha256:${string}`, unknown>>;
+}, z.core.$strict>;
+export declare const agentWorkspaceLeaseRecordMaterialSchema: z.ZodType<AgentWorkspaceLeaseRecordMaterial>;
+export declare const agentWorkspaceLeaseRecordSchema: z.ZodType<AgentWorkspaceLeaseRecord>;
+/** Canonical public identity; private token/state fields cannot enter its schema. */
+export declare function canonicalAgentWorkspaceLeaseRecordDigest(material: AgentWorkspaceLeaseRecordMaterial): Sha256Digest;
+/** Build and self-hash one phase-valid public workspace lease record. */
+export declare function buildAgentWorkspaceLeaseRecord<Material extends AgentWorkspaceLeaseRecordMaterial>(material: Material): WithDigest<Material>;
+export {};