@makaio/framework 1.0.0-dev-1787670559522 → 1.0.0-dev-1787949057928

package/dist/{types-CwvN4uN2.d.mts → types-DcxBYlPA.d.mts}

@@ -1,5 +1,6 @@
-import { a as JsonValue$1 } from "./json-value-C1RGgS0a.mjs";
-import { s as MessageBlock$1 } from "./index-CSN_0sCo.mjs";
+import { l as JsonValue$1 } from "./json-value-DPqb-SJ8.mjs";
+import { s as MessageBlock$1 } from "./index-CmwAJ8-5.mjs";
+import { t as ContractStorageNamespaceDefinition } from "./storage-namespace-definition-BsnYAPot.mjs";
 import * as _$zod from "zod";
 import { z } from "zod";
 import * as _$_makaio_core0 from "@makaio/framework/core";
@@ -106,6 +107,11 @@ declare const MakaioSessionAgentSchema$1: z.ZodObject<{
   adapterId: z.ZodString;
   adapterName: z.ZodString;
   sessionId: z.ZodString;
+  runtimeOwner: z.ZodOptional<z.ZodObject<{
+    machineId: z.ZodString;
+    instanceId: z.ZodString;
+  }, z.core.$strip>>;
+  recoveryAttemptId: z.ZodOptional<z.ZodString>;
   adapterSessionId: z.ZodOptional<z.ZodString>;
   currentAdapterSessionId: z.ZodOptional<z.ZodString>;
   currentAdapterSessionIdState: z.ZodOptional<z.ZodEnum<{
@@ -162,6 +168,11 @@ declare const MakaioSessionSchema: z.ZodObject<{
     adapterId: z.ZodString;
     adapterName: z.ZodString;
     sessionId: z.ZodString;
+    runtimeOwner: z.ZodOptional<z.ZodObject<{
+      machineId: z.ZodString;
+      instanceId: z.ZodString;
+    }, z.core.$strip>>;
+    recoveryAttemptId: z.ZodOptional<z.ZodString>;
     adapterSessionId: z.ZodOptional<z.ZodString>;
     currentAdapterSessionId: z.ZodOptional<z.ZodString>;
     currentAdapterSessionIdState: z.ZodOptional<z.ZodEnum<{
@@ -305,6 +316,11 @@ declare const SessionWithPreviewSchema: z.ZodObject<{
     adapterId: z.ZodString;
     adapterName: z.ZodString;
     sessionId: z.ZodString;
+    runtimeOwner: z.ZodOptional<z.ZodObject<{
+      machineId: z.ZodString;
+      instanceId: z.ZodString;
+    }, z.core.$strip>>;
+    recoveryAttemptId: z.ZodOptional<z.ZodString>;
     adapterSessionId: z.ZodOptional<z.ZodString>;
     currentAdapterSessionId: z.ZodOptional<z.ZodString>;
     currentAdapterSessionIdState: z.ZodOptional<z.ZodEnum<{
@@ -522,6 +538,11 @@ declare const SessionSnapshotSchema: z.ZodObject<{
       adapterId: z.ZodString;
       adapterName: z.ZodString;
       sessionId: z.ZodString;
+      runtimeOwner: z.ZodOptional<z.ZodObject<{
+        machineId: z.ZodString;
+        instanceId: z.ZodString;
+      }, z.core.$strip>>;
+      recoveryAttemptId: z.ZodOptional<z.ZodString>;
       adapterSessionId: z.ZodOptional<z.ZodString>;
       currentAdapterSessionId: z.ZodOptional<z.ZodString>;
       currentAdapterSessionIdState: z.ZodOptional<z.ZodEnum<{
@@ -650,6 +671,11 @@ declare const SessionSnapshotSchema: z.ZodObject<{
     adapterId: z.ZodString;
     adapterName: z.ZodString;
     sessionId: z.ZodString;
+    runtimeOwner: z.ZodOptional<z.ZodObject<{
+      machineId: z.ZodString;
+      instanceId: z.ZodString;
+    }, z.core.$strip>>;
+    recoveryAttemptId: z.ZodOptional<z.ZodString>;
     adapterSessionId: z.ZodOptional<z.ZodString>;
     currentAdapterSessionId: z.ZodOptional<z.ZodString>;
     currentAdapterSessionIdState: z.ZodOptional<z.ZodEnum<{
@@ -1526,8 +1552,8 @@ type Turn$1 = z.infer<typeof TurnSchema$1>;
  */
 declare const MessageRoutingStatusSchema: z.ZodEnum<{
   completed: "completed";
-  sent: "sent";
   acknowledged: "acknowledged";
+  sent: "sent";
 }>;
 type MessageRoutingStatus = z.infer<typeof MessageRoutingStatusSchema>;
 /**
@@ -1538,8 +1564,8 @@ declare const MessageRoutingSchema$1: z.ZodObject<{
   agentId: z.ZodString;
   status: z.ZodEnum<{
     completed: "completed";
-    sent: "sent";
     acknowledged: "acknowledged";
+    sent: "sent";
   }>;
   timestamp: z.ZodNumber;
   error: z.ZodOptional<z.ZodString>;
@@ -2522,7 +2548,7 @@ declare const OrchestratorSchemas: {
           systemPrompt: "systemPrompt";
           fullPrefix: "fullPrefix";
         }>>;
-        turnContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<_$_makaio_contracts0.JsonValue, unknown, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, unknown>>>>;
+        turnContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, z.core.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>>;
         requestCorrelation: z.ZodOptional<z.ZodObject<{
           sessionId: z.ZodOptional<z.ZodString>;
           turnId: z.ZodOptional<z.ZodString>;
@@ -4556,21 +4582,2578 @@ declare const SessionUpdatedEventSchema: z.ZodObject<{
 type SessionCreated = z.infer<typeof SessionCreatedEventSchema>;
 type SessionUpdatedEvent = z.infer<typeof SessionUpdatedEventSchema>;
 //#endregion
+//#region core/contracts/src/session/session-ownership-claim-status.d.ts
+/** Lifecycle state of a durable adapter-session ownership claim. */
+declare const AdapterSessionClaimStatusSchema: z.ZodEnum<{
+  abandoned: "abandoned";
+  held: "held";
+  releasing: "releasing";
+}>;
+/** {@inheritDoc AdapterSessionClaimStatusSchema} */
+type AdapterSessionClaimStatus = z.infer<typeof AdapterSessionClaimStatusSchema>;
+//#endregion
+//#region core/contracts/src/session/session-ownership-recovery.d.ts
+/** Exact runtime binding a recovery transfers to its replacement connector. */
+declare const RuntimeBindingSchema: z.ZodObject<{
+  adapterId: z.ZodString;
+  ownerMachineId: z.ZodString;
+  ownerInstanceId: z.ZodString;
+}, z.core.$strip>;
+/** {@inheritDoc RuntimeBindingSchema} */
+type RuntimeBinding = z.infer<typeof RuntimeBindingSchema>;
+/** Durable row image restored when a recovery is refused before dispatch. */
+declare const SessionOwnershipRecoveryPreimageSchema: z.ZodObject<{
+  status: z.ZodEnum<{
+    idle: "idle";
+    active: "active";
+    starting: "starting";
+    dead: "dead";
+    disposed: "disposed";
+  }>;
+  adapterId: z.ZodString;
+  binding: z.ZodOptional<z.ZodObject<{
+    adapterId: z.ZodString;
+    ownerMachineId: z.ZodString;
+    ownerInstanceId: z.ZodString;
+  }, z.core.$strip>>;
+  recoveryAttemptId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipRecoveryPreimageSchema} */
+type SessionOwnershipRecoveryPreimage = z.infer<typeof SessionOwnershipRecoveryPreimageSchema>;
+/** Attempt and preimage created by one successful guarded reservation. */
+declare const SessionOwnershipRecoveryReservationSchema: z.ZodObject<{
+  attemptId: z.ZodString;
+  preimage: z.ZodObject<{
+    status: z.ZodEnum<{
+      idle: "idle";
+      active: "active";
+      starting: "starting";
+      dead: "dead";
+      disposed: "disposed";
+    }>;
+    adapterId: z.ZodString;
+    binding: z.ZodOptional<z.ZodObject<{
+      adapterId: z.ZodString;
+      ownerMachineId: z.ZodString;
+      ownerInstanceId: z.ZodString;
+    }, z.core.$strip>>;
+    recoveryAttemptId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipRecoveryReservationSchema} */
+type SessionOwnershipRecoveryReservation = z.infer<typeof SessionOwnershipRecoveryReservationSchema>;
+/** Terminal action for an attempt-fenced recovery lifecycle. */
+declare const SessionOwnershipRecoveryTerminalActionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"rollback">;
+  preimage: z.ZodObject<{
+    status: z.ZodEnum<{
+      idle: "idle";
+      active: "active";
+      starting: "starting";
+      dead: "dead";
+      disposed: "disposed";
+    }>;
+    adapterId: z.ZodString;
+    binding: z.ZodOptional<z.ZodObject<{
+      adapterId: z.ZodString;
+      ownerMachineId: z.ZodString;
+      ownerInstanceId: z.ZodString;
+    }, z.core.$strip>>;
+    recoveryAttemptId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"succeeded">;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"failed">;
+}, z.core.$strip>], "kind">;
+/** {@inheritDoc SessionOwnershipRecoveryTerminalActionSchema} */
+type SessionOwnershipRecoveryTerminalAction = z.infer<typeof SessionOwnershipRecoveryTerminalActionSchema>;
+/** Atomically terminalize a recovery only while its exact attempt still owns the row. */
+declare const SessionOwnershipFinalizeRecoveryRequestSchema: z.ZodObject<{
+  agentId: z.ZodString;
+  attemptId: z.ZodString;
+  binding: z.ZodObject<{
+    adapterId: z.ZodString;
+    ownerMachineId: z.ZodString;
+    ownerInstanceId: z.ZodString;
+  }, z.core.$strip>;
+  action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"rollback">;
+    preimage: z.ZodObject<{
+      status: z.ZodEnum<{
+        idle: "idle";
+        active: "active";
+        starting: "starting";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+      adapterId: z.ZodString;
+      binding: z.ZodOptional<z.ZodObject<{
+        adapterId: z.ZodString;
+        ownerMachineId: z.ZodString;
+        ownerInstanceId: z.ZodString;
+      }, z.core.$strip>>;
+      recoveryAttemptId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"succeeded">;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"failed">;
+  }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipFinalizeRecoveryRequestSchema} */
+type SessionOwnershipFinalizeRecoveryRequest = z.infer<typeof SessionOwnershipFinalizeRecoveryRequestSchema>;
+/** Result of an attempt-fenced recovery terminal transition. */
+declare const SessionOwnershipFinalizeRecoveryResponseSchema: z.ZodObject<{
+  applied: z.ZodBoolean;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipFinalizeRecoveryResponseSchema} */
+type SessionOwnershipFinalizeRecoveryResult = z.infer<typeof SessionOwnershipFinalizeRecoveryResponseSchema>;
+/** Exact generation observed on a key while recovery was planned. */
+declare const SessionOwnershipRecoveryOwnerGenerationSchema: z.ZodObject<{
+  claimId: z.ZodString;
+  claimToken: z.ZodString;
+  fence: z.ZodNumber;
+  ownerInstanceId: z.ZodNullable<z.ZodString>;
+  status: z.ZodEnum<{
+    abandoned: "abandoned";
+    held: "held";
+    releasing: "releasing";
+  }>;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipRecoveryOwnerGenerationSchema} */
+type SessionOwnershipRecoveryOwnerGeneration = z.infer<typeof SessionOwnershipRecoveryOwnerGenerationSchema>;
+/** Snapshot a recovery reservation must replace atomically. */
+declare const SessionOwnershipRecoveryGuardSchema: z.ZodObject<{
+  expectedStatus: z.ZodEnum<{
+    idle: "idle";
+    active: "active";
+    starting: "starting";
+    dead: "dead";
+    disposed: "disposed";
+  }>;
+  expectedPreimage: z.ZodObject<{
+    status: z.ZodEnum<{
+      idle: "idle";
+      active: "active";
+      starting: "starting";
+      dead: "dead";
+      disposed: "disposed";
+    }>;
+    adapterId: z.ZodString;
+    binding: z.ZodOptional<z.ZodObject<{
+      adapterId: z.ZodString;
+      ownerMachineId: z.ZodString;
+      ownerInstanceId: z.ZodString;
+    }, z.core.$strip>>;
+    recoveryAttemptId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  expectedRevision: z.ZodNumber;
+  expectedCurrencyFence: z.ZodNumber;
+  expectedCurrency: z.ZodObject<{
+    adapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionIdState: z.ZodEnum<{
+      confirmed: "confirmed";
+      moved: "moved";
+      inherited: "inherited";
+    }>;
+  }, z.core.$strip>;
+  ownerGeneration: z.ZodNullable<z.ZodObject<{
+    claimId: z.ZodString;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipRecoveryGuardSchema} */
+type SessionOwnershipRecoveryGuard$1 = z.infer<typeof SessionOwnershipRecoveryGuardSchema>;
+//#endregion
+//#region core/contracts/src/session/session-ownership-storage-namespace.d.ts
+/**
+ * Identity of the namespace a provider session is owned within.
+ *
+ * A provider session ID is only unique inside the runtime that stores it: the
+ * same ID may exist on another machine, or under another adapter runtime on the
+ * same machine, and those are different conversations. This triple is therefore
+ * the ownership key, and the claim table's unique index over it is what makes
+ * "exactly one winner" a property of the schema rather than of handler code.
+ */
+declare const AdapterSessionClaimKeySchema: z.ZodObject<{
+  machineId: z.ZodString;
+  adapterId: z.ZodString;
+  providerSessionId: z.ZodString;
+}, z.core.$strip>;
+/** {@inheritDoc AdapterSessionClaimKeySchema} */
+type AdapterSessionClaimKey = z.infer<typeof AdapterSessionClaimKeySchema>;
+/**
+ * A durable ownership claim on one provider-native session.
+ *
+ * `claimToken` identifies the claim generation opaquely; `fence` orders
+ * generations. The two always change together — a takeover mints a new token
+ * and a higher fence — so a stale owner can be rejected by comparison
+ * (`fence`) rather than by recognition (`claimToken`), which is what lets a
+ * write arriving from a previous process be refused rather than applied.
+ */
+declare const AdapterSessionClaimRecordSchema: z.ZodObject<{
+  machineId: z.ZodString;
+  adapterId: z.ZodString;
+  providerSessionId: z.ZodString;
+  claimId: z.ZodString;
+  adapterName: z.ZodString;
+  sessionId: z.ZodString;
+  agentId: z.ZodString;
+  ownerInstanceId: z.ZodNullable<z.ZodString>;
+  claimToken: z.ZodString;
+  fence: z.ZodNumber;
+  status: z.ZodEnum<{
+    abandoned: "abandoned";
+    held: "held";
+    releasing: "releasing";
+  }>;
+  claimedAt: z.ZodNumber;
+  updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+/** {@inheritDoc AdapterSessionClaimRecordSchema} */
+type AdapterSessionClaimRecord$1 = z.infer<typeof AdapterSessionClaimRecordSchema>;
+/**
+ * One runtime process acting for one machine that has taken an ownership
+ * generation. Instance rows are durable diagnostics and are never deleted.
+ */
+declare const RuntimeInstanceRecordSchema: z.ZodObject<{
+  instanceId: z.ZodString;
+  machineId: z.ZodString;
+  incarnation: z.ZodNumber;
+  startedAt: z.ZodNumber;
+  retiredAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+/** {@inheritDoc RuntimeInstanceRecordSchema} */
+type RuntimeInstanceRecord$1 = z.infer<typeof RuntimeInstanceRecordSchema>;
+/** Runtime process on whose behalf an ownership generation is taken. */
+declare const OwnershipOwnerInstanceSchema: z.ZodObject<{
+  instanceId: z.ZodString;
+}, z.core.$strip>;
+/** {@inheritDoc OwnershipOwnerInstanceSchema} */
+type OwnershipOwnerInstance = z.infer<typeof OwnershipOwnerInstanceSchema>;
+/** How many runtime processes may own claims on one machine. */
+declare const OwnershipTopologySchema: z.ZodEnum<{
+  "machine-exclusive": "machine-exclusive";
+  "shared-machine": "shared-machine";
+}>;
+/**
+ * Durable ownership state of one agent.
+ *
+ * `revision` and `currencyFence` are the two orderings a currency write is
+ * checked against, and they answer different questions:
+ * - `currencyFence` — *which generation* last wrote this currency. A write from
+ *   a lower fence is a stale owner and is refused outright.
+ * - `revision` — *which write* the caller read before computing its target. A
+ *   mismatch means the row moved under the caller within the same generation.
+ *
+ * `revision` is bumped exclusively by the ownership seam. Any other writer
+ * bumping it would make the compare-and-swap fail for reasons unrelated to
+ * currency, which is the same as not having it.
+ */
+declare const AgentSessionOwnershipRecordSchema: z.ZodObject<{
+  agentId: z.ZodString;
+  sessionId: z.ZodString;
+  currency: z.ZodObject<{
+    adapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionIdState: z.ZodEnum<{
+      confirmed: "confirmed";
+      moved: "moved";
+      inherited: "inherited";
+    }>;
+  }, z.core.$strip>;
+  revision: z.ZodNumber;
+  currencyFence: z.ZodNumber;
+  claims: z.ZodArray<z.ZodObject<{
+    machineId: z.ZodString;
+    adapterId: z.ZodString;
+    providerSessionId: z.ZodString;
+    claimId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+    claimedAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/** {@inheritDoc AgentSessionOwnershipRecordSchema} */
+type AgentSessionOwnershipRecord = z.infer<typeof AgentSessionOwnershipRecordSchema>;
+/**
+ * Request payload for `storage:sessionOwnership.claim`.
+ *
+ * One call is the whole reservation: it takes the claim and — when
+ * `designateLead` is supplied — designates the session's lead agent in the same
+ * transaction. Splitting those into two calls is what leaves the window where a
+ * provider session is owned by an agent the session does not yet call its lead,
+ * and a movement announced in that window has no legitimate writer.
+ */
+declare const SessionOwnershipClaimRequestSchema: z.ZodObject<{
+  machineId: z.ZodString;
+  adapterId: z.ZodString;
+  providerSessionId: z.ZodNullable<z.ZodString>;
+  adapterName: z.ZodString;
+  ownerInstance: z.ZodOptional<z.ZodObject<{
+    instanceId: z.ZodString;
+  }, z.core.$strip>>;
+  topology: z.ZodDefault<z.ZodEnum<{
+    "machine-exclusive": "machine-exclusive";
+    "shared-machine": "shared-machine";
+  }>>;
+  recoveryGuard: z.ZodOptional<z.ZodObject<{
+    expectedStatus: z.ZodEnum<{
+      idle: "idle";
+      active: "active";
+      starting: "starting";
+      dead: "dead";
+      disposed: "disposed";
+    }>;
+    expectedPreimage: z.ZodObject<{
+      status: z.ZodEnum<{
+        idle: "idle";
+        active: "active";
+        starting: "starting";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+      adapterId: z.ZodString;
+      binding: z.ZodOptional<z.ZodObject<{
+        adapterId: z.ZodString;
+        ownerMachineId: z.ZodString;
+        ownerInstanceId: z.ZodString;
+      }, z.core.$strip>>;
+      recoveryAttemptId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    expectedRevision: z.ZodNumber;
+    expectedCurrencyFence: z.ZodNumber;
+    expectedCurrency: z.ZodObject<{
+      adapterSessionId: z.ZodNullable<z.ZodString>;
+      currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+      currentAdapterSessionIdState: z.ZodEnum<{
+        confirmed: "confirmed";
+        moved: "moved";
+        inherited: "inherited";
+      }>;
+    }, z.core.$strip>;
+    ownerGeneration: z.ZodNullable<z.ZodObject<{
+      claimId: z.ZodString;
+      claimToken: z.ZodString;
+      fence: z.ZodNumber;
+      ownerInstanceId: z.ZodNullable<z.ZodString>;
+      status: z.ZodEnum<{
+        abandoned: "abandoned";
+        held: "held";
+        releasing: "releasing";
+      }>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  recoveryAttemptId: z.ZodOptional<z.ZodString>;
+  sessionId: z.ZodString;
+  agentId: z.ZodString;
+  claimToken: z.ZodString;
+  supersedes: z.ZodOptional<z.ZodObject<{
+    claimToken: z.ZodString;
+  }, z.core.$strip>>;
+  designateLead: z.ZodOptional<z.ZodObject<{
+    expectedLeadAgentId: z.ZodNullable<z.ZodString>;
+    clear: z.ZodOptional<z.ZodLiteral<true>>;
+    restore: z.ZodOptional<z.ZodLiteral<true>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipClaimRequestSchema} */
+type SessionOwnershipClaimRequest = z.infer<typeof SessionOwnershipClaimRequestSchema>;
+/**
+ * Validate and normalize an ownership claim at the storage trust boundary.
+ *
+ * Storage handlers call this even when bus validation is disabled so schema
+ * defaults and cross-field refinements remain part of the durable invariant.
+ * @param value - Untrusted claim request received by a storage handler.
+ * @returns The fully validated claim request with schema defaults applied.
+ */
+declare function normalizeSessionOwnershipClaimRequest$1(value: unknown): SessionOwnershipClaimRequest;
+declare const SessionOwnershipClaimResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  outcome: z.ZodLiteral<"claimed">;
+  claim: z.ZodNullable<z.ZodObject<{
+    machineId: z.ZodString;
+    adapterId: z.ZodString;
+    providerSessionId: z.ZodString;
+    claimId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+    claimedAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+  }, z.core.$strip>>;
+  recovery: z.ZodOptional<z.ZodObject<{
+    attemptId: z.ZodString;
+    preimage: z.ZodObject<{
+      status: z.ZodEnum<{
+        idle: "idle";
+        active: "active";
+        starting: "starting";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+      adapterId: z.ZodString;
+      binding: z.ZodOptional<z.ZodObject<{
+        adapterId: z.ZodString;
+        ownerMachineId: z.ZodString;
+        ownerInstanceId: z.ZodString;
+      }, z.core.$strip>>;
+      recoveryAttemptId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+  leadDesignated: z.ZodBoolean;
+  previousLeadAgentId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"idempotent">;
+  claim: z.ZodNullable<z.ZodObject<{
+    machineId: z.ZodString;
+    adapterId: z.ZodString;
+    providerSessionId: z.ZodString;
+    claimId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+    claimedAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+  }, z.core.$strip>>;
+  recovery: z.ZodOptional<z.ZodObject<{
+    attemptId: z.ZodString;
+    preimage: z.ZodObject<{
+      status: z.ZodEnum<{
+        idle: "idle";
+        active: "active";
+        starting: "starting";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+      adapterId: z.ZodString;
+      binding: z.ZodOptional<z.ZodObject<{
+        adapterId: z.ZodString;
+        ownerMachineId: z.ZodString;
+        ownerInstanceId: z.ZodString;
+      }, z.core.$strip>>;
+      recoveryAttemptId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+  leadDesignated: z.ZodBoolean;
+  previousLeadAgentId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"already-claimed">;
+  holder: z.ZodObject<{
+    machineId: z.ZodString;
+    adapterId: z.ZodString;
+    providerSessionId: z.ZodString;
+    claimId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+    claimedAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"agent-disposed">;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"session-not-active">;
+  status: z.ZodEnum<{
+    closed: "closed";
+    discovered: "discovered";
+    archived: "archived";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"lead-conflict">;
+  currentLeadAgentId: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"not-found">;
+  missing: z.ZodEnum<{
+    agent: "agent";
+    session: "session";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"currency-changed">;
+  revision: z.ZodNumber;
+  currencyFence: z.ZodNumber;
+  currency: z.ZodObject<{
+    adapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionIdState: z.ZodEnum<{
+      confirmed: "confirmed";
+      moved: "moved";
+      inherited: "inherited";
+    }>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"recovery-conflict">;
+  status: z.ZodEnum<{
+    idle: "idle";
+    active: "active";
+    starting: "starting";
+    dead: "dead";
+    disposed: "disposed";
+  }>;
+  ownerGeneration: z.ZodNullable<z.ZodObject<{
+    claimId: z.ZodString;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+  }, z.core.$strip>>;
+}, z.core.$strip>], "outcome">;
+/** {@inheritDoc SessionOwnershipClaimResponseSchema} */
+type SessionOwnershipClaimResult = z.infer<typeof SessionOwnershipClaimResponseSchema>;
+/**
+ * Request payload for `storage:sessionOwnership.settleCurrency`.
+ *
+ * The write is guarded twice, because two different things can be wrong. The
+ * `claimToken` + `fence` pair answers "may this caller write at all"; the
+ * `expectedRevision` answers "did the caller compute its target from the state
+ * it is overwriting". A settle that passes the first and fails the second is a
+ * lost race inside one generation, not a stale owner, and the caller's recovery
+ * differs accordingly.
+ */
+declare const SessionOwnershipSettleCurrencyRequestSchema: z.ZodObject<{
+  agentId: z.ZodString;
+  claimToken: z.ZodString;
+  fence: z.ZodNumber;
+  expectedRevision: z.ZodNumber;
+  target: z.ZodObject<{
+    currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionIdState: z.ZodEnum<{
+      confirmed: "confirmed";
+      moved: "moved";
+      inherited: "inherited";
+    }>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipSettleCurrencyRequestSchema} */
+type SessionOwnershipSettleCurrencyRequest = z.infer<typeof SessionOwnershipSettleCurrencyRequestSchema>;
+/**
+ * Result of `storage:sessionOwnership.settleCurrency`.
+ *
+ * `sessionSnapshotUpdated` reports whether the session row's currency was
+ * refreshed alongside the agent's. Storage decides that by reading the session's
+ * lead designation inside the same transaction as the write — a caller that
+ * checked lead-ness first and passed a flag would be acting on a read that the
+ * write no longer agrees with.
+ *
+ * That refresh publishes the settled currency **resolved onto the session row's
+ * own terms, not copied from `target`**, exactly as a lead designation does (see
+ * {@link SessionOwnershipClaimRequestSchema}'s `designateLead`): `inherited`
+ * points at the reading row's own `adapterSessionId`, and a lead's origin is
+ * generally not its session's, so a verbatim copy would leave the session
+ * resolving to its own origin while the lead resolves elsewhere. What the
+ * session row ends up carrying is what `resolveResumableAdapterSessionId` yields
+ * for the settled lead — so a settle of `inherited` can legitimately leave the
+ * session row reading `confirmed` or `moved`.
+ *
+ * A missing claim is `not-owner`, not `not-found`: the agent exists, the caller
+ * simply has no authority over it. Callers that need to report *who* owns it
+ * instead read the claim through `listClaims`.
+ *
+ * Authority is decided before order: a caller whose claim row is gone is
+ * `not-owner` even when its fence is also stale, because `superseded` names the
+ * generation that outranked it and there is no such generation to name. The
+ * authority a caller presents is the *pair* `claimToken` + `fence`, so a live
+ * claim carrying a different fence than the caller named is `not-owner` too —
+ * that pair never existed, and reporting `superseded` would have to name a
+ * `currentFence` that outranks nothing (it may even be below the caller's own).
+ *
+ * A claim is an ownership of an agent *in a session*, so a claim filed under a
+ * session the agent has since left is `not-owner` as well. Whole-record writes
+ * can move an agent between sessions; a generation taken while it was in the old
+ * one no longer represents any ownership of it, and settling under it would
+ * publish its currency into a session its holder was never part of.
+ * `release` deliberately does **not** apply that rule — see
+ * {@link SessionOwnershipReleaseRequestSchema}.
+ */
+declare const SessionOwnershipSettleCurrencyResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  outcome: z.ZodLiteral<"settled">;
+  revision: z.ZodNumber;
+  currency: z.ZodObject<{
+    adapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionIdState: z.ZodEnum<{
+      confirmed: "confirmed";
+      moved: "moved";
+      inherited: "inherited";
+    }>;
+  }, z.core.$strip>;
+  sessionSnapshotUpdated: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"idempotent">;
+  revision: z.ZodNumber;
+  currency: z.ZodObject<{
+    adapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionIdState: z.ZodEnum<{
+      confirmed: "confirmed";
+      moved: "moved";
+      inherited: "inherited";
+    }>;
+  }, z.core.$strip>;
+  sessionSnapshotUpdated: z.ZodLiteral<false>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"superseded">;
+  currentFence: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"currency-changed">;
+  revision: z.ZodNumber;
+  currency: z.ZodObject<{
+    adapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionIdState: z.ZodEnum<{
+      confirmed: "confirmed";
+      moved: "moved";
+      inherited: "inherited";
+    }>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"not-owner">;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"agent-disposed">;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"not-found">;
+}, z.core.$strip>], "outcome">;
+/** {@inheritDoc SessionOwnershipSettleCurrencyResponseSchema} */
+type SessionOwnershipSettleCurrencyResult = z.infer<typeof SessionOwnershipSettleCurrencyResponseSchema>;
+/**
+ * What the provider did with an agent's conversation.
+ *
+ * The two members differ in what they *know*, not in how far they got, and the
+ * difference decides whether a key may be freed. `confirmed` names a successor
+ * the provider acknowledged, so the generations the agent held before it are
+ * genuinely retired. `demote` says only that the conversation left, with no
+ * acknowledged successor — the provider may still be live under the ID being
+ * voided, so its claim is taken (or kept) rather than released.
+ */
+declare const OwnershipMovementSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"confirmed">;
+  providerSessionId: z.ZodString;
+  claimToken: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"demote">;
+  claimToken: z.ZodString;
+}, z.core.$strip>], "kind">;
+/** {@inheritDoc OwnershipMovementSchema} */
+type OwnershipMovement = z.infer<typeof OwnershipMovementSchema>;
+/**
+ * Request payload for `storage:sessionOwnership.settleMovement`.
+ *
+ * One call is the whole movement: acquire (or recognize) the successor
+ * generation, settle the agent's currency under it, retire the predecessors it
+ * replaces and refresh the session snapshot — in one transaction. Composed from
+ * `claim` + `settleCurrency` + `release` by a caller, the same act is three
+ * transactions with two windows in which a crash strands a key or publishes a
+ * currency no generation owns.
+ */
+declare const SessionOwnershipSettleMovementRequestSchema$1: z.ZodObject<{
+  machineId: z.ZodString;
+  adapterId: z.ZodString;
+  adapterName: z.ZodString;
+  ownerInstance: z.ZodOptional<z.ZodObject<{
+    instanceId: z.ZodString;
+  }, z.core.$strip>>;
+  topology: z.ZodDefault<z.ZodEnum<{
+    "machine-exclusive": "machine-exclusive";
+    "shared-machine": "shared-machine";
+  }>>;
+  sessionId: z.ZodString;
+  agentId: z.ZodString;
+  expectedRevision: z.ZodNumber;
+  movement: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"confirmed">;
+    providerSessionId: z.ZodString;
+    claimToken: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"demote">;
+    claimToken: z.ZodString;
+  }, z.core.$strip>], "kind">;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipSettleMovementRequestSchema} */
+type SessionOwnershipSettleMovementRequest = z.infer<typeof SessionOwnershipSettleMovementRequestSchema$1>;
+/**
+ * Result of `storage:sessionOwnership.settleMovement`.
+ *
+ * Every outcome other than `settled` leaves the store exactly as it was: the
+ * claims phase runs inside the same transaction as the settle, so a refusal
+ * reached after a generation was allocated rolls that allocation back with it.
+ *
+ * **The generation the response names is the one the settle wrote through**, not
+ * the one the caller sent. An agent that already held the target key is settled
+ * under the claim it already has, and the request's token names no row at all —
+ * so a caller that carried its own token into a later release would retire a
+ * generation that never existed and leave the real one blocking the key.
+ */
+declare const SessionOwnershipSettleMovementResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  outcome: z.ZodLiteral<"settled">;
+  revision: z.ZodNumber;
+  currency: z.ZodObject<{
+    adapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionIdState: z.ZodEnum<{
+      confirmed: "confirmed";
+      moved: "moved";
+      inherited: "inherited";
+    }>;
+  }, z.core.$strip>;
+  sessionSnapshotUpdated: z.ZodBoolean;
+  releasedProviderSessionIds: z.ZodArray<z.ZodString>;
+  claim: z.ZodObject<{
+    machineId: z.ZodString;
+    adapterId: z.ZodString;
+    providerSessionId: z.ZodString;
+    claimId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+    claimedAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"idempotent">;
+  revision: z.ZodNumber;
+  currency: z.ZodObject<{
+    adapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionIdState: z.ZodEnum<{
+      confirmed: "confirmed";
+      moved: "moved";
+      inherited: "inherited";
+    }>;
+  }, z.core.$strip>;
+  sessionSnapshotUpdated: z.ZodLiteral<false>;
+  claim: z.ZodNullable<z.ZodObject<{
+    machineId: z.ZodString;
+    adapterId: z.ZodString;
+    providerSessionId: z.ZodString;
+    claimId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+    claimedAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+  }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"already-claimed">;
+  holder: z.ZodObject<{
+    machineId: z.ZodString;
+    adapterId: z.ZodString;
+    providerSessionId: z.ZodString;
+    claimId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+    claimedAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"superseded">;
+  currentFence: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"currency-changed">;
+  revision: z.ZodNumber;
+  currency: z.ZodObject<{
+    adapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionIdState: z.ZodEnum<{
+      confirmed: "confirmed";
+      moved: "moved";
+      inherited: "inherited";
+    }>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"not-owner">;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"agent-disposed">;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"not-found">;
+}, z.core.$strip>], "outcome">;
+/** {@inheritDoc SessionOwnershipSettleMovementResponseSchema} */
+type SessionOwnershipSettleMovementResult = z.infer<typeof SessionOwnershipSettleMovementResponseSchema>;
+/**
+ * How a claim is given up.
+ *
+ * - `released` — the provider session is provably done with; the row is removed
+ *   and the key becomes claimable again.
+ * - `releasing` — teardown started but is not confirmed; the row stays and keeps
+ *   blocking.
+ * - `abandoned` — the owner failed after dispatching to the provider; the row
+ *   stays and keeps blocking until an explicit takeover names its token, or
+ *   until that same generation later confirms teardown with a `released` of its
+ *   own (see {@link AdapterSessionClaimStatusSchema}). Storage does not judge
+ *   whether that takeover is legitimate.
+ *
+ * Only the first frees the key. A failure after dispatch must never take that
+ * path: the provider process may still be alive, and a second owner attaching
+ * to a live conversation is the exact outcome this aggregate exists to prevent.
+ */
+declare const AdapterSessionClaimDispositionSchema: z.ZodEnum<{
+  released: "released";
+  abandoned: "abandoned";
+  releasing: "releasing";
+}>;
+/** {@inheritDoc AdapterSessionClaimDispositionSchema} */
+type AdapterSessionClaimDisposition = z.infer<typeof AdapterSessionClaimDispositionSchema>;
+/**
+ * Request payload for `storage:sessionOwnership.release`.
+ *
+ * The token and the agent are the whole of the authority, deliberately less than
+ * `settleCurrency` asks for: that op additionally requires the claim to be filed
+ * under the agent's *current* session, because it exercises the claim as
+ * authority over that agent's currency. Giving a claim up needs no authority
+ * beyond having been the one who took it. Demanding session membership here
+ * would strand exactly the claims that most need retiring — an agent moved to
+ * another session would leave its old generation unreleasable, blocking the
+ * ownership key against everyone, forever.
+ */
+declare const SessionOwnershipReleaseRequestSchema: z.ZodObject<{
+  agentId: z.ZodString;
+  claimToken: z.ZodString;
+  disposition: z.ZodEnum<{
+    released: "released";
+    abandoned: "abandoned";
+    releasing: "releasing";
+  }>;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipReleaseRequestSchema} */
+type SessionOwnershipReleaseRequest = z.infer<typeof SessionOwnershipReleaseRequestSchema>;
+/** Result of `storage:sessionOwnership.release`. */
+declare const SessionOwnershipReleaseResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  outcome: z.ZodLiteral<"released">;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"marked">;
+  claim: z.ZodObject<{
+    machineId: z.ZodString;
+    adapterId: z.ZodString;
+    providerSessionId: z.ZodString;
+    claimId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+    claimedAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"not-owner">;
+  holder: z.ZodObject<{
+    machineId: z.ZodString;
+    adapterId: z.ZodString;
+    providerSessionId: z.ZodString;
+    claimId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+    claimedAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"not-found">;
+}, z.core.$strip>], "outcome">;
+/** {@inheritDoc SessionOwnershipReleaseResponseSchema} */
+type SessionOwnershipReleaseResult = z.infer<typeof SessionOwnershipReleaseResponseSchema>;
+/**
+ * Request payload for `storage:sessionOwnership.releaseAgentClaims`.
+ *
+ * The plural of `release`, and not a convenience: **omitting `claimToken` is the
+ * teardown fan-out**, which exists because reading an agent's claims and
+ * releasing them one by one cannot see a claim taken in between — and an agent
+ * legitimately holds two mid-movement. One predicate over `agent_id` retires
+ * whatever is there at the instant the statement runs, which is the only shape
+ * that can be complete.
+ *
+ * Naming a token scopes the act to exactly one generation, which is the rollback
+ * form: a start that failed before dispatch must give up the generation it took
+ * and nothing else, because the agent may hold a second one from an unrelated
+ * in-flight movement.
+ *
+ * **Not `disposed`-guarded**, unlike every other ownership operation. Giving a
+ * claim up is the one act a removed agent must still perform; guarding it would
+ * strand exactly the claims that most need retiring.
+ */
+declare const SessionOwnershipReleaseAgentClaimsRequestSchema: z.ZodObject<{
+  agentId: z.ZodString;
+  claimToken: z.ZodOptional<z.ZodString>;
+  disposition: z.ZodEnum<{
+    released: "released";
+    abandoned: "abandoned";
+    releasing: "releasing";
+  }>;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipReleaseAgentClaimsRequestSchema} */
+type SessionOwnershipReleaseAgentClaimsRequest = z.infer<typeof SessionOwnershipReleaseAgentClaimsRequestSchema>;
+/**
+ * Result of `storage:sessionOwnership.releaseAgentClaims`.
+ *
+ * Not a discriminated union, because there is no failure to model: an agent with
+ * no claims — including one whose row is gone entirely — yields empty lists
+ * rather than an error, which is what makes teardown idempotent.
+ */
+declare const SessionOwnershipReleaseAgentClaimsResponseSchema: z.ZodObject<{
+  releasedProviderSessionIds: z.ZodArray<z.ZodString>;
+  markedClaims: z.ZodArray<z.ZodObject<{
+    machineId: z.ZodString;
+    adapterId: z.ZodString;
+    providerSessionId: z.ZodString;
+    claimId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodString;
+    agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+    claimedAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+  }, z.core.$strip>>;
+  claimTokenNotFound: z.ZodBoolean;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipReleaseAgentClaimsResponseSchema} */
+type SessionOwnershipReleaseAgentClaimsResult = z.infer<typeof SessionOwnershipReleaseAgentClaimsResponseSchema>;
+/**
+ * Request payload for `storage:sessionOwnership.listClaims`.
+ *
+ * `machineId` is mandatory because reconciliation is a per-machine act: a
+ * runtime may only reason about liveness of owners on its own machine, and a
+ * query that could span machines invites a takeover decision that has no
+ * evidence behind it.
+ */
+declare const SessionOwnershipListClaimsRequestSchema: z.ZodObject<{
+  machineId: z.ZodString;
+  adapterId: z.ZodOptional<z.ZodString>;
+  providerSessionId: z.ZodOptional<z.ZodString>;
+  statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+    abandoned: "abandoned";
+    held: "held";
+    releasing: "releasing";
+  }>>>;
+}, z.core.$strip>;
+/** {@inheritDoc SessionOwnershipListClaimsRequestSchema} */
+type SessionOwnershipListClaimsRequest = z.infer<typeof SessionOwnershipListClaimsRequestSchema>;
+/**
+ * Session ownership storage namespace.
+ *
+ * The durable seam of the session-ownership aggregate. Its invariant:
+ *
+ * A provider-native session has exactly one durable runtime owner within its
+ * machine/adapter namespace. Agent currency may only be changed by the current
+ * claim generation. Session currency is a persisted snapshot of the designated
+ * lead's currency.
+ *
+ * **Why a dedicated namespace.** `storage:session.update` is a partial-update
+ * surface with no notion of who is allowed to write. Widening it with
+ * compare-and-swap semantics would put a versioned-write contract on every
+ * existing caller, turning one seam's concurrency problem into a storage-wide
+ * one. The operations here are the narrow alternative: every one of them states
+ * its authority up front, and they are the only writers of the agent currency
+ * columns and of the claim table.
+ *
+ * **No second writer, including for the session snapshot.** The currency pair
+ * is on neither `storage:session.update` nor `storage:session.set`, so a
+ * snapshot written here can only be superseded by another write through this
+ * seam — one that had to present a claim generation to get in. That is what
+ * makes the snapshot's freshness derivable rather than hoped for.
+ *
+ * **Transactionality.** These handlers run multi-row writes inside
+ * `executeTransaction` from `@makaio/storage-drizzle`, which is a deliberate
+ * exception to the single-statement rule the other session storage handlers
+ * follow. That rule exists because a bare `db.transaction()` holds a write lock
+ * across await boundaries and deadlocks against concurrent handlers on the same
+ * connection; `executeTransaction` closes exactly that hole by serializing
+ * transaction callbacks per database handle before opening one, so a second
+ * transaction queues instead of colliding at `BEGIN`. The serialization is
+ * process-local by construction, which is why cross-process exclusivity is NOT
+ * derived from it: "exactly one winner" comes from the claim table's unique
+ * index over the ownership key, and the acquiring statement is an insert against
+ * that index rather than a read-then-write. The transaction supplies atomicity
+ * across the claim, agent and session rows; the index supplies exclusivity.
+ * @example
+ * ```typescript
+ * import { SessionOwnershipStorageSubjects } from '@makaio/framework/contracts';
+ *
+ * const result = await bus.request(SessionOwnershipStorageSubjects.claim, {
+ *   machineId, adapterId, adapterName, providerSessionId,
+ *   sessionId, agentId, claimToken,
+ *   designateLead: { expectedLeadAgentId: null },
+ * });
+ * // 'already-claimed' means another runtime owns the thread: degrade, never resume.
+ * ```
+ */
+declare const SessionOwnershipStorageNamespace: ContractStorageNamespaceDefinition<"sessionOwnership", {
+  /**
+   * Read one agent's durable ownership state.
+   *
+   * **Not a consistent snapshot**, in either direction: the agent row and its
+   * claims are read as two statements, so a concurrent claim or release can
+   * show up in one and not the other. A reader may therefore observe a claim
+   * whose fence the agent's `currencyFence` does not yet account for, or a
+   * `currencyFence` whose authoring claim has already been released. Both are
+   * legitimate instants of the aggregate; a reader that needs authority must
+   * ask for it (`settleCurrency`) rather than infer it from this read.
+   *
+   * Subject: `storage:sessionOwnership.read`
+   * Type: Request (RPC)
+   */
+  read: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      ownership: z.ZodNullable<z.ZodObject<{
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+        currency: z.ZodObject<{
+          adapterSessionId: z.ZodNullable<z.ZodString>;
+          currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+          currentAdapterSessionIdState: z.ZodEnum<{
+            confirmed: "confirmed";
+            moved: "moved";
+            inherited: "inherited";
+          }>;
+        }, z.core.$strip>;
+        revision: z.ZodNumber;
+        currencyFence: z.ZodNumber;
+        claims: z.ZodArray<z.ZodObject<{
+          machineId: z.ZodString;
+          adapterId: z.ZodString;
+          providerSessionId: z.ZodString;
+          claimId: z.ZodString;
+          adapterName: z.ZodString;
+          sessionId: z.ZodString;
+          agentId: z.ZodString;
+          ownerInstanceId: z.ZodNullable<z.ZodString>;
+          claimToken: z.ZodString;
+          fence: z.ZodNumber;
+          status: z.ZodEnum<{
+            abandoned: "abandoned";
+            held: "held";
+            releasing: "releasing";
+          }>;
+          claimedAt: z.ZodNumber;
+          updatedAt: z.ZodNumber;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Take or take over the ownership claim on a provider session, optionally
+   * designating the claiming agent as the session's lead in the same
+   * transaction.
+   *
+   * With `providerSessionId: null` it is the **keyless reservation**: no claim
+   * row at all, and the designation plus its currency mirror are the whole
+   * effect. That is the fresh-start shape — there is no provider identity to
+   * own yet, and the designation still has to be atomic and compare-and-swap.
+   *
+   * Subject: `storage:sessionOwnership.claim`
+   * Type: Request (RPC)
+   */
+  claim: {
+    request: z.ZodObject<{
+      machineId: z.ZodString;
+      adapterId: z.ZodString;
+      providerSessionId: z.ZodNullable<z.ZodString>;
+      adapterName: z.ZodString;
+      ownerInstance: z.ZodOptional<z.ZodObject<{
+        instanceId: z.ZodString;
+      }, z.core.$strip>>;
+      topology: z.ZodDefault<z.ZodEnum<{
+        "machine-exclusive": "machine-exclusive";
+        "shared-machine": "shared-machine";
+      }>>;
+      recoveryGuard: z.ZodOptional<z.ZodObject<{
+        expectedStatus: z.ZodEnum<{
+          idle: "idle";
+          active: "active";
+          starting: "starting";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        expectedPreimage: z.ZodObject<{
+          status: z.ZodEnum<{
+            idle: "idle";
+            active: "active";
+            starting: "starting";
+            dead: "dead";
+            disposed: "disposed";
+          }>;
+          adapterId: z.ZodString;
+          binding: z.ZodOptional<z.ZodObject<{
+            adapterId: z.ZodString;
+            ownerMachineId: z.ZodString;
+            ownerInstanceId: z.ZodString;
+          }, z.core.$strip>>;
+          recoveryAttemptId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        expectedRevision: z.ZodNumber;
+        expectedCurrencyFence: z.ZodNumber;
+        expectedCurrency: z.ZodObject<{
+          adapterSessionId: z.ZodNullable<z.ZodString>;
+          currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+          currentAdapterSessionIdState: z.ZodEnum<{
+            confirmed: "confirmed";
+            moved: "moved";
+            inherited: "inherited";
+          }>;
+        }, z.core.$strip>;
+        ownerGeneration: z.ZodNullable<z.ZodObject<{
+          claimId: z.ZodString;
+          claimToken: z.ZodString;
+          fence: z.ZodNumber;
+          ownerInstanceId: z.ZodNullable<z.ZodString>;
+          status: z.ZodEnum<{
+            abandoned: "abandoned";
+            held: "held";
+            releasing: "releasing";
+          }>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+      recoveryAttemptId: z.ZodOptional<z.ZodString>;
+      sessionId: z.ZodString;
+      agentId: z.ZodString;
+      claimToken: z.ZodString;
+      supersedes: z.ZodOptional<z.ZodObject<{
+        claimToken: z.ZodString;
+      }, z.core.$strip>>;
+      designateLead: z.ZodOptional<z.ZodObject<{
+        expectedLeadAgentId: z.ZodNullable<z.ZodString>;
+        clear: z.ZodOptional<z.ZodLiteral<true>>;
+        restore: z.ZodOptional<z.ZodLiteral<true>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      outcome: z.ZodLiteral<"claimed">;
+      claim: z.ZodNullable<z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>>;
+      recovery: z.ZodOptional<z.ZodObject<{
+        attemptId: z.ZodString;
+        preimage: z.ZodObject<{
+          status: z.ZodEnum<{
+            idle: "idle";
+            active: "active";
+            starting: "starting";
+            dead: "dead";
+            disposed: "disposed";
+          }>;
+          adapterId: z.ZodString;
+          binding: z.ZodOptional<z.ZodObject<{
+            adapterId: z.ZodString;
+            ownerMachineId: z.ZodString;
+            ownerInstanceId: z.ZodString;
+          }, z.core.$strip>>;
+          recoveryAttemptId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+      }, z.core.$strip>>;
+      leadDesignated: z.ZodBoolean;
+      previousLeadAgentId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"idempotent">;
+      claim: z.ZodNullable<z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>>;
+      recovery: z.ZodOptional<z.ZodObject<{
+        attemptId: z.ZodString;
+        preimage: z.ZodObject<{
+          status: z.ZodEnum<{
+            idle: "idle";
+            active: "active";
+            starting: "starting";
+            dead: "dead";
+            disposed: "disposed";
+          }>;
+          adapterId: z.ZodString;
+          binding: z.ZodOptional<z.ZodObject<{
+            adapterId: z.ZodString;
+            ownerMachineId: z.ZodString;
+            ownerInstanceId: z.ZodString;
+          }, z.core.$strip>>;
+          recoveryAttemptId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+      }, z.core.$strip>>;
+      leadDesignated: z.ZodBoolean;
+      previousLeadAgentId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"already-claimed">;
+      holder: z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"agent-disposed">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"session-not-active">;
+      status: z.ZodEnum<{
+        closed: "closed";
+        discovered: "discovered";
+        archived: "archived";
+      }>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"lead-conflict">;
+      currentLeadAgentId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-found">;
+      missing: z.ZodEnum<{
+        agent: "agent";
+        session: "session";
+      }>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"currency-changed">;
+      revision: z.ZodNumber;
+      currencyFence: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"recovery-conflict">;
+      status: z.ZodEnum<{
+        idle: "idle";
+        active: "active";
+        starting: "starting";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+      ownerGeneration: z.ZodNullable<z.ZodObject<{
+        claimId: z.ZodString;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>], "outcome">;
+  }; /** Terminalize a recovery attempt under its opaque attempt fence. */
+  finalizeRecovery: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      attemptId: z.ZodString;
+      binding: z.ZodObject<{
+        adapterId: z.ZodString;
+        ownerMachineId: z.ZodString;
+        ownerInstanceId: z.ZodString;
+      }, z.core.$strip>;
+      action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"rollback">;
+        preimage: z.ZodObject<{
+          status: z.ZodEnum<{
+            idle: "idle";
+            active: "active";
+            starting: "starting";
+            dead: "dead";
+            disposed: "disposed";
+          }>;
+          adapterId: z.ZodString;
+          binding: z.ZodOptional<z.ZodObject<{
+            adapterId: z.ZodString;
+            ownerMachineId: z.ZodString;
+            ownerInstanceId: z.ZodString;
+          }, z.core.$strip>>;
+          recoveryAttemptId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"succeeded">;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+      }, z.core.$strip>], "kind">;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      applied: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * Write an agent's adapter-session currency under a claim generation, and
+   * mirror it onto the session row when the agent is the designated lead.
+   *
+   * What is settled here is what a restart resumes: the resume-identity path
+   * resolves an agent's currency from this row whenever it has been settled,
+   * and falls back to the session row only for rows written before the agent
+   * row could carry currency at all.
+   *
+   * Subject: `storage:sessionOwnership.settleCurrency`
+   * Type: Request (RPC)
+   */
+  settleCurrency: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      claimToken: z.ZodString;
+      fence: z.ZodNumber;
+      expectedRevision: z.ZodNumber;
+      target: z.ZodObject<{
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      outcome: z.ZodLiteral<"settled">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+      sessionSnapshotUpdated: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"idempotent">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+      sessionSnapshotUpdated: z.ZodLiteral<false>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"superseded">;
+      currentFence: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"currency-changed">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-owner">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"agent-disposed">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-found">;
+    }, z.core.$strip>], "outcome">;
+  };
+  /**
+   * Record a provider-session movement in full: acquire or recognize the
+   * successor generation, settle the agent's currency under it, retire the
+   * predecessors it replaces, and mirror the result onto the session row —
+   * all in one transaction.
+   *
+   * The composite `settleCurrency` exists inside. Callers use this one;
+   * `settleCurrency` remains the single-step primitive the claim/settle
+   * interleavings are exercised through.
+   *
+   * Subject: `storage:sessionOwnership.settleMovement`
+   * Type: Request (RPC)
+   */
+  settleMovement: {
+    request: z.ZodObject<{
+      machineId: z.ZodString;
+      adapterId: z.ZodString;
+      adapterName: z.ZodString;
+      ownerInstance: z.ZodOptional<z.ZodObject<{
+        instanceId: z.ZodString;
+      }, z.core.$strip>>;
+      topology: z.ZodDefault<z.ZodEnum<{
+        "machine-exclusive": "machine-exclusive";
+        "shared-machine": "shared-machine";
+      }>>;
+      sessionId: z.ZodString;
+      agentId: z.ZodString;
+      expectedRevision: z.ZodNumber;
+      movement: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"confirmed">;
+        providerSessionId: z.ZodString;
+        claimToken: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"demote">;
+        claimToken: z.ZodString;
+      }, z.core.$strip>], "kind">;
+    }, z.core.$strip>;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      outcome: z.ZodLiteral<"settled">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+      sessionSnapshotUpdated: z.ZodBoolean;
+      releasedProviderSessionIds: z.ZodArray<z.ZodString>;
+      claim: z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"idempotent">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+      sessionSnapshotUpdated: z.ZodLiteral<false>;
+      claim: z.ZodNullable<z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"already-claimed">;
+      holder: z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"superseded">;
+      currentFence: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"currency-changed">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-owner">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"agent-disposed">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-found">;
+    }, z.core.$strip>], "outcome">;
+  };
+  /**
+   * Give up a claim — freeing the ownership key only on a clean release.
+   *
+   * Subject: `storage:sessionOwnership.release`
+   * Type: Request (RPC)
+   */
+  release: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      claimToken: z.ZodString;
+      disposition: z.ZodEnum<{
+        released: "released";
+        abandoned: "abandoned";
+        releasing: "releasing";
+      }>;
+    }, z.core.$strip>;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      outcome: z.ZodLiteral<"released">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"marked">;
+      claim: z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-owner">;
+      holder: z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-found">;
+    }, z.core.$strip>], "outcome">;
+  };
+  /**
+   * Give up every claim an agent holds, or exactly one of them, in a single
+   * statement — the teardown fan-out and the reservation rollback.
+   *
+   * Subject: `storage:sessionOwnership.releaseAgentClaims`
+   * Type: Request (RPC)
+   */
+  releaseAgentClaims: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      claimToken: z.ZodOptional<z.ZodString>;
+      disposition: z.ZodEnum<{
+        released: "released";
+        abandoned: "abandoned";
+        releasing: "releasing";
+      }>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      releasedProviderSessionIds: z.ZodArray<z.ZodString>;
+      markedClaims: z.ZodArray<z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>>;
+      claimTokenNotFound: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * List the claims recorded for a machine — the read reconciliation and
+   * ownership diagnostics run on.
+   *
+   * Subject: `storage:sessionOwnership.listClaims`
+   * Type: Request (RPC)
+   */
+  listClaims: {
+    request: z.ZodObject<{
+      machineId: z.ZodString;
+      adapterId: z.ZodOptional<z.ZodString>;
+      providerSessionId: z.ZodOptional<z.ZodString>;
+      statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        abandoned: "abandoned";
+        held: "held";
+        releasing: "releasing";
+      }>>>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      claims: z.ZodArray<z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Stamp every row for a runtime process as retired without releasing its
+   * claims. Repeating the operation is idempotent.
+   *
+   * Subject: `storage:sessionOwnership.retireInstance`
+   * Type: Request (RPC)
+   */
+  retireInstance: {
+    request: z.ZodObject<{
+      instanceId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      retiredMachines: z.ZodNumber;
+    }, z.core.$strip>;
+  };
+  /**
+   * Read one runtime-instance row for diagnostics only.
+   *
+   * Subject: `storage:sessionOwnership.getRuntimeInstance`
+   * Type: Request (RPC)
+   */
+  getRuntimeInstance: {
+    request: z.ZodObject<{
+      instanceId: z.ZodString;
+      machineId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      instance: z.ZodNullable<z.ZodObject<{
+        instanceId: z.ZodString;
+        machineId: z.ZodString;
+        incarnation: z.ZodNumber;
+        startedAt: z.ZodNumber;
+        retiredAt: z.ZodNullable<z.ZodNumber>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+}, Record<string, never>>;
+/**
+ * Typed subjects for session ownership storage operations.
+ */
+declare const SessionOwnershipStorageSubjects$1: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSubjectDefinitions<"storage:sessionOwnership", {
+  /**
+   * Read one agent's durable ownership state.
+   *
+   * **Not a consistent snapshot**, in either direction: the agent row and its
+   * claims are read as two statements, so a concurrent claim or release can
+   * show up in one and not the other. A reader may therefore observe a claim
+   * whose fence the agent's `currencyFence` does not yet account for, or a
+   * `currencyFence` whose authoring claim has already been released. Both are
+   * legitimate instants of the aggregate; a reader that needs authority must
+   * ask for it (`settleCurrency`) rather than infer it from this read.
+   *
+   * Subject: `storage:sessionOwnership.read`
+   * Type: Request (RPC)
+   */
+  read: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      ownership: z.ZodNullable<z.ZodObject<{
+        agentId: z.ZodString;
+        sessionId: z.ZodString;
+        currency: z.ZodObject<{
+          adapterSessionId: z.ZodNullable<z.ZodString>;
+          currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+          currentAdapterSessionIdState: z.ZodEnum<{
+            confirmed: "confirmed";
+            moved: "moved";
+            inherited: "inherited";
+          }>;
+        }, z.core.$strip>;
+        revision: z.ZodNumber;
+        currencyFence: z.ZodNumber;
+        claims: z.ZodArray<z.ZodObject<{
+          machineId: z.ZodString;
+          adapterId: z.ZodString;
+          providerSessionId: z.ZodString;
+          claimId: z.ZodString;
+          adapterName: z.ZodString;
+          sessionId: z.ZodString;
+          agentId: z.ZodString;
+          ownerInstanceId: z.ZodNullable<z.ZodString>;
+          claimToken: z.ZodString;
+          fence: z.ZodNumber;
+          status: z.ZodEnum<{
+            abandoned: "abandoned";
+            held: "held";
+            releasing: "releasing";
+          }>;
+          claimedAt: z.ZodNumber;
+          updatedAt: z.ZodNumber;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Take or take over the ownership claim on a provider session, optionally
+   * designating the claiming agent as the session's lead in the same
+   * transaction.
+   *
+   * With `providerSessionId: null` it is the **keyless reservation**: no claim
+   * row at all, and the designation plus its currency mirror are the whole
+   * effect. That is the fresh-start shape — there is no provider identity to
+   * own yet, and the designation still has to be atomic and compare-and-swap.
+   *
+   * Subject: `storage:sessionOwnership.claim`
+   * Type: Request (RPC)
+   */
+  claim: {
+    request: z.ZodObject<{
+      machineId: z.ZodString;
+      adapterId: z.ZodString;
+      providerSessionId: z.ZodNullable<z.ZodString>;
+      adapterName: z.ZodString;
+      ownerInstance: z.ZodOptional<z.ZodObject<{
+        instanceId: z.ZodString;
+      }, z.core.$strip>>;
+      topology: z.ZodDefault<z.ZodEnum<{
+        "machine-exclusive": "machine-exclusive";
+        "shared-machine": "shared-machine";
+      }>>;
+      recoveryGuard: z.ZodOptional<z.ZodObject<{
+        expectedStatus: z.ZodEnum<{
+          idle: "idle";
+          active: "active";
+          starting: "starting";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        expectedPreimage: z.ZodObject<{
+          status: z.ZodEnum<{
+            idle: "idle";
+            active: "active";
+            starting: "starting";
+            dead: "dead";
+            disposed: "disposed";
+          }>;
+          adapterId: z.ZodString;
+          binding: z.ZodOptional<z.ZodObject<{
+            adapterId: z.ZodString;
+            ownerMachineId: z.ZodString;
+            ownerInstanceId: z.ZodString;
+          }, z.core.$strip>>;
+          recoveryAttemptId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        expectedRevision: z.ZodNumber;
+        expectedCurrencyFence: z.ZodNumber;
+        expectedCurrency: z.ZodObject<{
+          adapterSessionId: z.ZodNullable<z.ZodString>;
+          currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+          currentAdapterSessionIdState: z.ZodEnum<{
+            confirmed: "confirmed";
+            moved: "moved";
+            inherited: "inherited";
+          }>;
+        }, z.core.$strip>;
+        ownerGeneration: z.ZodNullable<z.ZodObject<{
+          claimId: z.ZodString;
+          claimToken: z.ZodString;
+          fence: z.ZodNumber;
+          ownerInstanceId: z.ZodNullable<z.ZodString>;
+          status: z.ZodEnum<{
+            abandoned: "abandoned";
+            held: "held";
+            releasing: "releasing";
+          }>;
+        }, z.core.$strip>>;
+      }, z.core.$strip>>;
+      recoveryAttemptId: z.ZodOptional<z.ZodString>;
+      sessionId: z.ZodString;
+      agentId: z.ZodString;
+      claimToken: z.ZodString;
+      supersedes: z.ZodOptional<z.ZodObject<{
+        claimToken: z.ZodString;
+      }, z.core.$strip>>;
+      designateLead: z.ZodOptional<z.ZodObject<{
+        expectedLeadAgentId: z.ZodNullable<z.ZodString>;
+        clear: z.ZodOptional<z.ZodLiteral<true>>;
+        restore: z.ZodOptional<z.ZodLiteral<true>>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      outcome: z.ZodLiteral<"claimed">;
+      claim: z.ZodNullable<z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>>;
+      recovery: z.ZodOptional<z.ZodObject<{
+        attemptId: z.ZodString;
+        preimage: z.ZodObject<{
+          status: z.ZodEnum<{
+            idle: "idle";
+            active: "active";
+            starting: "starting";
+            dead: "dead";
+            disposed: "disposed";
+          }>;
+          adapterId: z.ZodString;
+          binding: z.ZodOptional<z.ZodObject<{
+            adapterId: z.ZodString;
+            ownerMachineId: z.ZodString;
+            ownerInstanceId: z.ZodString;
+          }, z.core.$strip>>;
+          recoveryAttemptId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+      }, z.core.$strip>>;
+      leadDesignated: z.ZodBoolean;
+      previousLeadAgentId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"idempotent">;
+      claim: z.ZodNullable<z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>>;
+      recovery: z.ZodOptional<z.ZodObject<{
+        attemptId: z.ZodString;
+        preimage: z.ZodObject<{
+          status: z.ZodEnum<{
+            idle: "idle";
+            active: "active";
+            starting: "starting";
+            dead: "dead";
+            disposed: "disposed";
+          }>;
+          adapterId: z.ZodString;
+          binding: z.ZodOptional<z.ZodObject<{
+            adapterId: z.ZodString;
+            ownerMachineId: z.ZodString;
+            ownerInstanceId: z.ZodString;
+          }, z.core.$strip>>;
+          recoveryAttemptId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+      }, z.core.$strip>>;
+      leadDesignated: z.ZodBoolean;
+      previousLeadAgentId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"already-claimed">;
+      holder: z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"agent-disposed">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"session-not-active">;
+      status: z.ZodEnum<{
+        closed: "closed";
+        discovered: "discovered";
+        archived: "archived";
+      }>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"lead-conflict">;
+      currentLeadAgentId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-found">;
+      missing: z.ZodEnum<{
+        agent: "agent";
+        session: "session";
+      }>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"currency-changed">;
+      revision: z.ZodNumber;
+      currencyFence: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"recovery-conflict">;
+      status: z.ZodEnum<{
+        idle: "idle";
+        active: "active";
+        starting: "starting";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+      ownerGeneration: z.ZodNullable<z.ZodObject<{
+        claimId: z.ZodString;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>], "outcome">;
+  }; /** Terminalize a recovery attempt under its opaque attempt fence. */
+  finalizeRecovery: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      attemptId: z.ZodString;
+      binding: z.ZodObject<{
+        adapterId: z.ZodString;
+        ownerMachineId: z.ZodString;
+        ownerInstanceId: z.ZodString;
+      }, z.core.$strip>;
+      action: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"rollback">;
+        preimage: z.ZodObject<{
+          status: z.ZodEnum<{
+            idle: "idle";
+            active: "active";
+            starting: "starting";
+            dead: "dead";
+            disposed: "disposed";
+          }>;
+          adapterId: z.ZodString;
+          binding: z.ZodOptional<z.ZodObject<{
+            adapterId: z.ZodString;
+            ownerMachineId: z.ZodString;
+            ownerInstanceId: z.ZodString;
+          }, z.core.$strip>>;
+          recoveryAttemptId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"succeeded">;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"failed">;
+      }, z.core.$strip>], "kind">;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      applied: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * Write an agent's adapter-session currency under a claim generation, and
+   * mirror it onto the session row when the agent is the designated lead.
+   *
+   * What is settled here is what a restart resumes: the resume-identity path
+   * resolves an agent's currency from this row whenever it has been settled,
+   * and falls back to the session row only for rows written before the agent
+   * row could carry currency at all.
+   *
+   * Subject: `storage:sessionOwnership.settleCurrency`
+   * Type: Request (RPC)
+   */
+  settleCurrency: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      claimToken: z.ZodString;
+      fence: z.ZodNumber;
+      expectedRevision: z.ZodNumber;
+      target: z.ZodObject<{
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      outcome: z.ZodLiteral<"settled">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+      sessionSnapshotUpdated: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"idempotent">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+      sessionSnapshotUpdated: z.ZodLiteral<false>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"superseded">;
+      currentFence: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"currency-changed">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-owner">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"agent-disposed">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-found">;
+    }, z.core.$strip>], "outcome">;
+  };
+  /**
+   * Record a provider-session movement in full: acquire or recognize the
+   * successor generation, settle the agent's currency under it, retire the
+   * predecessors it replaces, and mirror the result onto the session row —
+   * all in one transaction.
+   *
+   * The composite `settleCurrency` exists inside. Callers use this one;
+   * `settleCurrency` remains the single-step primitive the claim/settle
+   * interleavings are exercised through.
+   *
+   * Subject: `storage:sessionOwnership.settleMovement`
+   * Type: Request (RPC)
+   */
+  settleMovement: {
+    request: z.ZodObject<{
+      machineId: z.ZodString;
+      adapterId: z.ZodString;
+      adapterName: z.ZodString;
+      ownerInstance: z.ZodOptional<z.ZodObject<{
+        instanceId: z.ZodString;
+      }, z.core.$strip>>;
+      topology: z.ZodDefault<z.ZodEnum<{
+        "machine-exclusive": "machine-exclusive";
+        "shared-machine": "shared-machine";
+      }>>;
+      sessionId: z.ZodString;
+      agentId: z.ZodString;
+      expectedRevision: z.ZodNumber;
+      movement: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"confirmed">;
+        providerSessionId: z.ZodString;
+        claimToken: z.ZodString;
+      }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"demote">;
+        claimToken: z.ZodString;
+      }, z.core.$strip>], "kind">;
+    }, z.core.$strip>;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      outcome: z.ZodLiteral<"settled">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+      sessionSnapshotUpdated: z.ZodBoolean;
+      releasedProviderSessionIds: z.ZodArray<z.ZodString>;
+      claim: z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"idempotent">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+      sessionSnapshotUpdated: z.ZodLiteral<false>;
+      claim: z.ZodNullable<z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"already-claimed">;
+      holder: z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"superseded">;
+      currentFence: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"currency-changed">;
+      revision: z.ZodNumber;
+      currency: z.ZodObject<{
+        adapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+        currentAdapterSessionIdState: z.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-owner">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"agent-disposed">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-found">;
+    }, z.core.$strip>], "outcome">;
+  };
+  /**
+   * Give up a claim — freeing the ownership key only on a clean release.
+   *
+   * Subject: `storage:sessionOwnership.release`
+   * Type: Request (RPC)
+   */
+  release: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      claimToken: z.ZodString;
+      disposition: z.ZodEnum<{
+        released: "released";
+        abandoned: "abandoned";
+        releasing: "releasing";
+      }>;
+    }, z.core.$strip>;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      outcome: z.ZodLiteral<"released">;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"marked">;
+      claim: z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-owner">;
+      holder: z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+      outcome: z.ZodLiteral<"not-found">;
+    }, z.core.$strip>], "outcome">;
+  };
+  /**
+   * Give up every claim an agent holds, or exactly one of them, in a single
+   * statement — the teardown fan-out and the reservation rollback.
+   *
+   * Subject: `storage:sessionOwnership.releaseAgentClaims`
+   * Type: Request (RPC)
+   */
+  releaseAgentClaims: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      claimToken: z.ZodOptional<z.ZodString>;
+      disposition: z.ZodEnum<{
+        released: "released";
+        abandoned: "abandoned";
+        releasing: "releasing";
+      }>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      releasedProviderSessionIds: z.ZodArray<z.ZodString>;
+      markedClaims: z.ZodArray<z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>>;
+      claimTokenNotFound: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * List the claims recorded for a machine — the read reconciliation and
+   * ownership diagnostics run on.
+   *
+   * Subject: `storage:sessionOwnership.listClaims`
+   * Type: Request (RPC)
+   */
+  listClaims: {
+    request: z.ZodObject<{
+      machineId: z.ZodString;
+      adapterId: z.ZodOptional<z.ZodString>;
+      providerSessionId: z.ZodOptional<z.ZodString>;
+      statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        abandoned: "abandoned";
+        held: "held";
+        releasing: "releasing";
+      }>>>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      claims: z.ZodArray<z.ZodObject<{
+        machineId: z.ZodString;
+        adapterId: z.ZodString;
+        providerSessionId: z.ZodString;
+        claimId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        agentId: z.ZodString;
+        ownerInstanceId: z.ZodNullable<z.ZodString>;
+        claimToken: z.ZodString;
+        fence: z.ZodNumber;
+        status: z.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+        claimedAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Stamp every row for a runtime process as retired without releasing its
+   * claims. Repeating the operation is idempotent.
+   *
+   * Subject: `storage:sessionOwnership.retireInstance`
+   * Type: Request (RPC)
+   */
+  retireInstance: {
+    request: z.ZodObject<{
+      instanceId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      retiredMachines: z.ZodNumber;
+    }, z.core.$strip>;
+  };
+  /**
+   * Read one runtime-instance row for diagnostics only.
+   *
+   * Subject: `storage:sessionOwnership.getRuntimeInstance`
+   * Type: Request (RPC)
+   */
+  getRuntimeInstance: {
+    request: z.ZodObject<{
+      instanceId: z.ZodString;
+      machineId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      instance: z.ZodNullable<z.ZodObject<{
+        instanceId: z.ZodString;
+        machineId: z.ZodString;
+        incarnation: z.ZodNumber;
+        startedAt: z.ZodNumber;
+        retiredAt: z.ZodNullable<z.ZodNumber>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+}>, "storage:sessionOwnership">;
+//#endregion
 //#region core/contracts/src/session/schemas/ownership.d.ts
-/**
- * How many runtime processes may own claims on one machine.
- *
- * Only `machine-exclusive` licenses "no adapter answers for this instance" as
- * evidence that an owner is gone: with peers on the same machine, an
- * unanswered probe means "not mine", never "nobody's". The default is
- * `shared-machine` everywhere, because neither the desktop runtime nor the
- * isolated workflow runtime can prove exclusivity while workflow workers and
- * relay peers may host adapters of their own.
- */
-declare const OwnershipTopologySchema: z.ZodEnum<{
-  "machine-exclusive": "machine-exclusive";
-  "shared-machine": "shared-machine";
-}>;
 /** {@inheritDoc OwnershipTopologySchema} */
 type OwnershipTopology$1 = z.infer<typeof OwnershipTopologySchema>;
 /**
@@ -4586,6 +7169,7 @@ declare const SessionOwnershipPrincipalSchema: z.ZodObject<{
   agentId: z.ZodString;
   adapterId: z.ZodString;
   adapterName: z.ZodString;
+  ownerInstanceId: z.ZodString;
   machineId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /** {@inheritDoc SessionOwnershipPrincipalSchema} */
@@ -4605,25 +7189,108 @@ declare const SessionOwnershipReserveStartServiceRequestSchema: z.ZodObject<{
   agentId: z.ZodString;
   adapterId: z.ZodString;
   adapterName: z.ZodString;
+  ownerInstanceId: z.ZodString;
   machineId: z.ZodOptional<z.ZodString>;
   role: z.ZodEnum<{
     lead: "lead";
     member: "member";
   }>;
   resumeProviderSessionId: z.ZodNullable<z.ZodString>;
+  claimToken: z.ZodString;
+  recoveryGuard: z.ZodOptional<z.ZodObject<{
+    expectedStatus: z.ZodEnum<{
+      idle: "idle";
+      active: "active";
+      starting: "starting";
+      dead: "dead";
+      disposed: "disposed";
+    }>;
+    expectedPreimage: z.ZodObject<{
+      status: z.ZodEnum<{
+        idle: "idle";
+        active: "active";
+        starting: "starting";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+      adapterId: z.ZodString;
+      binding: z.ZodOptional<z.ZodObject<{
+        adapterId: z.ZodString;
+        ownerMachineId: z.ZodString;
+        ownerInstanceId: z.ZodString;
+      }, z.core.$strip>>;
+      recoveryAttemptId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    expectedRevision: z.ZodNumber;
+    expectedCurrencyFence: z.ZodNumber;
+    expectedCurrency: z.ZodObject<{
+      adapterSessionId: z.ZodNullable<z.ZodString>;
+      currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+      currentAdapterSessionIdState: z.ZodEnum<{
+        confirmed: "confirmed";
+        moved: "moved";
+        inherited: "inherited";
+      }>;
+    }, z.core.$strip>;
+    ownerGeneration: z.ZodNullable<z.ZodObject<{
+      claimId: z.ZodString;
+      claimToken: z.ZodString;
+      fence: z.ZodNumber;
+      ownerInstanceId: z.ZodNullable<z.ZodString>;
+      status: z.ZodEnum<{
+        abandoned: "abandoned";
+        held: "held";
+        releasing: "releasing";
+      }>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  recoveryAttemptId: z.ZodOptional<z.ZodString>;
   expectedLeadAgentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strip>;
 /** {@inheritDoc SessionOwnershipReserveStartServiceRequestSchema} */
 type SessionOwnershipReserveStartServiceRequest = z.infer<typeof SessionOwnershipReserveStartServiceRequestSchema>;
+/**
+ * Validate and normalize a start reservation at the service trust boundary.
+ * @param value - Untrusted reservation request received by the authority.
+ * @returns The fully validated reservation request.
+ */
+declare function normalizeSessionOwnershipReserveStartServiceRequest$1(value: unknown): SessionOwnershipReserveStartServiceRequest;
 /**
  * What a committed reservation gives the caller to act — and to roll back — on.
+ *
+ * A provider-session claim always carries the resolved machine identity that
+ * names its key. A designation-only reservation may not: its storage request
+ * uses an inert schema filler, which is not a runtime identity and must never
+ * be forwarded to a settlement or persisted as a runtime owner.
  */
-declare const SessionOwnershipReservationSchema: z.ZodObject<{
+declare const SessionOwnershipReservationSchema: z.ZodUnion<readonly [z.ZodObject<{
   agentId: z.ZodString;
   sessionId: z.ZodString;
-  machineId: z.ZodString;
   adapterId: z.ZodString;
-  claim: z.ZodNullable<z.ZodObject<{
+  ownerInstanceId: z.ZodString;
+  leadDesignated: z.ZodBoolean;
+  previousLeadAgentId: z.ZodNullable<z.ZodString>;
+  recovery: z.ZodOptional<z.ZodObject<{
+    attemptId: z.ZodString;
+    preimage: z.ZodObject<{
+      status: z.ZodEnum<{
+        idle: "idle";
+        active: "active";
+        starting: "starting";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+      adapterId: z.ZodString;
+      binding: z.ZodOptional<z.ZodObject<{
+        adapterId: z.ZodString;
+        ownerMachineId: z.ZodString;
+        ownerInstanceId: z.ZodString;
+      }, z.core.$strip>>;
+      recoveryAttemptId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+  machineId: z.ZodString;
+  claim: z.ZodObject<{
     machineId: z.ZodString;
     adapterId: z.ZodString;
     providerSessionId: z.ZodString;
@@ -4631,6 +7298,7 @@ declare const SessionOwnershipReservationSchema: z.ZodObject<{
     adapterName: z.ZodString;
     sessionId: z.ZodString;
     agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
     claimToken: z.ZodString;
     fence: z.ZodNumber;
     status: z.ZodEnum<{
@@ -4640,10 +7308,36 @@ declare const SessionOwnershipReservationSchema: z.ZodObject<{
     }>;
     claimedAt: z.ZodNumber;
     updatedAt: z.ZodNumber;
-  }, z.core.$strip>>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  agentId: z.ZodString;
+  sessionId: z.ZodString;
+  adapterId: z.ZodString;
+  ownerInstanceId: z.ZodString;
   leadDesignated: z.ZodBoolean;
   previousLeadAgentId: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
+  recovery: z.ZodOptional<z.ZodObject<{
+    attemptId: z.ZodString;
+    preimage: z.ZodObject<{
+      status: z.ZodEnum<{
+        idle: "idle";
+        active: "active";
+        starting: "starting";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+      adapterId: z.ZodString;
+      binding: z.ZodOptional<z.ZodObject<{
+        adapterId: z.ZodString;
+        ownerMachineId: z.ZodString;
+        ownerInstanceId: z.ZodString;
+      }, z.core.$strip>>;
+      recoveryAttemptId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>>;
+  machineId: z.ZodOptional<z.ZodString>;
+  claim: z.ZodNull;
+}, z.core.$strip>]>;
 /** {@inheritDoc SessionOwnershipReservationSchema} */
 type SessionOwnershipReservation = z.infer<typeof SessionOwnershipReservationSchema>;
 /**
@@ -4656,12 +7350,34 @@ type SessionOwnershipReservation = z.infer<typeof SessionOwnershipReservationSch
  */
 declare const SessionOwnershipReserveStartServiceResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   outcome: z.ZodLiteral<"reserved">;
-  reservation: z.ZodObject<{
+  reservation: z.ZodUnion<readonly [z.ZodObject<{
     agentId: z.ZodString;
     sessionId: z.ZodString;
-    machineId: z.ZodString;
     adapterId: z.ZodString;
-    claim: z.ZodNullable<z.ZodObject<{
+    ownerInstanceId: z.ZodString;
+    leadDesignated: z.ZodBoolean;
+    previousLeadAgentId: z.ZodNullable<z.ZodString>;
+    recovery: z.ZodOptional<z.ZodObject<{
+      attemptId: z.ZodString;
+      preimage: z.ZodObject<{
+        status: z.ZodEnum<{
+          idle: "idle";
+          active: "active";
+          starting: "starting";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        adapterId: z.ZodString;
+        binding: z.ZodOptional<z.ZodObject<{
+          adapterId: z.ZodString;
+          ownerMachineId: z.ZodString;
+          ownerInstanceId: z.ZodString;
+        }, z.core.$strip>>;
+        recoveryAttemptId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+    machineId: z.ZodString;
+    claim: z.ZodObject<{
       machineId: z.ZodString;
       adapterId: z.ZodString;
       providerSessionId: z.ZodString;
@@ -4669,6 +7385,7 @@ declare const SessionOwnershipReserveStartServiceResponseSchema: z.ZodDiscrimina
       adapterName: z.ZodString;
       sessionId: z.ZodString;
       agentId: z.ZodString;
+      ownerInstanceId: z.ZodNullable<z.ZodString>;
       claimToken: z.ZodString;
       fence: z.ZodNumber;
       status: z.ZodEnum<{
@@ -4678,10 +7395,36 @@ declare const SessionOwnershipReserveStartServiceResponseSchema: z.ZodDiscrimina
       }>;
       claimedAt: z.ZodNumber;
       updatedAt: z.ZodNumber;
-    }, z.core.$strip>>;
+    }, z.core.$strip>;
+  }, z.core.$strip>, z.ZodObject<{
+    agentId: z.ZodString;
+    sessionId: z.ZodString;
+    adapterId: z.ZodString;
+    ownerInstanceId: z.ZodString;
     leadDesignated: z.ZodBoolean;
     previousLeadAgentId: z.ZodNullable<z.ZodString>;
-  }, z.core.$strip>;
+    recovery: z.ZodOptional<z.ZodObject<{
+      attemptId: z.ZodString;
+      preimage: z.ZodObject<{
+        status: z.ZodEnum<{
+          idle: "idle";
+          active: "active";
+          starting: "starting";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        adapterId: z.ZodString;
+        binding: z.ZodOptional<z.ZodObject<{
+          adapterId: z.ZodString;
+          ownerMachineId: z.ZodString;
+          ownerInstanceId: z.ZodString;
+        }, z.core.$strip>>;
+        recoveryAttemptId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+    }, z.core.$strip>>;
+    machineId: z.ZodOptional<z.ZodString>;
+    claim: z.ZodNull;
+  }, z.core.$strip>]>;
 }, z.core.$strip>, z.ZodObject<{
   outcome: z.ZodLiteral<"occupied">;
   holder: z.ZodObject<{
@@ -4692,6 +7435,7 @@ declare const SessionOwnershipReserveStartServiceResponseSchema: z.ZodDiscrimina
     adapterName: z.ZodString;
     sessionId: z.ZodString;
     agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
     claimToken: z.ZodString;
     fence: z.ZodNumber;
     status: z.ZodEnum<{
@@ -4707,14 +7451,54 @@ declare const SessionOwnershipReserveStartServiceResponseSchema: z.ZodDiscrimina
   currentLeadAgentId: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
   outcome: z.ZodLiteral<"agent-disposed">;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"session-not-active">;
+  status: z.ZodEnum<{
+    closed: "closed";
+    discovered: "discovered";
+    archived: "archived";
+  }>;
 }, z.core.$strip>, z.ZodObject<{
   outcome: z.ZodLiteral<"not-found">;
   missing: z.ZodEnum<{
-    session: "session";
     agent: "agent";
+    session: "session";
   }>;
 }, z.core.$strip>, z.ZodObject<{
   outcome: z.ZodLiteral<"machine-identity-unavailable">;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"currency-changed">;
+  revision: z.ZodNumber;
+  currencyFence: z.ZodNumber;
+  currency: z.ZodObject<{
+    adapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionId: z.ZodNullable<z.ZodString>;
+    currentAdapterSessionIdState: z.ZodEnum<{
+      confirmed: "confirmed";
+      moved: "moved";
+      inherited: "inherited";
+    }>;
+  }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+  outcome: z.ZodLiteral<"recovery-conflict">;
+  status: z.ZodEnum<{
+    idle: "idle";
+    active: "active";
+    starting: "starting";
+    dead: "dead";
+    disposed: "disposed";
+  }>;
+  ownerGeneration: z.ZodNullable<z.ZodObject<{
+    claimId: z.ZodString;
+    claimToken: z.ZodString;
+    fence: z.ZodNumber;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+      abandoned: "abandoned";
+      held: "held";
+      releasing: "releasing";
+    }>;
+  }, z.core.$strip>>;
 }, z.core.$strip>], "outcome">;
 /** {@inheritDoc SessionOwnershipReserveStartServiceResponseSchema} */
 type SessionOwnershipReserveStartServiceResult$1 = z.infer<typeof SessionOwnershipReserveStartServiceResponseSchema>;
@@ -4747,6 +7531,7 @@ declare const SessionOwnershipSettleMovementServiceRequestSchema: z.ZodObject<{
   agentId: z.ZodString;
   adapterId: z.ZodString;
   adapterName: z.ZodString;
+  ownerInstanceId: z.ZodString;
   machineId: z.ZodOptional<z.ZodString>;
   movement: z.ZodDiscriminatedUnion<[z.ZodObject<{
     confirmed: z.ZodLiteral<true>;
@@ -4787,6 +7572,7 @@ declare const SessionOwnershipSettleMovementServiceResponseSchema: z.ZodDiscrimi
     adapterName: z.ZodString;
     sessionId: z.ZodString;
     agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
     claimToken: z.ZodString;
     fence: z.ZodNumber;
     status: z.ZodEnum<{
@@ -4818,6 +7604,7 @@ declare const SessionOwnershipSettleMovementServiceResponseSchema: z.ZodDiscrimi
     adapterName: z.ZodString;
     sessionId: z.ZodString;
     agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
     claimToken: z.ZodString;
     fence: z.ZodNumber;
     status: z.ZodEnum<{
@@ -4838,6 +7625,7 @@ declare const SessionOwnershipSettleMovementServiceResponseSchema: z.ZodDiscrimi
     adapterName: z.ZodString;
     sessionId: z.ZodString;
     agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
     claimToken: z.ZodString;
     fence: z.ZodNumber;
     status: z.ZodEnum<{
@@ -4908,6 +7696,7 @@ declare const SessionOwnershipReclaimReasonSchema: z.ZodEnum<{
   "agent-disposed": "agent-disposed";
   "agent-gone": "agent-gone";
   "adapter-instance-gone": "adapter-instance-gone";
+  "owner-instance-retired": "owner-instance-retired";
 }>;
 /** {@inheritDoc SessionOwnershipReclaimReasonSchema} */
 type SessionOwnershipReclaimReason$1 = z.infer<typeof SessionOwnershipReclaimReasonSchema>;
@@ -4921,6 +7710,7 @@ declare const SessionOwnershipReconciledClaimSchema: z.ZodObject<{
     adapterName: z.ZodString;
     sessionId: z.ZodString;
     agentId: z.ZodString;
+    ownerInstanceId: z.ZodNullable<z.ZodString>;
     claimToken: z.ZodString;
     fence: z.ZodNumber;
     status: z.ZodEnum<{
@@ -4940,6 +7730,7 @@ declare const SessionOwnershipReconciledClaimSchema: z.ZodObject<{
     "agent-disposed": "agent-disposed";
     "agent-gone": "agent-gone";
     "adapter-instance-gone": "adapter-instance-gone";
+    "owner-instance-retired": "owner-instance-retired";
   }>>;
 }, z.core.$strip>;
 /** {@inheritDoc SessionOwnershipReconciledClaimSchema} */
@@ -4963,6 +7754,7 @@ declare const SessionOwnershipReconcileServiceResponseSchema: z.ZodDiscriminated
       adapterName: z.ZodString;
       sessionId: z.ZodString;
       agentId: z.ZodString;
+      ownerInstanceId: z.ZodNullable<z.ZodString>;
       claimToken: z.ZodString;
       fence: z.ZodNumber;
       status: z.ZodEnum<{
@@ -4982,6 +7774,7 @@ declare const SessionOwnershipReconcileServiceResponseSchema: z.ZodDiscriminated
       "agent-disposed": "agent-disposed";
       "agent-gone": "agent-gone";
       "adapter-instance-gone": "adapter-instance-gone";
+      "owner-instance-retired": "owner-instance-retired";
     }>>;
   }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
@@ -5056,22 +7849,94 @@ declare const SessionSchemas: {
       agentId: _$zod.ZodString;
       adapterId: _$zod.ZodString;
       adapterName: _$zod.ZodString;
+      ownerInstanceId: _$zod.ZodString;
       machineId: _$zod.ZodOptional<_$zod.ZodString>;
       role: _$zod.ZodEnum<{
         lead: "lead";
         member: "member";
       }>;
       resumeProviderSessionId: _$zod.ZodNullable<_$zod.ZodString>;
+      claimToken: _$zod.ZodString;
+      recoveryGuard: _$zod.ZodOptional<_$zod.ZodObject<{
+        expectedStatus: _$zod.ZodEnum<{
+          idle: "idle";
+          active: "active";
+          starting: "starting";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        expectedPreimage: _$zod.ZodObject<{
+          status: _$zod.ZodEnum<{
+            idle: "idle";
+            active: "active";
+            starting: "starting";
+            dead: "dead";
+            disposed: "disposed";
+          }>;
+          adapterId: _$zod.ZodString;
+          binding: _$zod.ZodOptional<_$zod.ZodObject<{
+            adapterId: _$zod.ZodString;
+            ownerMachineId: _$zod.ZodString;
+            ownerInstanceId: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>>;
+          recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
+        }, _$zod_v4_core0.$strip>;
+        expectedRevision: _$zod.ZodNumber;
+        expectedCurrencyFence: _$zod.ZodNumber;
+        expectedCurrency: _$zod.ZodObject<{
+          adapterSessionId: _$zod.ZodNullable<_$zod.ZodString>;
+          currentAdapterSessionId: _$zod.ZodNullable<_$zod.ZodString>;
+          currentAdapterSessionIdState: _$zod.ZodEnum<{
+            confirmed: "confirmed";
+            moved: "moved";
+            inherited: "inherited";
+          }>;
+        }, _$zod_v4_core0.$strip>;
+        ownerGeneration: _$zod.ZodNullable<_$zod.ZodObject<{
+          claimId: _$zod.ZodString;
+          claimToken: _$zod.ZodString;
+          fence: _$zod.ZodNumber;
+          ownerInstanceId: _$zod.ZodNullable<_$zod.ZodString>;
+          status: _$zod.ZodEnum<{
+            abandoned: "abandoned";
+            held: "held";
+            releasing: "releasing";
+          }>;
+        }, _$zod_v4_core0.$strip>>;
+      }, _$zod_v4_core0.$strip>>;
+      recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
       expectedLeadAgentId: _$zod.ZodOptional<_$zod.ZodNullable<_$zod.ZodString>>;
     }, _$zod_v4_core0.$strip>;
     response: _$zod.ZodDiscriminatedUnion<[_$zod.ZodObject<{
       outcome: _$zod.ZodLiteral<"reserved">;
-      reservation: _$zod.ZodObject<{
+      reservation: _$zod.ZodUnion<readonly [_$zod.ZodObject<{
         agentId: _$zod.ZodString;
         sessionId: _$zod.ZodString;
-        machineId: _$zod.ZodString;
         adapterId: _$zod.ZodString;
-        claim: _$zod.ZodNullable<_$zod.ZodObject<{
+        ownerInstanceId: _$zod.ZodString;
+        leadDesignated: _$zod.ZodBoolean;
+        previousLeadAgentId: _$zod.ZodNullable<_$zod.ZodString>;
+        recovery: _$zod.ZodOptional<_$zod.ZodObject<{
+          attemptId: _$zod.ZodString;
+          preimage: _$zod.ZodObject<{
+            status: _$zod.ZodEnum<{
+              idle: "idle";
+              active: "active";
+              starting: "starting";
+              dead: "dead";
+              disposed: "disposed";
+            }>;
+            adapterId: _$zod.ZodString;
+            binding: _$zod.ZodOptional<_$zod.ZodObject<{
+              adapterId: _$zod.ZodString;
+              ownerMachineId: _$zod.ZodString;
+              ownerInstanceId: _$zod.ZodString;
+            }, _$zod_v4_core0.$strip>>;
+            recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
+          }, _$zod_v4_core0.$strip>;
+        }, _$zod_v4_core0.$strip>>;
+        machineId: _$zod.ZodString;
+        claim: _$zod.ZodObject<{
           machineId: _$zod.ZodString;
           adapterId: _$zod.ZodString;
           providerSessionId: _$zod.ZodString;
@@ -5079,6 +7944,7 @@ declare const SessionSchemas: {
           adapterName: _$zod.ZodString;
           sessionId: _$zod.ZodString;
           agentId: _$zod.ZodString;
+          ownerInstanceId: _$zod.ZodNullable<_$zod.ZodString>;
           claimToken: _$zod.ZodString;
           fence: _$zod.ZodNumber;
           status: _$zod.ZodEnum<{
@@ -5088,10 +7954,36 @@ declare const SessionSchemas: {
           }>;
           claimedAt: _$zod.ZodNumber;
           updatedAt: _$zod.ZodNumber;
-        }, _$zod_v4_core0.$strip>>;
+        }, _$zod_v4_core0.$strip>;
+      }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
+        agentId: _$zod.ZodString;
+        sessionId: _$zod.ZodString;
+        adapterId: _$zod.ZodString;
+        ownerInstanceId: _$zod.ZodString;
         leadDesignated: _$zod.ZodBoolean;
         previousLeadAgentId: _$zod.ZodNullable<_$zod.ZodString>;
-      }, _$zod_v4_core0.$strip>;
+        recovery: _$zod.ZodOptional<_$zod.ZodObject<{
+          attemptId: _$zod.ZodString;
+          preimage: _$zod.ZodObject<{
+            status: _$zod.ZodEnum<{
+              idle: "idle";
+              active: "active";
+              starting: "starting";
+              dead: "dead";
+              disposed: "disposed";
+            }>;
+            adapterId: _$zod.ZodString;
+            binding: _$zod.ZodOptional<_$zod.ZodObject<{
+              adapterId: _$zod.ZodString;
+              ownerMachineId: _$zod.ZodString;
+              ownerInstanceId: _$zod.ZodString;
+            }, _$zod_v4_core0.$strip>>;
+            recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
+          }, _$zod_v4_core0.$strip>;
+        }, _$zod_v4_core0.$strip>>;
+        machineId: _$zod.ZodOptional<_$zod.ZodString>;
+        claim: _$zod.ZodNull;
+      }, _$zod_v4_core0.$strip>]>;
     }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
       outcome: _$zod.ZodLiteral<"occupied">;
       holder: _$zod.ZodObject<{
@@ -5102,6 +7994,7 @@ declare const SessionSchemas: {
         adapterName: _$zod.ZodString;
         sessionId: _$zod.ZodString;
         agentId: _$zod.ZodString;
+        ownerInstanceId: _$zod.ZodNullable<_$zod.ZodString>;
         claimToken: _$zod.ZodString;
         fence: _$zod.ZodNumber;
         status: _$zod.ZodEnum<{
@@ -5117,14 +8010,54 @@ declare const SessionSchemas: {
       currentLeadAgentId: _$zod.ZodNullable<_$zod.ZodString>;
     }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
       outcome: _$zod.ZodLiteral<"agent-disposed">;
+    }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
+      outcome: _$zod.ZodLiteral<"session-not-active">;
+      status: _$zod.ZodEnum<{
+        closed: "closed";
+        discovered: "discovered";
+        archived: "archived";
+      }>;
     }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
       outcome: _$zod.ZodLiteral<"not-found">;
       missing: _$zod.ZodEnum<{
-        session: "session";
         agent: "agent";
+        session: "session";
       }>;
     }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
       outcome: _$zod.ZodLiteral<"machine-identity-unavailable">;
+    }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
+      outcome: _$zod.ZodLiteral<"currency-changed">;
+      revision: _$zod.ZodNumber;
+      currencyFence: _$zod.ZodNumber;
+      currency: _$zod.ZodObject<{
+        adapterSessionId: _$zod.ZodNullable<_$zod.ZodString>;
+        currentAdapterSessionId: _$zod.ZodNullable<_$zod.ZodString>;
+        currentAdapterSessionIdState: _$zod.ZodEnum<{
+          confirmed: "confirmed";
+          moved: "moved";
+          inherited: "inherited";
+        }>;
+      }, _$zod_v4_core0.$strip>;
+    }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
+      outcome: _$zod.ZodLiteral<"recovery-conflict">;
+      status: _$zod.ZodEnum<{
+        idle: "idle";
+        active: "active";
+        starting: "starting";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+      ownerGeneration: _$zod.ZodNullable<_$zod.ZodObject<{
+        claimId: _$zod.ZodString;
+        claimToken: _$zod.ZodString;
+        fence: _$zod.ZodNumber;
+        ownerInstanceId: _$zod.ZodNullable<_$zod.ZodString>;
+        status: _$zod.ZodEnum<{
+          abandoned: "abandoned";
+          held: "held";
+          releasing: "releasing";
+        }>;
+      }, _$zod_v4_core0.$strip>>;
     }, _$zod_v4_core0.$strip>], "outcome">;
   };
   'ownership.settleMovement': {
@@ -5133,6 +8066,7 @@ declare const SessionSchemas: {
       agentId: _$zod.ZodString;
       adapterId: _$zod.ZodString;
       adapterName: _$zod.ZodString;
+      ownerInstanceId: _$zod.ZodString;
       machineId: _$zod.ZodOptional<_$zod.ZodString>;
       movement: _$zod.ZodDiscriminatedUnion<[_$zod.ZodObject<{
         confirmed: _$zod.ZodLiteral<true>;
@@ -5164,6 +8098,7 @@ declare const SessionSchemas: {
         adapterName: _$zod.ZodString;
         sessionId: _$zod.ZodString;
         agentId: _$zod.ZodString;
+        ownerInstanceId: _$zod.ZodNullable<_$zod.ZodString>;
         claimToken: _$zod.ZodString;
         fence: _$zod.ZodNumber;
         status: _$zod.ZodEnum<{
@@ -5195,6 +8130,7 @@ declare const SessionSchemas: {
         adapterName: _$zod.ZodString;
         sessionId: _$zod.ZodString;
         agentId: _$zod.ZodString;
+        ownerInstanceId: _$zod.ZodNullable<_$zod.ZodString>;
         claimToken: _$zod.ZodString;
         fence: _$zod.ZodNumber;
         status: _$zod.ZodEnum<{
@@ -5215,6 +8151,7 @@ declare const SessionSchemas: {
         adapterName: _$zod.ZodString;
         sessionId: _$zod.ZodString;
         agentId: _$zod.ZodString;
+        ownerInstanceId: _$zod.ZodNullable<_$zod.ZodString>;
         claimToken: _$zod.ZodString;
         fence: _$zod.ZodNumber;
         status: _$zod.ZodEnum<{
@@ -5270,6 +8207,7 @@ declare const SessionSchemas: {
         adapterName: _$zod.ZodString;
         sessionId: _$zod.ZodString;
         agentId: _$zod.ZodString;
+        ownerInstanceId: _$zod.ZodNullable<_$zod.ZodString>;
         claimToken: _$zod.ZodString;
         fence: _$zod.ZodNumber;
         status: _$zod.ZodEnum<{
@@ -5297,6 +8235,7 @@ declare const SessionSchemas: {
           adapterName: _$zod.ZodString;
           sessionId: _$zod.ZodString;
           agentId: _$zod.ZodString;
+          ownerInstanceId: _$zod.ZodNullable<_$zod.ZodString>;
           claimToken: _$zod.ZodString;
           fence: _$zod.ZodNumber;
           status: _$zod.ZodEnum<{
@@ -5316,6 +8255,7 @@ declare const SessionSchemas: {
           "agent-disposed": "agent-disposed";
           "agent-gone": "agent-gone";
           "adapter-instance-gone": "adapter-instance-gone";
+          "owner-instance-retired": "owner-instance-retired";
         }>>;
       }, _$zod_v4_core0.$strip>>;
     }, _$zod_v4_core0.$strip>, _$zod.ZodObject<{
@@ -6069,7 +9009,7 @@ declare const SessionSchemas: {
           systemPrompt: "systemPrompt";
           fullPrefix: "fullPrefix";
         }>>;
-        turnContext: _$zod.ZodOptional<_$zod.ZodRecord<_$zod.ZodString, _$zod.ZodType<_$_makaio_contracts0.JsonValue, unknown, _$zod_v4_core0.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, unknown>>>>;
+        turnContext: _$zod.ZodOptional<_$zod.ZodRecord<_$zod.ZodString, _$zod.ZodType<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue, _$zod_v4_core0.$ZodTypeInternals<_$_makaio_contracts0.JsonValue, _$_makaio_contracts0.JsonValue>>>>;
         requestCorrelation: _$zod.ZodOptional<_$zod.ZodObject<{
           sessionId: _$zod.ZodOptional<_$zod.ZodString>;
           turnId: _$zod.ZodOptional<_$zod.ZodString>;
@@ -7441,6 +10381,11 @@ declare const SessionSchemas: {
             adapterId: _$zod.ZodString;
             adapterName: _$zod.ZodString;
             sessionId: _$zod.ZodString;
+            runtimeOwner: _$zod.ZodOptional<_$zod.ZodObject<{
+              machineId: _$zod.ZodString;
+              instanceId: _$zod.ZodString;
+            }, _$zod_v4_core0.$strip>>;
+            recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
             adapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
             currentAdapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
             currentAdapterSessionIdState: _$zod.ZodOptional<_$zod.ZodEnum<{
@@ -7569,6 +10514,11 @@ declare const SessionSchemas: {
           adapterId: _$zod.ZodString;
           adapterName: _$zod.ZodString;
           sessionId: _$zod.ZodString;
+          runtimeOwner: _$zod.ZodOptional<_$zod.ZodObject<{
+            machineId: _$zod.ZodString;
+            instanceId: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>>;
+          recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
           adapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionIdState: _$zod.ZodOptional<_$zod.ZodEnum<{
@@ -8103,6 +11053,11 @@ declare const SessionSchemas: {
             adapterId: _$zod.ZodString;
             adapterName: _$zod.ZodString;
             sessionId: _$zod.ZodString;
+            runtimeOwner: _$zod.ZodOptional<_$zod.ZodObject<{
+              machineId: _$zod.ZodString;
+              instanceId: _$zod.ZodString;
+            }, _$zod_v4_core0.$strip>>;
+            recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
             adapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
             currentAdapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
             currentAdapterSessionIdState: _$zod.ZodOptional<_$zod.ZodEnum<{
@@ -8231,6 +11186,11 @@ declare const SessionSchemas: {
           adapterId: _$zod.ZodString;
           adapterName: _$zod.ZodString;
           sessionId: _$zod.ZodString;
+          runtimeOwner: _$zod.ZodOptional<_$zod.ZodObject<{
+            machineId: _$zod.ZodString;
+            instanceId: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>>;
+          recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
           adapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionIdState: _$zod.ZodOptional<_$zod.ZodEnum<{
@@ -9282,6 +12242,11 @@ declare const SessionSchemas: {
           adapterId: _$zod.ZodString;
           adapterName: _$zod.ZodString;
           sessionId: _$zod.ZodString;
+          runtimeOwner: _$zod.ZodOptional<_$zod.ZodObject<{
+            machineId: _$zod.ZodString;
+            instanceId: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>>;
+          recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
           adapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionIdState: _$zod.ZodOptional<_$zod.ZodEnum<{
@@ -9435,6 +12400,11 @@ declare const SessionSchemas: {
           adapterId: _$zod.ZodString;
           adapterName: _$zod.ZodString;
           sessionId: _$zod.ZodString;
+          runtimeOwner: _$zod.ZodOptional<_$zod.ZodObject<{
+            machineId: _$zod.ZodString;
+            instanceId: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>>;
+          recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
           adapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionIdState: _$zod.ZodOptional<_$zod.ZodEnum<{
@@ -9579,6 +12549,11 @@ declare const SessionSchemas: {
           adapterId: _$zod.ZodString;
           adapterName: _$zod.ZodString;
           sessionId: _$zod.ZodString;
+          runtimeOwner: _$zod.ZodOptional<_$zod.ZodObject<{
+            machineId: _$zod.ZodString;
+            instanceId: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>>;
+          recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
           adapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionIdState: _$zod.ZodOptional<_$zod.ZodEnum<{
@@ -9837,6 +12812,11 @@ declare const SessionSchemas: {
           adapterId: _$zod.ZodString;
           adapterName: _$zod.ZodString;
           sessionId: _$zod.ZodString;
+          runtimeOwner: _$zod.ZodOptional<_$zod.ZodObject<{
+            machineId: _$zod.ZodString;
+            instanceId: _$zod.ZodString;
+          }, _$zod_v4_core0.$strip>>;
+          recoveryAttemptId: _$zod.ZodOptional<_$zod.ZodString>;
           adapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionId: _$zod.ZodOptional<_$zod.ZodString>;
           currentAdapterSessionIdState: _$zod.ZodOptional<_$zod.ZodEnum<{
@@ -10075,4 +13055,4 @@ type KnownSessionEvent = { [K in RuntimeKnownSessionEventType]: SessionEventBase
  */
 declare function isKnownSessionEvent(event: MakaioSessionEvent$1): event is KnownSessionEvent;
 //#endregion
-export { NativeForkDirective$1 as $, SessionRecordMetadata as $t, SessionOwnershipReserveStartServiceResult$1 as A, TurnUsage$1 as At, SegmentPolicySchema as B, ImportStatus as Bt, SessionOwnershipReleaseServiceRequest as C, SessionMessageSchema$1 as Ct, SessionOwnershipReserveStartServiceRequest as D, TurnSchema$1 as Dt, SessionOwnershipReservationSchema as E, TurnInitiatorSchema$1 as Et, SessionOwnershipSettleMovementServiceResponseSchema as F, AdapterSessionCurrencyStateSchema as Ft, ForkChildInfo as G, SnapshotExportOptions as Gt, SessionCreatedEventSchema as H, SNAPSHOT_VERSION as Ht, SessionOwnershipSettleMovementServiceResult as I, AgentRole$1 as It, SESSION_EVENT_TYPES as J, SnapshotPreviewData as Jt, ForkChildInfoSchema as K, SnapshotExportOptionsSchema as Kt, ForkTransforms$1 as L, AgentRoleSchema as Lt, SessionOwnershipServiceMovementSchema as M, UsageMetrics as Mt, SessionOwnershipSettleMovementServiceRequest as N, UsageMetricsSchema as Nt, SessionOwnershipReserveStartServiceRequestSchema as O, TurnStatus as Ot, SessionOwnershipSettleMovementServiceRequestSchema as P, AdapterSessionCurrencyState as Pt, SessionEventTypeSchema as Q, SessionPreviewDataSchema as Qt, ForkTransformsSchema$1 as R, BranchKind$1 as Rt, SessionOwnershipReconciledClaimSchema as S, SessionMessageRoleSchema as St, SessionOwnershipReservation as T, TurnInitiator$2 as Tt, SessionUpdatedEvent as U, SessionSnapshot as Ut, SessionCreated as V, ImportStatusSchema as Vt, SessionUpdatedEventSchema as W, SessionSnapshotSchema as Wt, SessionEventType$1 as X, validateSnapshot as Xt, SessionEventPayload as Y, safeValidateSnapshot as Yt, SessionEventTypeMap as Z, MakaioSessionSchema as Zt, SessionOwnershipReclaimReason$1 as _, SessionMessageBlock$1 as _t, SessionPreviewData as a, SessionCreateBase as an, AgentAttachResolvedRequest as at, SessionOwnershipReconcileServiceResult as b, SessionMessageOriginSchema as bt, SessionSchemas as c, TurnCompleted as ct, SessionOwnershipContinuationServiceRequest as d, TurnStarted as dt, SessionRecordMetadataSchema$1 as en, NativeForkDirectiveSchema as et, SessionOwnershipContinuationServiceRequestSchema as f, MessageRouting as ft, SessionOwnershipPrincipalSchema as g, SessionMessage$1 as gt, SessionOwnershipPrincipal as h, MessageRoutingStatusSchema as ht, MakaioSessionEvent$1 as i, MakaioSessionAgentSchema$1 as in, NativeLocalityVerdictSchema as it, SessionOwnershipServiceMovement as j, TurnUsageSchema$1 as jt, SessionOwnershipReserveStartServiceResponseSchema as k, TurnStatusSchema$1 as kt, OwnershipTopology$1 as l, TurnIngestionMarker$1 as lt, SessionOwnershipContinuationServiceResult as m, MessageRoutingStatus as mt, KnownSessionEvent as n, AgentStatus as nn, NativeLocalityReasonSchema as nt, SessionWithPreview as o, SessionCreateBaseSchema as on, SendMessageRequest as ot, SessionOwnershipContinuationServiceResponseSchema as p, MessageRoutingSchema$1 as pt, MakaioSessionEventSchema as q, SnapshotImportConflictErrorData as qt, MakaioSessionAgent$1 as r, AgentStatusSchema$1 as rn, NativeLocalityVerdict$1 as rt, isKnownSessionEvent as s, SendMessageResponse as st, IMakaioSession$1 as t, SessionWithPreviewSchema as tn, NativeLocalityReason as tt, OwnershipTopologySchema as u, TurnIngestionMarkerSchema$1 as ut, SessionOwnershipReclaimReasonSchema as v, SessionMessageBlockSchema as vt, SessionOwnershipReleaseServiceRequestSchema as w, Turn$1 as wt, SessionOwnershipReconciledClaim as x, SessionMessageRole as xt, SessionOwnershipReconcileServiceResponseSchema as y, SessionMessageOrigin$1 as yt, SegmentPolicy as z, BranchKindSchema as zt };
+export { SessionOwnershipClaimRequestSchema as $, safeValidateSnapshot as $n, SessionEventPayload as $t, SessionOwnershipServiceMovement as A, TurnInitiatorSchema$1 as An, SessionOwnershipRecoveryGuardSchema as At, AdapterSessionClaimKeySchema as B, AgentRole$1 as Bn, AdapterSessionClaimStatusSchema as Bt, SessionOwnershipReleaseServiceRequestSchema as C, SessionMessageOrigin$1 as Cn, RuntimeBinding as Ct, SessionOwnershipReserveStartServiceRequestSchema as D, SessionMessageSchema$1 as Dn, SessionOwnershipFinalizeRecoveryResponseSchema as Dt, SessionOwnershipReserveStartServiceRequest as E, SessionMessageRoleSchema as En, SessionOwnershipFinalizeRecoveryRequestSchema as Et, SessionOwnershipSettleMovementServiceResult as F, TurnUsageSchema$1 as Fn, SessionOwnershipRecoveryReservation as Ft, OwnershipMovement as G, ImportStatusSchema as Gn, SessionCreated as Gt, AdapterSessionClaimRecordSchema as H, BranchKind$1 as Hn, ForkTransformsSchema$1 as Ht, normalizeSessionOwnershipReserveStartServiceRequest$1 as I, UsageMetrics as In, SessionOwnershipRecoveryReservationSchema as It, OwnershipOwnerInstanceSchema as J, SessionSnapshotSchema as Jn, SessionUpdatedEventSchema as Jt, OwnershipMovementSchema as K, SNAPSHOT_VERSION as Kn, SessionCreatedEventSchema as Kt, AdapterSessionClaimDisposition as L, UsageMetricsSchema as Ln, SessionOwnershipRecoveryTerminalAction as Lt, SessionOwnershipSettleMovementServiceRequest as M, TurnStatus as Mn, SessionOwnershipRecoveryOwnerGenerationSchema as Mt, SessionOwnershipSettleMovementServiceRequestSchema as N, TurnStatusSchema$1 as Nn, SessionOwnershipRecoveryPreimage as Nt, SessionOwnershipReserveStartServiceResponseSchema as O, Turn$1 as On, SessionOwnershipFinalizeRecoveryResult as Ot, SessionOwnershipSettleMovementServiceResponseSchema as P, TurnUsage$1 as Pn, SessionOwnershipRecoveryPreimageSchema as Pt, SessionOwnershipClaimRequest as Q, SnapshotPreviewData as Qn, SESSION_EVENT_TYPES as Qt, AdapterSessionClaimDispositionSchema as R, AdapterSessionCurrencyState as Rn, SessionOwnershipRecoveryTerminalActionSchema as Rt, SessionOwnershipReleaseServiceRequest as S, SessionMessageBlockSchema as Sn, normalizeSessionOwnershipClaimRequest$1 as St, SessionOwnershipReservationSchema as T, SessionMessageRole as Tn, SessionOwnershipFinalizeRecoveryRequest as Tt, AgentSessionOwnershipRecord as U, BranchKindSchema as Un, SegmentPolicy as Ut, AdapterSessionClaimRecord$1 as V, AgentRoleSchema as Vn, ForkTransforms$1 as Vt, AgentSessionOwnershipRecordSchema as W, ImportStatus as Wn, SegmentPolicySchema as Wt, RuntimeInstanceRecord$1 as X, SnapshotExportOptionsSchema as Xn, ForkChildInfoSchema as Xt, OwnershipTopologySchema as Y, SnapshotExportOptions as Yn, ForkChildInfo as Yt, RuntimeInstanceRecordSchema as Z, SnapshotImportConflictErrorData as Zn, MakaioSessionEventSchema as Zt, SessionOwnershipReclaimReasonSchema as _, MessageRoutingSchema$1 as _n, SessionOwnershipSettleMovementRequestSchema$1 as _t, SessionPreviewData as a, NativeLocalityReason as an, SessionWithPreviewSchema as ar, SessionOwnershipReleaseAgentClaimsRequestSchema as at, SessionOwnershipReconciledClaim as b, SessionMessage$1 as bn, SessionOwnershipStorageNamespace as bt, SessionSchemas as c, NativeLocalityVerdictSchema as cn, MakaioSessionAgentSchema$1 as cr, SessionOwnershipReleaseRequest as ct, SessionOwnershipContinuationServiceRequestSchema as d, SendMessageResponse as dn, SessionOwnershipReleaseResult as dt, SessionEventType$1 as en, validateSnapshot as er, SessionOwnershipClaimResponseSchema as et, SessionOwnershipContinuationServiceResponseSchema as f, TurnCompleted as fn, SessionOwnershipSettleCurrencyRequest as ft, SessionOwnershipReclaimReason$1 as g, MessageRouting as gn, SessionOwnershipSettleMovementRequest as gt, SessionOwnershipPrincipalSchema as h, TurnStarted as hn, SessionOwnershipSettleCurrencyResult as ht, MakaioSessionEvent$1 as i, NativeForkDirectiveSchema as in, SessionRecordMetadataSchema$1 as ir, SessionOwnershipReleaseAgentClaimsRequest as it, SessionOwnershipServiceMovementSchema as j, TurnSchema$1 as jn, SessionOwnershipRecoveryOwnerGeneration as jt, SessionOwnershipReserveStartServiceResult$1 as k, TurnInitiator$2 as kn, SessionOwnershipRecoveryGuard$1 as kt, OwnershipTopology$1 as l, AgentAttachResolvedRequest as ln, SessionCreateBase as lr, SessionOwnershipReleaseRequestSchema as lt, SessionOwnershipPrincipal as m, TurnIngestionMarkerSchema$1 as mn, SessionOwnershipSettleCurrencyResponseSchema as mt, KnownSessionEvent as n, SessionEventTypeSchema as nn, SessionPreviewDataSchema as nr, SessionOwnershipListClaimsRequest as nt, SessionWithPreview as o, NativeLocalityReasonSchema as on, AgentStatus as or, SessionOwnershipReleaseAgentClaimsResponseSchema as ot, SessionOwnershipContinuationServiceResult as p, TurnIngestionMarker$1 as pn, SessionOwnershipSettleCurrencyRequestSchema as pt, OwnershipOwnerInstance as q, SessionSnapshot as qn, SessionUpdatedEvent as qt, MakaioSessionAgent$1 as r, NativeForkDirective$1 as rn, SessionRecordMetadata as rr, SessionOwnershipListClaimsRequestSchema as rt, isKnownSessionEvent as s, NativeLocalityVerdict$1 as sn, AgentStatusSchema$1 as sr, SessionOwnershipReleaseAgentClaimsResult as st, IMakaioSession$1 as t, SessionEventTypeMap as tn, MakaioSessionSchema as tr, SessionOwnershipClaimResult as tt, SessionOwnershipContinuationServiceRequest as u, SendMessageRequest as un, SessionCreateBaseSchema as ur, SessionOwnershipReleaseResponseSchema as ut, SessionOwnershipReconcileServiceResponseSchema as v, MessageRoutingStatus as vn, SessionOwnershipSettleMovementResponseSchema as vt, SessionOwnershipReservation as w, SessionMessageOriginSchema as wn, RuntimeBindingSchema as wt, SessionOwnershipReconciledClaimSchema as x, SessionMessageBlock$1 as xn, SessionOwnershipStorageSubjects$1 as xt, SessionOwnershipReconcileServiceResult as y, MessageRoutingStatusSchema as yn, SessionOwnershipSettleMovementResult as yt, AdapterSessionClaimKey as z, AdapterSessionCurrencyStateSchema as zn, AdapterSessionClaimStatus as zt };