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

package/dist/{index-CqQYgsbB.d.mts → index-BNzUyVwV.d.mts}

@@ -1,17 +1,18 @@
-import { C as Turn$1, g as OwnedAdapterInstance, h as MachineScopedAdapterInstance } from "./index-DI7-tIL3.mjs";
-import { a as PipelineStep, o as SessionEditorAction, t as ActionCategory } from "./types-xCdGghb2.mjs";
+import { g as OwnedAdapterInstance, h as MachineScopedAdapterInstance, w as Turn$1 } from "./index-B0yMCJW8.mjs";
+import { a as PipelineStep, o as SessionEditorAction, t as ActionCategory } from "./types-BlB23n4f.mjs";
 import { z } from "zod";
 import * as _$_makaio_core0 from "@makaio/framework/core";
 import { ExtractSubjectPayload, SubjectDefinition } from "@makaio/framework/core";
 import { IMakaioBus } from "@makaio/framework/bus";
 import * as _$_makaio_contracts0 from "@makaio/framework/contracts";
-import { AIReasoningLevel, AdapterRuntimeOptions, AdapterSelection, AdapterSessionClaimRecord, AgentRole, BranchKind, ContextWindowState, ForkOptions, ForkTransforms, ICapabilityProvider, IMakaioSession, JsonValue, MakaioSessionAgent, MakaioSessionEvent, Message, MessageBlock, MessageInput, NativeLocalityVerdict, OwnershipTopology, ResolvedProviderContext, SessionContext, SessionEventType, SessionExtensionContext, SessionLineage, SessionLineageKind, SessionMessage, SessionMessageBlock, SessionMessageOrigin, SessionOwnershipReclaimReason, SessionOwnershipReserveStartServiceResult, SessionSubjects, TurnIngestionMarker, TurnInitiator, TurnUsage } from "@makaio/framework/contracts";
+import { AIReasoningLevel, AdapterRuntimeOptions, AdapterSelection, AdapterSessionClaimRecord, AgentRole, BranchKind, ContextWindowState, ForkOptions, ForkTransforms, ICapabilityProvider, IMakaioSession, JsonValue, MakaioSessionAgent, MakaioSessionEvent, Message, MessageBlock, MessageInput, NativeLocalityVerdict, OwnershipTopology, ResolvedProviderContext, RuntimeInstanceRecord, SessionContext, SessionEventType, SessionExtensionContext, SessionLineage, SessionLineageKind, SessionMessage, SessionMessageBlock, SessionMessageOrigin, SessionOwnershipReclaimReason, SessionOwnershipRecoveryGuard, SessionOwnershipReserveStartServiceResult, SessionSubjects, StartAgentRequest, StartAgentResponse, TurnIngestionMarker, TurnInitiator, TurnUsage } from "@makaio/framework/contracts";
 import { BaseService } from "@makaio/framework/service-base";
 import * as _$drizzle_orm_sqlite_core0 from "drizzle-orm/sqlite-core";
 import * as _$drizzle_orm_pg_core0 from "drizzle-orm/pg-core";
 import * as _$_makaio_storage_drizzle0 from "@makaio/framework/storage/drizzle";
-import { MakaioDatabase } from "@makaio/framework/storage/drizzle";
+import { MakaioDatabase, TransactionLock } from "@makaio/framework/storage/drizzle";
 import * as _$drizzle_orm0 from "drizzle-orm";
+import { SQL } from "drizzle-orm";
 import * as _$_makaio_storage_core0 from "@makaio/framework/storage";
 
 //#region services/core/src/session/session-service.d.ts
@@ -93,6 +94,17 @@ interface MakaioSessionServiceOptions {
  */
 declare class MakaioSessionService extends BaseService {
   private readonly options;
+  private ownership;
+  /**
+   * Return the currently active ownership-authority incarnation.
+   *
+   * Read at adapter construction time rather than cached by the adapter
+   * subsystem, so reinitializing this service gives every subsequently created
+   * adapter the newly minted incarnation.
+   * @returns Active runtime-incarnation identity.
+   * @throws When the service has not initialized its authority.
+   */
+  requireOwnershipInstanceId(): string;
   /**
    * Creates a new MakaioSessionService instance.
    * @param bus - The event bus for inter-service communication
@@ -115,6 +127,16 @@ declare class MakaioSessionService extends BaseService {
    * that do not register turn storage).
    */
   protected onInit(): Promise<void>;
+  /**
+   * Retire this process only after the adapter subsystem's earlier teardown has
+   * published its aggregate evidence.
+   *
+   * Reverse dependency ordering destroys the adapter subsystem first. The
+   * authority then closes admission, drains operations already admitted, and
+   * stamps retirement only when that published aggregate proves teardown was
+   * observed.
+   */
+  protected onDestroy(): Promise<void>;
   /**
    * Arm the ownership reconcile behind the post-coordinator barrier.
    *
@@ -163,6 +185,8 @@ interface OwnershipAuthorityContext {
   readonly bus: IMakaioBus;
   /** Machine identity the authority owns claims under, or `undefined` when it has none. */
   readonly machineId: string | undefined;
+  /** Runtime-incarnation identity stamped onto every generation this authority allocates. */
+  readonly instanceId: string;
   /** {@inheritDoc OwnershipTopologySchema} */
   readonly topology: OwnershipTopology;
 }
@@ -175,7 +199,24 @@ interface OwnershipAuthorityContext {
  * the authority with *is* what every operation decides under, so there is no
  * second declaration for the two to drift apart in.
  */
-type SessionOwnershipAuthorityDeps = OwnershipAuthorityContext;
+interface SessionOwnershipAuthorityDeps extends Omit<OwnershipAuthorityContext, 'instanceId'> {
+  /** Runtime-incarnation identity, or a freshly minted identity in isolated compositions. */
+  readonly instanceId?: string;
+}
+/** Private lifecycle control for the locally composed ownership authority. */
+interface OwnershipAuthorityHandle {
+  /** Identity stamped onto generations allocated by this authority. */
+  readonly instanceId: string;
+  /** Close admission, drain admitted operations, and retire on observed teardown. */
+  close(): Promise<void>;
+}
+/** Authority handlers and the private lifecycle control that owns them. */
+interface RegisteredSessionOwnershipAuthority {
+  /** Idempotent handler cleanups for the containing service. */
+  readonly cleanups: readonly (() => void)[];
+  /** Private shutdown capability; deliberately not exposed as a bus subject. */
+  readonly ownership: OwnershipAuthorityHandle;
+}
 /**
  * Register the session-ownership authority.
  *
@@ -184,10 +225,10 @@ type SessionOwnershipAuthorityDeps = OwnershipAuthorityContext;
  * a caller out of storage RPCs, a reservation or a movement is three
  * transactions with windows in which a crash strands an ownership key or
  * publishes a currency no generation owns.
- * @param context - Bus, machine identity and topology to compose the authority with.
- * @returns Cleanup function unregistering every handler.
+ * @param deps - Bus, machine identity, topology and optional test identity.
+ * @returns Registered cleanups and the private retirement handle.
  */
-declare function registerSessionOwnershipAuthority(context: SessionOwnershipAuthorityDeps): () => void;
+declare function registerSessionOwnershipAuthority(deps: SessionOwnershipAuthorityDeps): RegisteredSessionOwnershipAuthority;
 //#endregion
 //#region services/core/src/session/ownership/movement-observer.d.ts
 /**
@@ -393,6 +434,8 @@ declare function mintClaimToken(): string;
  *   diagnostic must report what it observes, and a probe can straddle a delete.
  * - `agent-disposed` — the agent was removed. A disposed agent can never
  *   legitimately hold a key.
+ * - `owner-instance-retired` — storage proves the exact process that took this
+ *   generation retired itself.
  * - `adapter-instance-gone` — no adapter answers for the claim's instance.
  *   Admitted **only** under `machine-exclusive`: where peers may host adapters
  *   on the same machine, an unanswered probe means "not this runtime's", never
@@ -430,6 +473,15 @@ interface CoreSessionServiceHandlerDeps {
    * `'shared-machine'` — the reading no host can be wrong about.
    */
   topology?: OwnershipTopology;
+  /** Runtime-incarnation identity stamped onto ownership generations. */
+  instanceId?: string;
+}
+/** Core handler cleanups plus the private ownership lifecycle handle. */
+interface RegisteredCoreSessionServiceHandlers {
+  /** Cleanup callbacks for the containing service. */
+  readonly cleanups: readonly (() => void)[];
+  /** Private authority shutdown capability. */
+  readonly ownership: OwnershipAuthorityHandle;
 }
 /**
  * Registers the framework-core session service handlers:
@@ -447,9 +499,9 @@ interface CoreSessionServiceHandlerDeps {
  * `session.get` / `session.list` / `session.close` all delegate to
  * `SessionStorageSubjects.*` which may be unhandled in ephemeral mode.
  * @param deps - Bus, plus the identity the ownership authority is composed with
- * @returns Array of cleanup callbacks, one per registered handler
+ * @returns Cleanup callbacks plus the private ownership lifecycle handle.
  */
-declare function registerCoreSessionServiceHandlers(deps: CoreSessionServiceHandlerDeps): Array<() => void>;
+declare function registerCoreSessionServiceHandlers(deps: CoreSessionServiceHandlerDeps): RegisteredCoreSessionServiceHandlers;
 //#endregion
 //#region services/core/src/session/session-orchestrator.d.ts
 /**
@@ -464,52 +516,7 @@ interface ISessionOrchestrator {
   /** Stop the orchestrator and clean up all subscriptions. */
   destroy(): void;
 }
-/**
- * Slim framework session orchestrator.
- *
- * Composes with `SessionTurnManager` (turn lifecycle, usage accumulation,
- * completion), `AdapterRegistry` (adapterName to adapterId mapping), and the
- * adapter-subsystem reverse lookup for canonical `adapterId` to `adapterName`
- * validation when callers select a direct adapter instance.
- *
- * Registers the core session orchestration handlers:
- * 1. Get or create session (via `getOrCreateSession`)
- * 2. Resolve any start the session has in flight (via `resolveInFlightStarts`),
- *    before anything probes an agent or concludes the session has none
- * 2b. Refuse a send that stated targets (named ids or `'all'`) against a session
- *    that has none — before the start below, so a refused send leaves no agent
- *    and no reservation; only the default send may bootstrap a session
- * 3. Start the lead agent if the session has no agents — resolves the canonical
- *    `adapterName` from direct selections, uses `adapterId` directly when
- *    provided, otherwise resolves it via `AdapterRegistry`, resolves provider
- *    credentials when selected, then runs the reserved start (via
- *    `startLeadAgent`)
- * 4. Resolve target agents (via `resolveTargetAgents`)
- * 5. Verify agent liveness and recover dead agents under one recovery plan
- *    (requestOptional `AdapterSubjects.getAgent` + `buildPlannedRecoveryContext`)
- * 6. Get or create turn (via `SessionTurnManager`), generate the message ID and
- *    store the user message (awaited, persist-before-route) + routing records
- *    (fire-and-forget)
- * 7. Emit `session.turn.started` + `session.user_message.sent`
- * 8. Route to agents (via `routeToAgentsCore`, single shared context)
- * 9. Return result with `messageId`, `turnId`, `sessionId`
- *
- * Explicit `session.agent.attach` handlers share the same turn manager so
- * attach-time initial messages participate in the same completion lifecycle.
- *
- * Host-specific features (personas, MCP, execution targets, container spawn,
- * connector swap, CWD/model enforcement, fork context, TurnContextEnricher) are
- * handled by a host-provided orchestrator.
- * @example
- * ```typescript
- * const orchestrator = new SessionOrchestrator(MakaioBus, 'machine-id');
- *
- * const { messageId, turnId, sessionId } = await MakaioBus.request(
- *   SessionSubjects.sendMessage,
- *   { sessionId: crypto.randomUUID(), adapterName: 'openai-node', message: 'Hello!' },
- * );
- * ```
- */
+/** Coordinates session sends, recovery and turn completion. */
 declare class SessionOrchestrator implements ISessionOrchestrator {
   private readonly bus;
   private readonly turnManager;
@@ -524,84 +531,8 @@ declare class SessionOrchestrator implements ISessionOrchestrator {
    *   instance resolution).
    */
   constructor(bus: IMakaioBus | undefined, machineId: string);
-  /**
-   * Register the `session.sendMessage` RPC handler.
-   *
-   * Core flow:
-   * 1. Get or create session
-   * 2. Join or arbitrate every start the session has in flight
-   * 2b. Refuse a target-stating send (named ids or `'all'`) against a session
-   *    with no agents, before the bootstrap can leave state behind a send that
-   *    cannot deliver
-   * 3. Start the lead agent if the session has no agents (canonicalize direct
-   *    selections, resolve adapterId, resolve provider credentials, reserved start)
-   * 4. Resolve target agents
-   * 5. Verify agent liveness and recover dead agents under one recovery plan
-   * 6. Get or create turn (via SessionTurnManager), generate the message ID and
-   *    store the user message (awaited) + routing records (fire-and-forget)
-   * 7. Emit turn.started + user_message.sent
-   * 8. Route to agents (routeToAgentsCore, single shared context)
-   * 9. Return result with messageId, turnId, sessionId
-   */
+  /** Register the `session.sendMessage` RPC handler. */
   private registerSendMessageHandler;
-  /**
-   * Probe this send's targets and recover the ones that are gone.
-   *
-   * **An agent whose in-flight start this send consumed *locally* needs no
-   * probe; one it merely out-raced does.** The distinction is the evidence
-   * behind the verdict. A locally joined attempt reported what it built, and
-   * this process ran it. A won compare-and-swap reports only that this caller
-   * wrote a status first: the attempt it outran belongs to a process this
-   * runtime cannot see, and writing `dead` does not make the agent dead. Wave 3
-   * cannot ask whether that process is alive (OQ-B, Wave 4) — but it can ask
-   * whether a *connector* answers, which is what the probe already does for
-   * every other target and the only instrument here that carries evidence
-   * across processes. Skipping it there was the send believing its own status
-   * write, and it is what let a second lifecycle open beside a live one.
-   *
-   * The framework orchestrator evaluates no locality, so it can make only one
-   * honest recovery decision: the replacement connector starts fresh and the
-   * stored conversation is injected. Holding it as a plan keeps the history
-   * assembly and the rehydrate reading one decision — a host that later resumes
-   * natively here changes that value alone and both sides follow.
-   *
-   * Each recovery is reserved and runs inside the in-flight-start seam, which
-   * the entry-point inventory requires of every service-owned path that can
-   * reach a lifecycle call for an *existing* agent identity: two concurrent
-   * sends onto one dead agent would otherwise dispatch two rehydrates, and the
-   * second would race the first's connector.
-   * @param session - Session being sent to.
-   * @param targetAgents - Targets this send materialised.
-   * @param recovering - Agents whose in-flight start this send already claimed.
-   * @param arbitrated - Of those, the ones claimed by compare-and-swap against another process.
-   * @returns The injected history, when any agent needed it, and the agents this runtime may not drive.
-   */
-  private recoverDeadTargets;
-  /**
-   * Re-resolve a send's targets around agents this runtime may not drive.
-   *
-   * The three send forms degrade differently, and the difference is deliberate:
-   *
-   * - **lead-default** — a deferred lead is always *total*, because target
-   *   resolution raises for a session whose named lead it cannot resolve, so
-   *   there is no state in which the default send proceeds with "the other
-   *   usable agents". The session re-enters the fresh-start branch and gains a
-   *   **new** lead agent, which the stored conversation is injected into. That
-   *   is what fresh-with-history means once the old agent is owned elsewhere: a
-   *   fresh *agent*, not a second connector bolted onto one this runtime does
-   *   not own.
-   * - **`'all'`** — deliver to the usable ones; a broadcast with no recipient
-   *   is not a delivery and fails.
-   * - **an explicit array** — deliver to the usable ones; a caller that named
-   *   its agents gets a failure rather than a substitute, because substituting
-   *   would answer a question nobody asked.
-   * @param context - The send's identity, target spec and start inputs.
-   * @param targetAgents - Targets as this send materialised them.
-   * @param deferredAgentIds - Agents held by a generation this runtime does not own.
-   * @returns The surviving targets, and what a replacement start left for the caller to finish.
-   * @throws A {@link SessionStartError} when every target deferred and no fresh start applies.
-   */
-  private retargetAfterDeferral;
   /**
    * Start the session's lead agent, reserved and in the order §7.1 prescribes.
    *
@@ -618,6 +549,7 @@ declare class SessionOrchestrator implements ISessionOrchestrator {
    * @param agentSelection - Public agent selection from the request.
    * @param message - User message, used as canonical-model prompt context.
    * @param sessionContext - Session context passed through to the adapter.
+   * @param leadTransition - Whether this start creates or replaces the durable lead.
    * @returns What the adopted agents need, empty unless a race was lost.
    */
   private startLeadAgent;
@@ -659,12 +591,10 @@ declare class AdapterRegistry {
    * adapters that restart emit a fresh initialized event and the registry should
    * reflect the latest instance.
    *
-   * **The event names no machine**, and the bus can span hosts, so an instance
-   * learned this way is *unattributed*: it says an adapter of this name exists
-   * somewhere reachable, not that it belongs to any particular machine. It is
-   * therefore cached in the unscoped scope only, and a lookup that named a
-   * machine is never served from it — answering one would be a guess about the
-   * very identity the caller was careful enough to name.
+   * Every initialization announcement carries the machine that hosts the exact
+   * adapter ID, so event fallback may serve only that same scope. The unscoped
+   * entry remains for legacy observers that intentionally make no ownership
+   * assertion.
    * @param bus - The event bus to listen on
    */
   constructor(bus: IMakaioBus);
@@ -780,6 +710,10 @@ declare function resolveTargetAgents(session: IMakaioSession, targetSpec: string
 declare function findTurnByAgent(activeTurns: Map<string, Turn$1>, agentId: string): Turn$1 | undefined;
 //#endregion
 //#region services/core/src/session/utils/start-reservation.d.ts
+/** Adapter identity sufficient to route every reservation to one authority. */
+type ReservationAdapterInstance = OwnedAdapterInstance & {
+  readonly ownerInstanceId: string;
+};
 /** What every start reservation names, whatever role it takes. */
 interface StartReservationIdentity {
   /** Session the agent belongs to; verified against the agent row by the authority. */
@@ -789,9 +723,11 @@ interface StartReservationIdentity {
   /** Adapter type name carried onto any claim for diagnostics. */
   readonly adapterName: string;
   /** Instance the dispatch addresses, and the machine its ownership acts are filed under. */
-  readonly instance: OwnedAdapterInstance;
+  readonly instance: ReservationAdapterInstance;
   /** Provider session to reserve, or `null` for a start with no key yet. */
   readonly resumeProviderSessionId: string | null;
+  /** Caller-minted identity for the reservation generation. */
+  readonly claimToken: string;
 }
 /**
  * The designation half, as a union rather than an optional field.
@@ -810,7 +746,10 @@ type StartReservationDesignation = {
   /** This start leaves the designation untouched. */readonly role: Exclude<AgentRole, 'lead'>;
 };
 /** Everything a start reservation names beyond the instance it runs against. */
-type StartReservationRequest = StartReservationIdentity & StartReservationDesignation;
+type StartReservationRequest = StartReservationIdentity & StartReservationDesignation & {
+  /** Atomic snapshot for a member recovery; absent for ordinary starts. */readonly recoveryGuard?: SessionOwnershipRecoveryGuard; /** Opaque fence for this guarded recovery attempt. */
+  readonly recoveryAttemptId?: string;
+};
 /**
  * Take one start reservation.
  *
@@ -973,9 +912,8 @@ interface RecoveryConfig {
    * while the authority files the acts under its default, which is the mixed key
    * the aggregate exists to prevent.
    *
-   * Omitted only by a caller that genuinely has no machine identity — a headless
-   * host, a test composition — where every act is unscoped and consistent for
-   * that reason.
+   * Omitted when the caller cannot target a real machine. Such a recovery is
+   * deferred before it can dispatch a connector.
    */
   machineId?: string;
 }
@@ -1051,11 +989,12 @@ interface VerifiedAgents {
  * The caller's `recoveryConfig.plan` applies to every agent recovered in this
  * batch and must be the same plan the caller feeds to its history assembly.
  *
- * The **adapter instance is resolved per agent**, inside the loop, and not once
- * for the batch: a batch may span adapters, and a persisted `adapterId` goes
- * stale across a runtime restart or failover. Resolving per agent is what keeps
- * each rehydrate addressed to the live instance that actually owns that agent's
- * adapter, and keeps a single unresolvable adapter from deciding the batch.
+ * The **adapter instance is resolved per agent**, inside the exclusive recovery
+ * attempt, and not once for the batch: a batch may span adapters, and a
+ * persisted `adapterId` goes stale across a runtime restart or failover.
+ * Resolving per agent is what keeps each rehydrate addressed to the live
+ * instance that actually owns that agent's adapter, and keeps a single
+ * unresolvable adapter from deciding the batch.
  * @param bus - Bus instance
  * @param agents - Agents to verify
  * @param recoveryConfig - Configuration for recovering dead agents, including the shared recovery plan
@@ -1092,15 +1031,11 @@ type AgentRecoveryOutcome = /** A connector is live again; the agent carries the
  * Context delivery happens via the normal sendMessage path that follows
  * recovery (same handler invocation). No staging needed.
  *
- * **The instance is an input, never resolved here — and it arrives with its
- * machine.** The ownership key is `(machine, adapter instance, provider session)`,
- * so the reservation this makes has to name the very instance the rehydrate is
- * dispatched to, in the namespace of the machine that instance was derived for.
- * Resolving internally would put the reservation and the dispatch in two
- * different namespaces whenever the persisted ID went stale; taking the machine
- * as a *second*, independent input would let a caller supply two halves that
- * were never one key. The resolver hands out both together or neither, and this
- * signature only accepts it that way.
+ * Every invocation that wins the exclusive seam reads the canonical recovery
+ * snapshot and resolves its live adapter instance itself. A join can leave a
+ * different status, binding, or holder generation behind, so carrying any of
+ * those planning facts into a self-reentry would make its guarded reservation
+ * describe the attempt it joined rather than the row it is about to claim.
  *
  * The reserved rehydrate runs inside the in-flight-start seam, so a concurrent
  * consumer that finds this agent mid-recovery joins the attempt instead of
@@ -1111,12 +1046,10 @@ type AgentRecoveryOutcome = /** A connector is live again; the agent carries the
  * @param deadAgent - The dead agent to recover; its `adapterId` is re-stamped to the instance the
  *   attempt actually used
  * @param recoveryConfig - Configuration for the recovered connector
- * @param instance - Live instance to rehydrate into and the machine its ownership acts name, resolved
- *   by the caller for THIS agent
  * @returns The recovered agent, or the statement that this runtime may not drive it
  * @throws Whatever {@link failedRehydrateError} raises when the recovery failed rather than deferred
  */
-declare function recoverAgent(bus: IMakaioBus, deadAgent: MakaioSessionAgent, recoveryConfig: RecoveryConfig, instance: OwnedAdapterInstance): Promise<AgentRecoveryOutcome>;
+declare function recoverAgent(bus: IMakaioBus, deadAgent: MakaioSessionAgent, recoveryConfig: RecoveryConfig): Promise<AgentRecoveryOutcome>;
 //#endregion
 //#region services/core/src/session/utils/turn-initiator.d.ts
 /**
@@ -1131,6 +1064,72 @@ declare function recoverAgent(bus: IMakaioBus, deadAgent: MakaioSessionAgent, re
  */
 declare function buildTurnInitiator(source: 'extension' | 'user' | 'system' | undefined, extensionId: string | undefined): TurnInitiator;
 //#endregion
+//#region services/core/src/session/handlers/lead-start-request.d.ts
+/** Fully-owned payload supplied to a host-specific lead-start dispatcher. */
+type LeadStartDispatchRequest = StartAgentRequest & {
+  /** Framework-minted identity of this exact attempt. */readonly agentId: string; /** Runtime incarnation selected by the ownership reservation. */
+  readonly ownerInstanceId: string;
+};
+/**
+ * Host-specific transport policy for one already-reserved lead start.
+ *
+ * The callback may choose how the request reaches the selected adapter, but it
+ * does not own identity, persistence, reservation, settlement, or cleanup.
+ */
+type LeadStartDispatch = (request: LeadStartDispatchRequest) => Promise<StartAgentResponse>;
+/** Whether this start creates the first lead or replaces an existing one. */
+type LeadTransition = {
+  readonly kind: 'fresh';
+} | {
+  readonly kind: 'replace';
+};
+/** Everything a lead transition needs beyond the payload it dispatches. */
+interface LeadStartRequest {
+  /** Session the agent is started into. */
+  readonly sessionId: string;
+  /** Machine-scoped adapter runtime selected for dispatch and ownership. */
+  readonly instance: MachineScopedAdapterInstance;
+  /** Adapter type name, carried onto the agent row and any claim. */
+  readonly adapterName: string;
+  /** Provider config to stamp on the agent's runtime row once the start lands. */
+  readonly providerConfigId?: string;
+  /** Persona identity persisted before the adapter can create a connector. */
+  readonly personaId?: string;
+  /** Profile identity persisted before the adapter can create a connector. */
+  readonly profileId?: string;
+  /** Explicit lifecycle transition; never inferred from designation identity. */
+  readonly leadTransition: LeadTransition;
+  /** Lead designation the caller observed before entering the reservation. */
+  readonly expectedLeadAgentId: string | null;
+  /** Adapter payload, complete except for the attempt identity minted by this service. */
+  readonly startRequest: StartAgentRequest;
+  /** Optional host transport policy; the bus request remains the default. */
+  readonly dispatch?: LeadStartDispatch;
+}
+/** How a lead transition ended, for the caller that has a send to continue. */
+type LeadStartResult = {
+  /** The agent is live, owns its provider session and is `idle` in storage. */outcome: 'started'; /** The agent row as it now stands, for the caller's in-memory session. */
+  agent: MakaioSessionAgent;
+} | {
+  /** Another start won the designation race and this attempt left nothing behind. */outcome: 'lead-conflict'; /** Lead the session actually names, or `null` when it has none. */
+  currentLeadAgentId: string | null;
+};
+//#endregion
+//#region services/core/src/session/handlers/lead-start.d.ts
+/**
+ * Start or replace a session lead under the ownership reservation.
+ *
+ * The whole attempt runs inside the in-flight-start seam, registered *before*
+ * the agent row is written. There is therefore no instant at which a `starting`
+ * row is visible without an entry a concurrent consumer can join, which is what
+ * lets that consumer wait for this attempt instead of opening a second
+ * lifecycle for the same identity.
+ * @param bus - Bus every step is issued on.
+ * @param request - The start to run.
+ * @returns The started agent, or the designation race this start lost.
+ */
+declare function startLeadAgent(bus: IMakaioBus, request: LeadStartRequest): Promise<LeadStartResult>;
+//#endregion
 //#region services/core/src/session/session-orchestrator-selection.d.ts
 /** What resolving a fresh start's instance needs beyond the selection itself. */
 interface SelectionInstanceContext {
@@ -1173,8 +1172,8 @@ interface SelectionInstanceContext {
  * @param selection - Direct adapter selection this start runs from.
  * @param context - Adapter name, session identity, this runtime's machine and its instance registry.
  * @returns The instance and the machine, as one key.
- * @throws A {@link SessionStartError} when a named instance carries no machine, or
- *   a named machine carries no instance.
+ * @throws A {@link SessionStartError} when an identity is incomplete or its
+ *   complete explicit triple has no matching live announcement.
  */
 declare function resolveSelectionOwnedInstance(bus: IMakaioBus, selection: AdapterSelection, context: SelectionInstanceContext): Promise<MachineScopedAdapterInstance>;
 //#endregion
@@ -1669,6 +1668,11 @@ declare const AgentStorageNamespace: _$_makaio_storage_core0.StorageNamespaceDef
         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<{
@@ -1729,6 +1733,11 @@ declare const AgentStorageNamespace: _$_makaio_storage_core0.StorageNamespaceDef
         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<{
@@ -1808,6 +1817,11 @@ declare const AgentStorageNamespace: _$_makaio_storage_core0.StorageNamespaceDef
         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<{
@@ -1862,6 +1876,11 @@ declare const AgentStorageNamespace: _$_makaio_storage_core0.StorageNamespaceDef
         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<{
@@ -1967,6 +1986,10 @@ declare const AgentStorageNamespace: _$_makaio_storage_core0.StorageNamespaceDef
     request: z.ZodObject<{
       agentId: z.ZodString;
       adapterId: z.ZodOptional<z.ZodString>;
+      runtimeOwner: z.ZodOptional<z.ZodObject<{
+        machineId: z.ZodString;
+        instanceId: z.ZodString;
+      }, z.core.$strip>>;
       adapterSessionId: z.ZodOptional<z.ZodString>;
       cwd: z.ZodOptional<z.ZodString>;
       model: z.ZodOptional<z.ZodString>;
@@ -2059,6 +2082,63 @@ declare const AgentStorageNamespace: _$_makaio_storage_core0.StorageNamespaceDef
         }, {}, {
           length: number | undefined;
         }>;
+        ownerMachineId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "owner_machine_id";
+          tableName: "agents";
+          dataType: "string";
+          columnType: "SQLiteText";
+          data: string;
+          driverParam: string;
+          notNull: false;
+          hasDefault: false;
+          isPrimaryKey: false;
+          isAutoincrement: false;
+          hasRuntimeDefault: false;
+          enumValues: [string, ...string[]];
+          baseColumn: never;
+          identity: undefined;
+          generated: undefined;
+        }, {}, {
+          length: number | undefined;
+        }>;
+        ownerInstanceId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "owner_instance_id";
+          tableName: "agents";
+          dataType: "string";
+          columnType: "SQLiteText";
+          data: string;
+          driverParam: string;
+          notNull: false;
+          hasDefault: false;
+          isPrimaryKey: false;
+          isAutoincrement: false;
+          hasRuntimeDefault: false;
+          enumValues: [string, ...string[]];
+          baseColumn: never;
+          identity: undefined;
+          generated: undefined;
+        }, {}, {
+          length: number | undefined;
+        }>;
+        recoveryAttemptId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "recovery_attempt_id";
+          tableName: "agents";
+          dataType: "string";
+          columnType: "SQLiteText";
+          data: string;
+          driverParam: string;
+          notNull: false;
+          hasDefault: false;
+          isPrimaryKey: false;
+          isAutoincrement: false;
+          hasRuntimeDefault: false;
+          enumValues: [string, ...string[]];
+          baseColumn: never;
+          identity: undefined;
+          generated: undefined;
+        }, {}, {
+          length: number | undefined;
+        }>;
         adapterSessionId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
           name: "adapter_session_id";
           tableName: "agents";
@@ -2418,6 +2498,11 @@ declare const AgentStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.
         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<{
@@ -2478,6 +2563,11 @@ declare const AgentStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.
         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<{
@@ -2557,6 +2647,11 @@ declare const AgentStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.
         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<{
@@ -2611,6 +2706,11 @@ declare const AgentStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.
         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<{
@@ -2716,6 +2816,10 @@ declare const AgentStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.
     request: z.ZodObject<{
       agentId: z.ZodString;
       adapterId: z.ZodOptional<z.ZodString>;
+      runtimeOwner: z.ZodOptional<z.ZodObject<{
+        machineId: z.ZodString;
+        instanceId: z.ZodString;
+      }, z.core.$strip>>;
       adapterSessionId: z.ZodOptional<z.ZodString>;
       cwd: z.ZodOptional<z.ZodString>;
       model: z.ZodOptional<z.ZodString>;
@@ -2745,6 +2849,8 @@ interface SessionStorageMemoryState {
   readonly agents: Map<string, MakaioSessionAgent>;
   /** Claim rows keyed by `claimId`. */
   readonly claims: Map<string, AdapterSessionClaimRecord>;
+  /** Runtime-instance rows keyed by the process/machine pair. */
+  readonly runtimeInstances: Map<string, RuntimeInstanceRecord>;
 }
 /**
  * Allocate a fresh, empty in-memory state instance.
@@ -3592,6 +3698,63 @@ declare const sessionStorageSchema: _$_makaio_storage_drizzle0.DialectSchema<{
       }, {}, {
         length: number | undefined;
       }>;
+      ownerMachineId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: "owner_machine_id";
+        tableName: "agents";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      ownerInstanceId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: "owner_instance_id";
+        tableName: "agents";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      recoveryAttemptId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: "recovery_attempt_id";
+        tableName: "agents";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
       adapterSessionId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
         name: "adapter_session_id";
         tableName: "agents";
@@ -3929,6 +4092,145 @@ declare const sessionStorageSchema: _$_makaio_storage_drizzle0.DialectSchema<{
     };
     dialect: "sqlite";
   }>;
+  runtimeInstanceIncarnationCounters: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<{
+    name: "runtime_instance_incarnation_counters";
+    schema: undefined;
+    columns: {
+      machineId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: "machine_id";
+        tableName: "runtime_instance_incarnation_counters";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: true;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      lastAllocatedIncarnation: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: string;
+        tableName: "runtime_instance_incarnation_counters";
+        dataType: "number";
+        columnType: "SQLiteInteger";
+        data: number;
+        driverParam: number;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+    };
+    dialect: "sqlite";
+  }>;
+  runtimeInstances: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<{
+    name: "runtime_instances";
+    schema: undefined;
+    columns: {
+      instanceId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: "instance_id";
+        tableName: "runtime_instances";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      machineId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: "machine_id";
+        tableName: "runtime_instances";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
+      incarnation: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: string;
+        tableName: "runtime_instances";
+        dataType: "number";
+        columnType: "SQLiteInteger";
+        data: number;
+        driverParam: number;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+      startedAt: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: string;
+        tableName: "runtime_instances";
+        dataType: "number";
+        columnType: "SQLiteInteger";
+        data: number;
+        driverParam: number;
+        notNull: true;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+      retiredAt: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: string;
+        tableName: "runtime_instances";
+        dataType: "number";
+        columnType: "SQLiteInteger";
+        data: number;
+        driverParam: number;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+    };
+    dialect: "sqlite";
+  }>;
   adapterSessionClaims: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<{
     name: "adapter_session_claims";
     schema: undefined;
@@ -4066,6 +4368,25 @@ declare const sessionStorageSchema: _$_makaio_storage_drizzle0.DialectSchema<{
       }, {}, {
         length: number | undefined;
       }>;
+      ownerInstanceId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: "owner_instance_id";
+        tableName: "adapter_session_claims";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
       claimToken: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
         name: "claim_token";
         tableName: "adapter_session_claims";
@@ -4221,6 +4542,28 @@ declare function registerMemorySessionOwnershipStorage(bus: IMakaioBus, state?:
  */
 declare function registerDrizzleSessionOwnershipStorage(bus: IMakaioBus, db: MakaioDatabase): () => void;
 //#endregion
+//#region services/core/src/session/storage/ownership-drizzle-claim-keys.d.ts
+/** Versioned namespace for ownership-key lock identities. */
+declare const SESSION_OWNERSHIP_CLAIM_LOCK_NAMESPACE = "makaio:session-ownership:claim:v1";
+/** Claim-key fields that identify one provider-session ownership row. */
+interface OwnershipClaimKey {
+  /** Runtime machine owning the provider session store. */
+  readonly machineId: string;
+  /** Adapter runtime owning the provider session. */
+  readonly adapterId: string;
+  /** Provider-native session identifier. */
+  readonly providerSessionId: string;
+}
+/**
+ * Build the stable transaction lock for one ownership key.
+ *
+ * JSON arrays preserve field boundaries while keeping the identity independent
+ * of the storage row that currently represents this key.
+ * @param key - Provider-session ownership key.
+ * @returns Stable transaction lock used before claim-row mutation.
+ */
+declare function ownershipClaimTransactionLock(key: OwnershipClaimKey): TransactionLock;
+//#endregion
 //#region services/core/src/session/storage/fts-search-handler.d.ts
 /**
  * Registers FTS-backed `storage:session.search` handler.
@@ -6253,8 +6596,8 @@ declare const MessageRoutingNamespace: _$_makaio_storage_core0.StorageNamespaceD
       agentId: z.ZodString;
       status: z.ZodEnum<{
         completed: "completed";
-        sent: "sent";
         acknowledged: "acknowledged";
+        sent: "sent";
       }>;
       timestamp: z.ZodNumber;
       error: z.ZodOptional<z.ZodString>;
@@ -6279,8 +6622,8 @@ declare const MessageRoutingNamespace: _$_makaio_storage_core0.StorageNamespaceD
         agentId: z.ZodString;
         status: z.ZodEnum<{
           completed: "completed";
-          sent: "sent";
           acknowledged: "acknowledged";
+          sent: "sent";
         }>;
         timestamp: z.ZodNumber;
         error: z.ZodOptional<z.ZodString>;
@@ -6367,7 +6710,7 @@ declare const MessageRoutingNamespace: _$_makaio_storage_core0.StorageNamespaceD
           tableName: "message_routing";
           dataType: "string";
           columnType: "SQLiteText";
-          data: "completed" | "sent" | "acknowledged";
+          data: "completed" | "acknowledged" | "sent";
           driverParam: string;
           notNull: true;
           hasDefault: false;
@@ -6438,8 +6781,8 @@ declare const MessageRoutingSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core
       agentId: z.ZodString;
       status: z.ZodEnum<{
         completed: "completed";
-        sent: "sent";
         acknowledged: "acknowledged";
+        sent: "sent";
       }>;
       timestamp: z.ZodNumber;
       error: z.ZodOptional<z.ZodString>;
@@ -6464,8 +6807,8 @@ declare const MessageRoutingSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core
         agentId: z.ZodString;
         status: z.ZodEnum<{
           completed: "completed";
-          sent: "sent";
           acknowledged: "acknowledged";
+          sent: "sent";
         }>;
         timestamp: z.ZodNumber;
         error: z.ZodOptional<z.ZodString>;
@@ -6609,7 +6952,7 @@ declare const messageRouting: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<
       tableName: "message_routing";
       dataType: "string";
       columnType: "SQLiteText";
-      data: "completed" | "sent" | "acknowledged";
+      data: "completed" | "acknowledged" | "sent";
       driverParam: string;
       notNull: true;
       hasDefault: false;
@@ -7069,4 +7412,4 @@ interface NativeLocalityInput {
  */
 declare function evaluateNativeLocality(input: NativeLocalityInput): NativeLocalityVerdict;
 //#endregion
-export { IngestCompletedTurnResult as $, resetBuiltInActionsRegistration as $t, registerDrizzleMessageStorage as A, getOrCreateSession as An, registerMemorySessionOwnershipStorage as At, importCursorsDual as B, mintClaimToken as Bn, createSessionExtensionContext as Bt, registerDrizzleMessageRoutingStorage as C, RecoveryPlan as Cn, fetchAgentsBySession as Ct, SelectMessage as D, StartReservationRequest as Dn, parseForkTransforms as Dt, InsertMessage as E, recoveryPlanResumeTarget as En, mapRowToSession as Et, registerMemoryTurnStorage as F, AdapterRegistry as Fn, SessionStorageMemoryState as Ft, ObservedSessionIngestionPolicyInput as G, registerAdapterSessionMovementObserver as Gn, CONNECTOR_SWAP_DEFAULT_PIPELINE as Gt, OBSERVED_SESSION_INGESTION_POLICY_CAPABILITY_ID as H, InFlightStart as Hn, assembleForkContext as Ht, registerDrizzleTurnStorage as I, ISessionOrchestrator as In, createSessionStorageMemoryState as It, ObservedSessionIngestionService as J, MakaioSessionService as Jn, describeHalfNamedInstanceRefusal as Jt, registerObservedSessionIngestionPolicyProvider as K, SessionOwnershipAuthorityDeps as Kn, NamedSelectionInstance as Kt, EmbeddingIndexManager as L, SessionOrchestrator as Ln, AgentStorageNamespace as Lt, SelectTurn as M, extractTextContent as Mn, registerMemoryAgentStorage as Mt, turns as N, normalizeToBlocks as Nn, registerDrizzleSessionStorage as Nt, messages as O, reserveStartFor as On, registerFtsSearchHandler as Ot, turnsDual as P, TurnContextEnricher as Pn, registerMemorySessionStorage as Pt, IngestCompletedTurnParams as Q, registerBuiltInActions as Qt, registerDrizzleImportCursorStorage as R, registerCoreSessionServiceHandlers as Rn, AgentStorageSubjects as Rt, messageRoutingDual as S, NativeResumeRecoveryPlan as Sn, SearchSessionRow as St, MessageRoutingSubjects as T, recoveryPlanRequiresHistory as Tn, fetchPreviewBySession as Tt, ObservedSessionIngestionPolicyDecision as U, peekInFlightStart as Un, FallbackRuntimeOptions as Ut, IObservedSessionIngestionPolicyProvider as V, enqueueAgentSettle as Vn, SessionBridge as Vt, ObservedSessionIngestionPolicyImportStatus as W, runExclusiveStart as Wn, pickFallbackRuntimeOptions as Wt, isTrackingStub as X, resolveAdapterNameById as Xt, isPolicyDiscoveredObservedSession as Y, MakaioSessionServiceOptions as Yn, normalizeSelectionString as Yt, LogImportTriggerSubjects as Z, registerListActionsHandler as Zt, MakaioSessionConfig as _, verifyAndRecoverAgents as _n, SessionPreviewMaps as _t, resolveSessionResumeIdentity as a, ContextWindowTrackerConfig as an, SessionUserMessageSentPayload as at, SelectMessageRouting as b, FRESH_WITH_HISTORY_RECOVERY_PLAN as bn, mapToSession as bt, BuildContextOptions as c, resolveSelectionOwnedInstance as cn, emitSessionUserMessageSent as ct, toSessionLineage as d, RecoveryConfig as dn, registerMemorySessionEventStorage as dt, actionRegistry as en, IngestTurnMessage as et, registerSessionDiscoveredHandler as f, VerifiedAgents as fn, InsertSessionEvent as ft, MakaioSession as g, recoverAgent as gn, getSessionAncestorChain as gt, registerParentResolver as h, ensureAgentModel as hn, sessionEventsDual as ht, SessionResumeIdentity as i, AgentContextState as in, SessionTurnStartedPayload as it, InsertTurn as j, resolveTargetAgents as jn, registerDrizzleAgentStorage as jt, registerMemoryMessageStorage as k, findTurnByAgent as kn, registerDrizzleSessionOwnershipStorage as kt, ContextAssemblyResult as l, buildTurnInitiator as ln, registerSessionLifecycleEventWriters as lt, registerCompressLineageResolver as m, ensureAgentCwd as mn, sessionEvents as mt, NativeLocalityIntent as n, registerResumeHandler as nn, EventTransform as nt, getFullConversation as o, SessionContextWindowState as on, appendSessionLifecycleEvent as ot, registerSpawningToolCallResolver as p, buildRecoveryContextWithPipeline as pn, SelectSessionEvent as pt, unregisterObservedSessionIngestionPolicyProvider as q, registerSessionOwnershipAuthority as qn, SelectionRefusalContext as qt, evaluateNativeLocality as r, ContextWindowTracker as rn, SessionLifecycleEventArgs as rt, buildSessionContext as s, SelectionInstanceContext as sn, emitSessionTurnStarted as st, NativeLocalityInput as t, registerGetStatusCountsHandler as tn, ingestCompletedTurn as tt, kindToBranchKind as u, AgentRecoveryOutcome as un, registerDrizzleSessionEventStorage as ut, StartTurnOptions as v, buildPlannedRecoveryContext as vn, fetchSessionPreviewMaps as vt, MessageRoutingNamespace as w, planAgentRecovery as wn, fetchMessageCountsBySession as wt, messageRouting as x, FreshWithHistoryRecoveryPlan as xn, SearchFilters as xt, InsertMessageRouting as y, buildRecoveryContext as yn, mapAgentsBySession as yt, importCursors as z, assessClaimOwner as zn, SessionExtensionContextImpl as zt };
+export { IngestCompletedTurnResult as $, runExclusiveStart as $n, resolveAdapterNameById as $t, registerDrizzleMessageStorage as A, FreshWithHistoryRecoveryPlan as An, SESSION_OWNERSHIP_CLAIM_LOCK_NAMESPACE as At, importCursorsDual as B, resolveTargetAgents as Bn, AgentStorageNamespace as Bt, registerDrizzleMessageRoutingStorage as C, ensureAgentCwd as Cn, fetchAgentsBySession as Ct, SelectMessage as D, buildPlannedRecoveryContext as Dn, parseForkTransforms as Dt, InsertMessage as E, verifyAndRecoverAgents as En, mapRowToSession as Et, registerMemoryTurnStorage as F, recoveryPlanResumeTarget as Fn, registerMemoryAgentStorage as Ft, ObservedSessionIngestionPolicyInput as G, ISessionOrchestrator as Gn, assembleForkContext as Gt, OBSERVED_SESSION_INGESTION_POLICY_CAPABILITY_ID as H, normalizeToBlocks as Hn, SessionExtensionContextImpl as Ht, registerDrizzleTurnStorage as I, StartReservationRequest as In, registerDrizzleSessionStorage as It, ObservedSessionIngestionService as J, assessClaimOwner as Jn, CONNECTOR_SWAP_DEFAULT_PIPELINE as Jt, registerObservedSessionIngestionPolicyProvider as K, SessionOrchestrator as Kn, FallbackRuntimeOptions as Kt, EmbeddingIndexManager as L, reserveStartFor as Ln, registerMemorySessionStorage as Lt, SelectTurn as M, RecoveryPlan as Mn, registerDrizzleSessionOwnershipStorage as Mt, turns as N, planAgentRecovery as Nn, registerMemorySessionOwnershipStorage as Nt, messages as O, buildRecoveryContext as On, registerFtsSearchHandler as Ot, turnsDual as P, recoveryPlanRequiresHistory as Pn, registerDrizzleAgentStorage as Pt, IngestCompletedTurnParams as Q, peekInFlightStart as Qn, normalizeSelectionString as Qt, registerDrizzleImportCursorStorage as R, findTurnByAgent as Rn, SessionStorageMemoryState as Rt, messageRoutingDual as S, buildRecoveryContextWithPipeline as Sn, SearchSessionRow as St, MessageRoutingSubjects as T, recoverAgent as Tn, fetchPreviewBySession as Tt, ObservedSessionIngestionPolicyDecision as U, TurnContextEnricher as Un, createSessionExtensionContext as Ut, IObservedSessionIngestionPolicyProvider as V, extractTextContent as Vn, AgentStorageSubjects as Vt, ObservedSessionIngestionPolicyImportStatus as W, AdapterRegistry as Wn, SessionBridge as Wt, isTrackingStub as X, enqueueAgentSettle as Xn, SelectionRefusalContext as Xt, isPolicyDiscoveredObservedSession as Y, mintClaimToken as Yn, NamedSelectionInstance as Yt, LogImportTriggerSubjects as Z, InFlightStart as Zn, describeHalfNamedInstanceRefusal as Zt, MakaioSessionConfig as _, LeadTransition as _n, SessionPreviewMaps as _t, resolveSessionResumeIdentity as a, registerResumeHandler as an, SessionUserMessageSentPayload as at, SelectMessageRouting as b, RecoveryConfig as bn, mapToSession as bt, BuildContextOptions as c, ContextWindowTrackerConfig as cn, emitSessionUserMessageSent as ct, toSessionLineage as d, resolveSelectionOwnedInstance as dn, registerMemorySessionEventStorage as dt, registerListActionsHandler as en, registerAdapterSessionMovementObserver as er, IngestTurnMessage as et, registerSessionDiscoveredHandler as f, startLeadAgent as fn, InsertSessionEvent as ft, MakaioSession as g, LeadStartResult as gn, getSessionAncestorChain as gt, registerParentResolver as h, LeadStartRequest as hn, sessionEventsDual as ht, SessionResumeIdentity as i, registerGetStatusCountsHandler as in, MakaioSessionServiceOptions as ir, SessionTurnStartedPayload as it, InsertTurn as j, NativeResumeRecoveryPlan as jn, ownershipClaimTransactionLock as jt, registerMemoryMessageStorage as k, FRESH_WITH_HISTORY_RECOVERY_PLAN as kn, OwnershipClaimKey as kt, ContextAssemblyResult as l, SessionContextWindowState as ln, registerSessionLifecycleEventWriters as lt, registerCompressLineageResolver as m, LeadStartDispatchRequest as mn, sessionEvents as mt, NativeLocalityIntent as n, resetBuiltInActionsRegistration as nn, registerSessionOwnershipAuthority as nr, EventTransform as nt, getFullConversation as o, ContextWindowTracker as on, appendSessionLifecycleEvent as ot, registerSpawningToolCallResolver as p, LeadStartDispatch as pn, SelectSessionEvent as pt, unregisterObservedSessionIngestionPolicyProvider as q, registerCoreSessionServiceHandlers as qn, pickFallbackRuntimeOptions as qt, evaluateNativeLocality as r, actionRegistry as rn, MakaioSessionService as rr, SessionLifecycleEventArgs as rt, buildSessionContext as s, AgentContextState as sn, emitSessionTurnStarted as st, NativeLocalityInput as t, registerBuiltInActions as tn, SessionOwnershipAuthorityDeps as tr, ingestCompletedTurn as tt, kindToBranchKind as u, SelectionInstanceContext as un, registerDrizzleSessionEventStorage as ut, StartTurnOptions as v, buildTurnInitiator as vn, fetchSessionPreviewMaps as vt, MessageRoutingNamespace as w, ensureAgentModel as wn, fetchMessageCountsBySession as wt, messageRouting as x, VerifiedAgents as xn, SearchFilters as xt, InsertMessageRouting as y, AgentRecoveryOutcome as yn, mapAgentsBySession as yt, importCursors as z, getOrCreateSession as zn, createSessionStorageMemoryState as zt };