@byok-sdk/protocol 0.22.0 → 0.24.0

package/dist/agent-memory-intent.d.ts

@@ -0,0 +1,717 @@
+import { z } from 'zod';
+/**
+ * Host-approved Agent memory intents — the wire half.
+ *
+ * A Host (the only approval authority) approves one exact memory operation on
+ * one device-local Agent home. The device (the only memory content authority)
+ * applies it with its existing sha256 CAS at most once and reports a terminal,
+ * content-free completion. This package defines only:
+ *
+ * - the device capability that gates the task-free server -> daemon notice
+ *   `agent.memory.intent.available`, whose strict payload is exactly
+ *   `{ intentId, agentRef }` (see `messages.ts`);
+ * - the immutable intent a Host releases over its own device routes;
+ * - the fetch request/response a device exchanges with those routes;
+ * - the terminal completion a device reports and the durable readback a Host
+ *   returns for it.
+ *
+ * Notice-and-fetch is the point: memory content never rides the mailbox or the
+ * device journal. The only field that carries content is `content` on a
+ * `release` of a `replace` intent.
+ *
+ * Path authority stays with the device. This schema applies only the syntactic
+ * bounds the device ledger relies on (at most 1024 ASCII bytes that need no
+ * JSON escaping); the exact memory path rule (`MEMORY.md` or
+ * `notes/<safe>/…md`) and the `MEMORY.md` delete ban are evaluated by the
+ * device and reported as `path_invalid` / `memory_md_not_deletable`. Host-only
+ * path policy is Host vocabulary and stays out of this package, as do
+ * audiences, route paths and product names.
+ *
+ * `operationDigest` is pinned to `@byok-sdk/core`
+ * `agentMemoryIntentOperationDigest(...)`, which a device recomputes with its
+ * own enrolled tenant and device ids.
+ */
+/** Device capability required before a Host may enqueue `agent.memory.intent.available`. */
+export declare const AGENT_MEMORY_INTENT_CAPABILITY: 'agent-memory-intent.v1';
+/** Maximum UTF-8 byte length of a released `replace` body (one memory file): 256 KiB. */
+export declare const AGENT_MEMORY_INTENT_CONTENT_MAX_BYTES = 262144;
+/** Maximum byte length of an intent `path` (ASCII, so bytes = characters). */
+export declare const AGENT_MEMORY_INTENT_PATH_MAX_BYTES = 1024;
+/** Maximum byte length of an opaque `approvalRef` (ASCII, so bytes = characters). */
+export declare const AGENT_MEMORY_INTENT_APPROVAL_REF_MAX_BYTES = 128;
+/** A memory file revision: `sha256:` over the file bytes (a missing file is the empty-bytes digest). */
+export declare const AgentMemoryIntentRevisionSchema: z.ZodString;
+export type AgentMemoryIntentRevision = z.infer<typeof AgentMemoryIntentRevisionSchema>;
+/** The identity-and-operation binding; see `@byok-sdk/core` `agentMemoryIntentOperationDigest`. */
+export declare const AgentMemoryIntentOperationDigestSchema: z.ZodString;
+export type AgentMemoryIntentOperationDigest = z.infer<typeof AgentMemoryIntentOperationDigestSchema>;
+/**
+ * Syntactic bound only: 1..1024 printable ASCII characters that need no JSON
+ * escaping (no `"`, no `\`, no control characters). The device applies the
+ * exact memory path rule.
+ */
+export declare const AgentMemoryIntentPathSchema: z.ZodString;
+export type AgentMemoryIntentPath = z.infer<typeof AgentMemoryIntentPathSchema>;
+/** Opaque audit correlation. The device records it and never evaluates it. */
+export declare const AgentMemoryIntentApprovalRefSchema: z.ZodString;
+export type AgentMemoryIntentApprovalRef = z.infer<typeof AgentMemoryIntentApprovalRefSchema>;
+/** A `replace` body: well-formed Unicode whose UTF-8 encoding is at most 256 KiB. */
+export declare const AgentMemoryIntentContentSchema: z.ZodString;
+export type AgentMemoryIntentContent = z.infer<typeof AgentMemoryIntentContentSchema>;
+export declare const AGENT_MEMORY_INTENT_OPERATIONS: readonly ['replace', 'delete'];
+export declare const AgentMemoryIntentOperationSchema: z.ZodEnum<{
+    delete: "delete";
+    replace: "replace";
+}>;
+export type AgentMemoryIntentOperation = z.infer<typeof AgentMemoryIntentOperationSchema>;
+/**
+ * The immutable Host-approved intent.
+ *
+ * - `replace`: `targetRevision` is the digest of the approved body and must
+ *   differ from `baseRevision`; `content` appears only inside a `release`.
+ * - `delete`: `targetRevision` is `null` and there is never `content`.
+ */
+export declare const AgentMemoryIntentV1Schema: z.ZodObject<{
+    intentId: z.ZodUUID;
+    agentRef: z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
+    }, z.core.$strict>;
+    path: z.ZodString;
+    operation: z.ZodEnum<{
+        delete: "delete";
+        replace: "replace";
+    }>;
+    baseRevision: z.ZodString;
+    targetRevision: z.ZodNullable<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+    approvalRef: z.ZodString;
+    operationDigest: z.ZodString;
+}, z.core.$strict>;
+export type AgentMemoryIntentV1 = z.infer<typeof AgentMemoryIntentV1Schema>;
+/**
+ * Codes a Host decides on its own authority. They are the only `withheld`
+ * codes and the only codes a `host_terminal` readback may carry.
+ */
+export declare const AGENT_MEMORY_INTENT_HOST_TERMINAL_CODES: readonly ['intent_revoked', 'intent_expired', 'placement_changed', 'profile_revision_changed'];
+export declare const AgentMemoryIntentHostTerminalCodeSchema: z.ZodEnum<{
+    intent_expired: "intent_expired";
+    intent_revoked: "intent_revoked";
+    placement_changed: "placement_changed";
+    profile_revision_changed: "profile_revision_changed";
+}>;
+export type AgentMemoryIntentHostTerminalCode = z.infer<typeof AgentMemoryIntentHostTerminalCodeSchema>;
+/**
+ * Closed rejection set. A code names the failed check, never a value. Every
+ * `rejected` completion means the device wrote no `applying` record and made
+ * zero memory writes.
+ */
+export declare const AGENT_MEMORY_INTENT_REJECTION_CODES: readonly ["intent_invalid", "path_invalid", "memory_md_not_deletable", "content_invalid", "intent_digest_mismatch", "agent_ref_mismatch", "agent_home_unavailable", "intent_revoked", "intent_expired", "placement_changed", "profile_revision_changed"];
+export declare const AgentMemoryIntentRejectionCodeSchema: z.ZodEnum<{
+    agent_home_unavailable: "agent_home_unavailable";
+    agent_ref_mismatch: "agent_ref_mismatch";
+    content_invalid: "content_invalid";
+    intent_digest_mismatch: "intent_digest_mismatch";
+    intent_expired: "intent_expired";
+    intent_invalid: "intent_invalid";
+    intent_revoked: "intent_revoked";
+    memory_md_not_deletable: "memory_md_not_deletable";
+    path_invalid: "path_invalid";
+    placement_changed: "placement_changed";
+    profile_revision_changed: "profile_revision_changed";
+}>;
+export type AgentMemoryIntentRejectionCode = z.infer<typeof AgentMemoryIntentRejectionCodeSchema>;
+/** One device observation of the target file. The observation instant is not on the wire. */
+export declare const AgentMemoryIntentFileObservationSchema: z.ZodObject<{
+    exists: z.ZodBoolean;
+    revision: z.ZodString;
+}, z.core.$strict>;
+export type AgentMemoryIntentFileObservation = z.infer<typeof AgentMemoryIntentFileObservationSchema>;
+/**
+ * The terminal, content-free result of one intent, reported by the device.
+ *
+ * - `applied`: the live-path CAS returned success; `result` is the file after it.
+ * - `conflict`: the live-path CAS refused on revision; this attempt wrote nothing.
+ * - `rejected`: no `applying` record was written; zero writes.
+ * - `uncertain`: whether this intent wrote is unknown; `observed` is only the
+ *   current file, never provenance.
+ *
+ * There is no non-terminal outcome.
+ */
+export declare const AgentMemoryIntentCompletionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    intentId: z.ZodUUID;
+    agentRef: z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
+    }, z.core.$strict>;
+    path: z.ZodString;
+    operation: z.ZodEnum<{
+        delete: "delete";
+        replace: "replace";
+    }>;
+    operationDigest: z.ZodString;
+    outcome: z.ZodLiteral<"applied">;
+    result: z.ZodObject<{
+        exists: z.ZodBoolean;
+        revision: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    intentId: z.ZodUUID;
+    agentRef: z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
+    }, z.core.$strict>;
+    path: z.ZodString;
+    operation: z.ZodEnum<{
+        delete: "delete";
+        replace: "replace";
+    }>;
+    operationDigest: z.ZodString;
+    outcome: z.ZodLiteral<"conflict">;
+    observed: z.ZodObject<{
+        exists: z.ZodBoolean;
+        revision: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    intentId: z.ZodUUID;
+    agentRef: z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
+    }, z.core.$strict>;
+    path: z.ZodString;
+    operation: z.ZodEnum<{
+        delete: "delete";
+        replace: "replace";
+    }>;
+    operationDigest: z.ZodString;
+    outcome: z.ZodLiteral<"rejected">;
+    code: z.ZodEnum<{
+        agent_home_unavailable: "agent_home_unavailable";
+        agent_ref_mismatch: "agent_ref_mismatch";
+        content_invalid: "content_invalid";
+        intent_digest_mismatch: "intent_digest_mismatch";
+        intent_expired: "intent_expired";
+        intent_invalid: "intent_invalid";
+        intent_revoked: "intent_revoked";
+        memory_md_not_deletable: "memory_md_not_deletable";
+        path_invalid: "path_invalid";
+        placement_changed: "placement_changed";
+        profile_revision_changed: "profile_revision_changed";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    intentId: z.ZodUUID;
+    agentRef: z.ZodObject<{
+        agentId: z.ZodString;
+        profileRevision: z.ZodString;
+    }, z.core.$strict>;
+    path: z.ZodString;
+    operation: z.ZodEnum<{
+        delete: "delete";
+        replace: "replace";
+    }>;
+    operationDigest: z.ZodString;
+    outcome: z.ZodLiteral<"uncertain">;
+    observed: z.ZodObject<{
+        exists: z.ZodBoolean;
+        revision: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>], "outcome">;
+export type AgentMemoryIntentCompletion = z.infer<typeof AgentMemoryIntentCompletionSchema>;
+/**
+ * How the Host's durable record relates to the completion it was handed:
+ *
+ * - `recorded`: this completion became the intent's first terminal fact.
+ * - `idempotent`: an identical completion was already recorded.
+ * - `conflict`: a different completion is already recorded; it is returned.
+ * - `host_terminal`: the Host had already terminated the intent on its own
+ *   authority ({@link AGENT_MEMORY_INTENT_HOST_TERMINAL_CODES}).
+ */
+export declare const AGENT_MEMORY_INTENT_READBACK_DISPOSITIONS: readonly ['recorded', 'idempotent', 'conflict', 'host_terminal'];
+export declare const AgentMemoryIntentReadbackDispositionSchema: z.ZodEnum<{
+    conflict: "conflict";
+    host_terminal: "host_terminal";
+    idempotent: "idempotent";
+    recorded: "recorded";
+}>;
+export type AgentMemoryIntentReadbackDisposition = z.infer<typeof AgentMemoryIntentReadbackDispositionSchema>;
+/**
+ * The Host's durable terminal readback for one intent. `completion` is the
+ * terminal fact the Host has STORED; on `host_terminal` it is always a
+ * `rejected` completion carrying a Host code. `recordedAt` is the Host record
+ * time, never a device observation time.
+ */
+export declare const AgentMemoryIntentReadbackSchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    deviceId: z.ZodString;
+    intentId: z.ZodUUID;
+    disposition: z.ZodEnum<{
+        conflict: "conflict";
+        host_terminal: "host_terminal";
+        idempotent: "idempotent";
+        recorded: "recorded";
+    }>;
+    completion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        operationDigest: z.ZodString;
+        outcome: z.ZodLiteral<"applied">;
+        result: z.ZodObject<{
+            exists: z.ZodBoolean;
+            revision: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        operationDigest: z.ZodString;
+        outcome: z.ZodLiteral<"conflict">;
+        observed: z.ZodObject<{
+            exists: z.ZodBoolean;
+            revision: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        operationDigest: z.ZodString;
+        outcome: z.ZodLiteral<"rejected">;
+        code: z.ZodEnum<{
+            agent_home_unavailable: "agent_home_unavailable";
+            agent_ref_mismatch: "agent_ref_mismatch";
+            content_invalid: "content_invalid";
+            intent_digest_mismatch: "intent_digest_mismatch";
+            intent_expired: "intent_expired";
+            intent_invalid: "intent_invalid";
+            intent_revoked: "intent_revoked";
+            memory_md_not_deletable: "memory_md_not_deletable";
+            path_invalid: "path_invalid";
+            placement_changed: "placement_changed";
+            profile_revision_changed: "profile_revision_changed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        operationDigest: z.ZodString;
+        outcome: z.ZodLiteral<"uncertain">;
+        observed: z.ZodObject<{
+            exists: z.ZodBoolean;
+            revision: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "outcome">;
+    recordedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type AgentMemoryIntentReadback = z.infer<typeof AgentMemoryIntentReadbackSchema>;
+/**
+ * `held`: the device reserved a ledger slot and may receive a release.
+ * `none`: the device could not reserve; the Host must not change intent state
+ * or release content.
+ */
+export declare const AGENT_MEMORY_INTENT_RESERVATIONS: readonly ['held', 'none'];
+export declare const AgentMemoryIntentReservationSchema: z.ZodEnum<{
+    held: "held";
+    none: "none";
+}>;
+export type AgentMemoryIntentReservation = z.infer<typeof AgentMemoryIntentReservationSchema>;
+/**
+ * The SDK half of a fetch. Device authentication (the tenant and device a Host
+ * trusts) is Host transport vocabulary and is not part of this schema.
+ */
+export declare const AgentMemoryIntentFetchRequestSchema: z.ZodObject<{
+    intentId: z.ZodUUID;
+    reservation: z.ZodEnum<{
+        held: "held";
+        none: "none";
+    }>;
+}, z.core.$strict>;
+export type AgentMemoryIntentFetchRequest = z.infer<typeof AgentMemoryIntentFetchRequestSchema>;
+export declare const AGENT_MEMORY_INTENT_FETCH_DISPOSITIONS: readonly ['release', 'withheld', 'terminal', 'deferred'];
+export type AgentMemoryIntentFetchDisposition = (typeof AGENT_MEMORY_INTENT_FETCH_DISPOSITIONS)[number];
+/** Which fetch dispositions a Host may answer for each request reservation. */
+export declare const AGENT_MEMORY_INTENT_FETCH_DISPOSITIONS_BY_RESERVATION: {
+    readonly held: readonly ["release", "withheld", "terminal"];
+    readonly none: readonly ["terminal", "deferred"];
+};
+/**
+ * A Host fetch answer, independent of the request reservation. A device must
+ * parse with {@link agentMemoryIntentFetchResponseSchemaFor} so a `release` or
+ * `withheld` answer to a `none` request (or a `deferred` answer to a `held`
+ * request) is refused.
+ */
+export declare const AgentMemoryIntentFetchResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    disposition: z.ZodLiteral<"release">;
+    intent: z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        baseRevision: z.ZodString;
+        targetRevision: z.ZodNullable<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        approvalRef: z.ZodString;
+        operationDigest: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    disposition: z.ZodLiteral<"withheld">;
+    intent: z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        baseRevision: z.ZodString;
+        targetRevision: z.ZodNullable<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        approvalRef: z.ZodString;
+        operationDigest: z.ZodString;
+    }, z.core.$strict>;
+    code: z.ZodEnum<{
+        intent_expired: "intent_expired";
+        intent_revoked: "intent_revoked";
+        placement_changed: "placement_changed";
+        profile_revision_changed: "profile_revision_changed";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    disposition: z.ZodLiteral<"terminal">;
+    intent: z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        baseRevision: z.ZodString;
+        targetRevision: z.ZodNullable<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        approvalRef: z.ZodString;
+        operationDigest: z.ZodString;
+    }, z.core.$strict>;
+    readback: z.ZodObject<{
+        tenantId: z.ZodString;
+        deviceId: z.ZodString;
+        intentId: z.ZodUUID;
+        disposition: z.ZodEnum<{
+            conflict: "conflict";
+            host_terminal: "host_terminal";
+            idempotent: "idempotent";
+            recorded: "recorded";
+        }>;
+        completion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            intentId: z.ZodUUID;
+            agentRef: z.ZodObject<{
+                agentId: z.ZodString;
+                profileRevision: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            operation: z.ZodEnum<{
+                delete: "delete";
+                replace: "replace";
+            }>;
+            operationDigest: z.ZodString;
+            outcome: z.ZodLiteral<"applied">;
+            result: z.ZodObject<{
+                exists: z.ZodBoolean;
+                revision: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            intentId: z.ZodUUID;
+            agentRef: z.ZodObject<{
+                agentId: z.ZodString;
+                profileRevision: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            operation: z.ZodEnum<{
+                delete: "delete";
+                replace: "replace";
+            }>;
+            operationDigest: z.ZodString;
+            outcome: z.ZodLiteral<"conflict">;
+            observed: z.ZodObject<{
+                exists: z.ZodBoolean;
+                revision: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            intentId: z.ZodUUID;
+            agentRef: z.ZodObject<{
+                agentId: z.ZodString;
+                profileRevision: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            operation: z.ZodEnum<{
+                delete: "delete";
+                replace: "replace";
+            }>;
+            operationDigest: z.ZodString;
+            outcome: z.ZodLiteral<"rejected">;
+            code: z.ZodEnum<{
+                agent_home_unavailable: "agent_home_unavailable";
+                agent_ref_mismatch: "agent_ref_mismatch";
+                content_invalid: "content_invalid";
+                intent_digest_mismatch: "intent_digest_mismatch";
+                intent_expired: "intent_expired";
+                intent_invalid: "intent_invalid";
+                intent_revoked: "intent_revoked";
+                memory_md_not_deletable: "memory_md_not_deletable";
+                path_invalid: "path_invalid";
+                placement_changed: "placement_changed";
+                profile_revision_changed: "profile_revision_changed";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            intentId: z.ZodUUID;
+            agentRef: z.ZodObject<{
+                agentId: z.ZodString;
+                profileRevision: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            operation: z.ZodEnum<{
+                delete: "delete";
+                replace: "replace";
+            }>;
+            operationDigest: z.ZodString;
+            outcome: z.ZodLiteral<"uncertain">;
+            observed: z.ZodObject<{
+                exists: z.ZodBoolean;
+                revision: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "outcome">;
+        recordedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    disposition: z.ZodLiteral<"deferred">;
+    intent: z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        baseRevision: z.ZodString;
+        targetRevision: z.ZodNullable<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        approvalRef: z.ZodString;
+        operationDigest: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>], "disposition">;
+export type AgentMemoryIntentFetchResponse = z.infer<typeof AgentMemoryIntentFetchResponseSchema>;
+/** The fetch answer schema bound to the reservation the device sent. */
+export declare function agentMemoryIntentFetchResponseSchemaFor(reservation: AgentMemoryIntentReservation): z.ZodDiscriminatedUnion<[z.ZodObject<{
+    disposition: z.ZodLiteral<"release">;
+    intent: z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        baseRevision: z.ZodString;
+        targetRevision: z.ZodNullable<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        approvalRef: z.ZodString;
+        operationDigest: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    disposition: z.ZodLiteral<"withheld">;
+    intent: z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        baseRevision: z.ZodString;
+        targetRevision: z.ZodNullable<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        approvalRef: z.ZodString;
+        operationDigest: z.ZodString;
+    }, z.core.$strict>;
+    code: z.ZodEnum<{
+        intent_expired: "intent_expired";
+        intent_revoked: "intent_revoked";
+        placement_changed: "placement_changed";
+        profile_revision_changed: "profile_revision_changed";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    disposition: z.ZodLiteral<"terminal">;
+    intent: z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        baseRevision: z.ZodString;
+        targetRevision: z.ZodNullable<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        approvalRef: z.ZodString;
+        operationDigest: z.ZodString;
+    }, z.core.$strict>;
+    readback: z.ZodObject<{
+        tenantId: z.ZodString;
+        deviceId: z.ZodString;
+        intentId: z.ZodUUID;
+        disposition: z.ZodEnum<{
+            conflict: "conflict";
+            host_terminal: "host_terminal";
+            idempotent: "idempotent";
+            recorded: "recorded";
+        }>;
+        completion: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            intentId: z.ZodUUID;
+            agentRef: z.ZodObject<{
+                agentId: z.ZodString;
+                profileRevision: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            operation: z.ZodEnum<{
+                delete: "delete";
+                replace: "replace";
+            }>;
+            operationDigest: z.ZodString;
+            outcome: z.ZodLiteral<"applied">;
+            result: z.ZodObject<{
+                exists: z.ZodBoolean;
+                revision: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            intentId: z.ZodUUID;
+            agentRef: z.ZodObject<{
+                agentId: z.ZodString;
+                profileRevision: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            operation: z.ZodEnum<{
+                delete: "delete";
+                replace: "replace";
+            }>;
+            operationDigest: z.ZodString;
+            outcome: z.ZodLiteral<"conflict">;
+            observed: z.ZodObject<{
+                exists: z.ZodBoolean;
+                revision: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            intentId: z.ZodUUID;
+            agentRef: z.ZodObject<{
+                agentId: z.ZodString;
+                profileRevision: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            operation: z.ZodEnum<{
+                delete: "delete";
+                replace: "replace";
+            }>;
+            operationDigest: z.ZodString;
+            outcome: z.ZodLiteral<"rejected">;
+            code: z.ZodEnum<{
+                agent_home_unavailable: "agent_home_unavailable";
+                agent_ref_mismatch: "agent_ref_mismatch";
+                content_invalid: "content_invalid";
+                intent_digest_mismatch: "intent_digest_mismatch";
+                intent_expired: "intent_expired";
+                intent_invalid: "intent_invalid";
+                intent_revoked: "intent_revoked";
+                memory_md_not_deletable: "memory_md_not_deletable";
+                path_invalid: "path_invalid";
+                placement_changed: "placement_changed";
+                profile_revision_changed: "profile_revision_changed";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            intentId: z.ZodUUID;
+            agentRef: z.ZodObject<{
+                agentId: z.ZodString;
+                profileRevision: z.ZodString;
+            }, z.core.$strict>;
+            path: z.ZodString;
+            operation: z.ZodEnum<{
+                delete: "delete";
+                replace: "replace";
+            }>;
+            operationDigest: z.ZodString;
+            outcome: z.ZodLiteral<"uncertain">;
+            observed: z.ZodObject<{
+                exists: z.ZodBoolean;
+                revision: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "outcome">;
+        recordedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    disposition: z.ZodLiteral<"deferred">;
+    intent: z.ZodObject<{
+        intentId: z.ZodUUID;
+        agentRef: z.ZodObject<{
+            agentId: z.ZodString;
+            profileRevision: z.ZodString;
+        }, z.core.$strict>;
+        path: z.ZodString;
+        operation: z.ZodEnum<{
+            delete: "delete";
+            replace: "replace";
+        }>;
+        baseRevision: z.ZodString;
+        targetRevision: z.ZodNullable<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+        approvalRef: z.ZodString;
+        operationDigest: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>], "disposition">;