@makaio/framework 1.0.0-dev-1783355411417 → 1.0.0-dev-1783477169057

package/dist/{index-3J0HZlPH.d.mts → index-DScUb-hF.d.mts}

@@ -1,12 +1,12 @@
 import { r as ExecutionTarget } from "./schemas-D4zaFE2p.mjs";
-import { d as Turn$1 } from "./index-BYfSAJRC.mjs";
-import { a as PipelineStep, o as SessionEditorAction, t as ActionCategory } from "./types-BMS6yfLS.mjs";
+import { d as Turn$1 } from "./index-BvTd61i5.mjs";
+import { a as PipelineStep, o as SessionEditorAction, t as ActionCategory } from "./types-BNW5n6qm.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, BranchKind, ContextWindowState, ForkOptions, ForkTransforms, ICapabilityProvider, IMakaioSession, JsonValue, MakaioSessionAgent, MakaioSessionEvent, Message, MessageBlock, MessageInput, ReasoningLevelMap, SessionContext, SessionEventType, SessionExtensionContext, SessionLineage, SessionLineageKind, SessionMessage, SessionMessageBlock, SessionMessageOrigin, SessionSubjects, TurnIngestionMarker, TurnInitiator, TurnUsage } from "@makaio/framework/contracts";
+import { AIReasoningLevel, AdapterRuntimeOptions, BranchKind, ContextWindowState, ForkOptions, ForkTransforms, ICapabilityProvider, IMakaioSession, JsonValue, MakaioSessionAgent, MakaioSessionEvent, Message, MessageBlock, MessageInput, NativeLocalityVerdict, ReasoningLevelMap, SessionContext, SessionEventType, SessionExtensionContext, SessionLineage, SessionLineageKind, SessionMessage, SessionMessageBlock, SessionMessageOrigin, SessionSubjects, 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";
@@ -182,13 +182,16 @@ declare class SessionOrchestrator implements ISessionOrchestrator {
   private readonly bus;
   private readonly turnManager;
   private readonly adapterRegistry;
+  private readonly machineId;
   /** Cleanup functions for bus subscriptions. */
   private readonly cleanups;
   /**
    * @param bus - Event bus used for handler registration and message routing
-   * @param _machineId - Machine identifier (reserved for future routing use)
+   * @param machineId - Stable machine identity forwarded to the attach handler
+   *   to drive native-locality decisions (resume locality evaluation, adapter
+   *   instance resolution).
    */
-  constructor(bus: IMakaioBus | undefined, _machineId: string);
+  constructor(bus: IMakaioBus | undefined, machineId: string);
   /**
    * Register the `session.sendMessage` RPC handler.
    *
@@ -357,9 +360,10 @@ declare function normalizeToBlocks(message: MessageInput): SessionMessageBlock[]
  * @param providedSessionId - Session ID to look up
  * @param _sessionContext - Optional session context (scope fields removed in W1-A)
  * @param originWindowId - Window ID that initiated the session creation
+ * @param machineId - Machine identity to stamp on the session at creation time
  * @returns Session ID and session object
  */
-declare function getOrCreateSession(bus: IMakaioBus, providedSessionId: string, _sessionContext?: SessionContext, originWindowId?: string): Promise<{
+declare function getOrCreateSession(bus: IMakaioBus, providedSessionId: string, _sessionContext?: SessionContext, originWindowId?: string, machineId?: string): Promise<{
   sessionId: string;
   session: IMakaioSession;
 }>;
@@ -436,6 +440,15 @@ interface RecoveryConfig {
   cwd?: string;
   /** Model identifier (e.g., 'claude-sonnet-4-20250514', 'gpt-4o') */
   model?: string;
+  /**
+   * Provider-native session ID to resume.
+   *
+   * When set, the adapter creates the connector in native-resume mode so the
+   * provider session continues from where it left off. The caller is responsible
+   * for evaluating locality (machine identity, adapter capability, CWD match)
+   * before setting this field.
+   */
+  resumeAdapterSessionId?: string;
 }
 /**
  * Ensure agent cwd matches desired cwd, swapping connector if needed.
@@ -797,15 +810,24 @@ type FallbackRuntimeOptions = Pick<AdapterRuntimeOptions, 'cwd' | 'systemPrompt'
 declare function pickFallbackRuntimeOptions(payload: Partial<Pick<AdapterRuntimeOptions, 'cwd' | 'systemPrompt' | 'allowedTools' | 'disallowedTools'>>): FallbackRuntimeOptions;
 //#endregion
 //#region services/core/src/session/context/assemble-fork-context.d.ts
+/** Adapter capability signals required before emitting a native fork directive. */
+interface AssembleForkContextCapabilities {
+  /** Adapter declares provider-native fork support for the selected target. */
+  readonly adapterSupportsNativeFork: boolean;
+  /** Adapter declares support for provider-native mid-history/checkpoint fork. */
+  readonly midHistoryForkSupported: boolean;
+}
 /**
  * Assemble fork context for a session's first turn.
  *
  * For fork sessions on their first turn, this:
  * 1. Detects if this is a fork session (has parentSessionId)
  * 2. Checks if this is the first turn (via isNewTurn flag + storage query)
- * 3. Calls getFullConversation() to get projected context with transforms
- * 4. Converts SessionMessage[] to Message[] format
- * 5. Returns enriched SessionContext with messageHistory
+ * 3. Evaluates native locality for the source (parent) session
+ * 4a. If native: returns a fork directive without message history injection
+ * 4b. Otherwise: calls getFullConversation() to get projected context with transforms,
+ *     converts SessionMessage[] to Message[] format, and attaches the locality verdict
+ * 5. Returns enriched SessionContext
  *
  * If not a fork first turn, returns the original sessionContext unchanged.
  * @param bus - Bus instance for RPC calls
@@ -813,9 +835,24 @@ declare function pickFallbackRuntimeOptions(payload: Partial<Pick<AdapterRuntime
  * @param sessionId - Session ID
  * @param originalContext - Original sessionContext from payload
  * @param isNewTurn - Whether this is a new turn (avoids race with just-created turn record)
+ * @param localMachineId - Stable machine identity of the current host process
+ * @param capabilities - Adapter capability signals resolved by the caller
+ * @param targetCwd - Effective working directory for the new agent, overriding
+ *   `session.targetWorkingDirectory` in the locality check. Callers that resolve
+ *   a per-request cwd override (e.g. a send payload `cwd` field) must pass the
+ *   resolved value here so the native-fork evaluation and the eventual
+ *   `startAgent` call operate on the same cwd — preventing a mismatch where
+ *   locality is approved against the stored session cwd but the agent starts in
+ *   a different directory.
+ * @param targetAdapterName - Stable adapter type name of the target adapter.
+ *   Compared against the source session's adapterName to prevent cross-adapter
+ *   fork — sending a provider session ID to a different adapter type would
+ *   corrupt the conversation. Undefined when the caller cannot determine the
+ *   target adapter (e.g. route-to-agents with mixed adapters); in that case the
+ *   adapter-mismatch check is skipped.
  * @returns Enriched or original SessionContext
  */
-declare function assembleForkContext(bus: IMakaioBus, session: IMakaioSession, sessionId: string, originalContext?: SessionContext, isNewTurn?: boolean): Promise<SessionContext | undefined>;
+declare function assembleForkContext(bus: IMakaioBus, session: IMakaioSession, sessionId: string, originalContext?: SessionContext, isNewTurn?: boolean, localMachineId?: string, capabilities?: AssembleForkContextCapabilities, targetCwd?: string, targetAdapterName?: string): Promise<SessionContext | undefined>;
 //#endregion
 //#region services/core/src/session/session-bridge.d.ts
 declare class SessionBridge {
@@ -1159,6 +1196,7 @@ declare const AgentStorageNamespace: _$_makaio_storage_core0.StorageNamespaceDef
     request: z.ZodObject<{
       agentId: z.ZodString;
       adapterId: z.ZodOptional<z.ZodString>;
+      adapterSessionId: z.ZodOptional<z.ZodString>;
       cwd: z.ZodOptional<z.ZodString>;
       model: z.ZodOptional<z.ZodString>;
       allowedDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -1768,6 +1806,7 @@ declare const AgentStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.
     request: z.ZodObject<{
       agentId: z.ZodString;
       adapterId: z.ZodOptional<z.ZodString>;
+      adapterSessionId: z.ZodOptional<z.ZodString>;
       cwd: z.ZodOptional<z.ZodString>;
       model: z.ZodOptional<z.ZodString>;
       allowedDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -2020,7 +2059,7 @@ declare const sessionStorageSchema: _$_makaio_storage_drizzle0.DialectSchema<{
         tableName: "sessions";
         dataType: "string";
         columnType: "SQLiteText";
-        data: "fork" | "subagent" | "compress" | "branch" | "rewrite" | "coordinator" | "aside";
+        data: "fork" | "subagent" | "branch" | "compress" | "rewrite" | "coordinator" | "aside";
         driverParam: string;
         notNull: false;
         hasDefault: false;
@@ -2461,6 +2500,25 @@ declare const sessionStorageSchema: _$_makaio_storage_drizzle0.DialectSchema<{
         identity: undefined;
         generated: undefined;
       }, {}, {}>;
+      machineId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+        name: "machine_id";
+        tableName: "sessions";
+        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;
+      }>;
     };
     dialect: "sqlite";
   }>;
@@ -2880,6 +2938,7 @@ type SearchSessionRow = {
   fork_transforms: string | null;
   target_working_directory: string | null;
   metadata: Record<string, JsonValue> | string | null;
+  machine_id: string | null;
 };
 /**
  * Filter parameters accepted by FTS search queries.
@@ -3674,6 +3733,194 @@ declare const LogImportTriggerSubjects: _$_makaio_core0.BusSubjects<_$_makaio_co
  * @returns True when content import must be suppressed
  */
 declare function isPolicyDiscoveredObservedSession(session: Pick<IMakaioSession, 'clientId' | 'importStatus'>): boolean;
+/**
+ * Check whether a stored session is a hook-first tracking stub.
+ *
+ * A tracking stub is the session row created by
+ * `ObservedSessionIngestionService.handleSessionStarted` when the
+ * `SessionStart` hook fires before the suppression gate is populated.
+ * Its fingerprint is:
+ * - `isImported: true` (set by `importUpsert`)
+ * - `importStatus: 'tracking'` (live-followed observed session)
+ * - `clientId` is present (hook-observed, not watcher-discovered)
+ *
+ * This predicate is the single source of truth for stub identification
+ * across reconciliation and diagnostic paths. Externally observed
+ * terminal sessions share this fingerprint, but they never trigger
+ * `client.runtime.started` — the caller discriminates by context.
+ * @param session - Stored session row to inspect
+ * @returns True when the session matches the tracking-stub fingerprint
+ */
+declare function isTrackingStub(session: Pick<IMakaioSession, 'isImported' | 'importStatus' | 'clientId'>): boolean;
+/**
+ * Bridges observed client sessions into the canonical session model.
+ *
+ * Responsibilities:
+ * - Register observed sessions on `client.session.started` through the
+ *   unified registration seam (`storage:session.importUpsert`), keyed on the
+ *   importer's adapter name so hook-first registration and later transcript
+ *   imports converge on the same `(source, adapterSessionId)` identity.
+ * - Trigger targeted transcript imports on `client.session.turn.completed`
+ *   (`log-import.importFile` when the transcript path is known, discovery
+ *   fallback via `log-import.importSession` otherwise).
+ * - Suppress all work for adapter-managed sessions: sessions the managed
+ *   orchestration path drives already flow through the orchestrator and must
+ *   not be double-ingested (gate fed by `client.runtime.started`).
+ *
+ * Non-responsibilities:
+ * - Holds NO turn state — turn boundaries and content come exclusively from
+ *   the transcript reconstruction during import (design Principle 4).
+ * - Never emits `session.*` subjects itself — the turn lifecycle ingestion
+ *   seam is the single emitter (design Principle 2).
+ *
+ * The component is client-agnostic: client and importer identities come from
+ * event payloads and the log-import registry, never from hard-coded client
+ * ids. A single subscription per subject on the global `client` namespace
+ * covers every emitting client; `clientId` in the payload is the
+ * discriminator. When no log-import service or no matching importer is
+ * registered (framework-only mode), all work is skipped silently.
+ */
+declare class ObservedSessionIngestionService {
+  private readonly bus;
+  /**
+   * Adapter session IDs owned by the managed orchestration path.
+   *
+   * FIFO-capped at {@link MANAGED_SESSION_CAP}; insertion order is the
+   * eviction order (mirrors the client services' gate).
+   */
+  private readonly managedAdapterSessionIds;
+  /**
+   * Importer resolutions per client id.
+   *
+   * Importers register at boot and do not un-register mid-session, so this
+   * cache (including misses) is valid for the lifetime of the service instance.
+   */
+  private readonly importerByClientId;
+  /** Client ids already debug-logged as unresolvable (one log per client id). */
+  private readonly unresolvedClientIds;
+  /** Registered optional policy providers; deny/discovered decisions win. */
+  private readonly policyProviders;
+  private readonly cleanups;
+  /**
+   * Create the service and subscribe to the observed-session subjects.
+   * @param bus - Application bus instance
+   */
+  constructor(bus?: IMakaioBus);
+  /** Unsubscribe all bus handlers. */
+  destroy(): void;
+  /**
+   * Record adapter-managed sessions in the suppression gate and reconcile
+   * any hook-first tracking stub.
+   *
+   * Unlike the per-client gates inside the client services, this component
+   * does not filter by `clientId`: it is client-agnostic, and an adapter
+   * session ID marked as managed must suppress observed ingestion regardless
+   * of which client runtime reported it. Non-adapter source layers (e.g.
+   * `'supervisor'`, `'statusline'`) never suppress — they observe sessions
+   * the managed path does not own.
+   *
+   * **Stub reconciliation:** When the `SessionStart` hook fires before this
+   * gate is populated (hook-first ingestion race), `handleSessionStarted`
+   * creates a tracking stub via `importUpsert`. This stub and the live
+   * session row coexist as duplicates. `client.runtime.started` is the
+   * authoritative, guaranteed-to-arrive signal that the adapter session is
+   * managed. On arrival, any existing tracking stub for the same
+   * `(source, adapterSessionId)` is reconciled: deleted when inert, or
+   * preserved when it already carries imported messages (native takeover
+   * of an externally observed session — see the content guard below).
+   *
+   * Externally observed terminal sessions share the same storage fingerprint
+   * (`isImported: true`, `importStatus: 'tracking'`, `clientId` set) but
+   * never trigger `client.runtime.started` for their `adapterSessionId` —
+   * they are observed via hooks only, without a `client.runtime.observe`
+   * preceding them. Therefore `client.runtime.started` itself is the
+   * discriminator: if we receive it for an adapterSessionId, the session is
+   * adapter-managed and any tracking stub is a racy artifact.
+   * @param payload - `client.runtime.started` payload
+   */
+  private handleRuntimeStarted;
+  /**
+   * Reconcile a hook-first tracking stub for a managed adapter session.
+   *
+   * Looks up a tracking stub by `(source, adapterSessionId)` and deletes it
+   * when it carries no imported messages (pure race artifact). Stubs with
+   * content are preserved (native takeover of an externally observed session).
+   * When message storage is unavailable (unhandled lookup), the stub is
+   * preserved defensively to avoid data loss.
+   *
+   * Called from two sites to close the in-flight importUpsert window:
+   * - `handleRuntimeStarted`: runtime side adds to gate, then reconciles.
+   * - `handleSessionStarted`: hook side writes storage, then reconciles
+   *   (post-upsert double-check when the gate was populated concurrently).
+   * @param clientId - Client identity for importer resolution
+   * @param adapterSessionId - External adapter session ID to reconcile
+   */
+  private reconcileTrackingStub;
+  /**
+   * Resolve the log-import importer responsible for a client's sessions.
+   *
+   * Bridges the correlation gap between hook identity and import identity:
+   * hooks report the client id (e.g. `'claude-code'`) while the import path
+   * keys sessions on the importer's adapter name. Registrations advertise
+   * their `clientId` via `log-import.listImporters`.
+   *
+   * Graceful absence: `null` means framework-only mode (no log-import
+   * service, or no importer registered for this client) — callers skip
+   * silently. At most one debug log is emitted per unresolved client id.
+   * @param clientId - Stable client id from the observed event payload
+   * @returns Importer adapter name, or `null` when no importer is registered
+   */
+  private resolveImporter;
+  /**
+   * Debug-log an unresolved client id at most once.
+   * @param clientId - Client id that could not be resolved to an importer
+   * @param reason - Why resolution failed
+   */
+  private debugUnresolved;
+  /**
+   * Register an observed session through the unified registration seam.
+   *
+   * Skipped for managed sessions and when no importer is resolvable — a
+   * session that can never receive imported content must not create a
+   * dangling stub. The registration `source` is the importer's adapter name,
+   * NOT the raw client id: the `(source, adapterSessionId)` upsert key must
+   * match what the import path writes, otherwise hook-first registration
+   * would fork the session identity and every import would create a
+   * duplicate session.
+   * @param payload - `client.session.started` payload
+   */
+  private handleSessionStarted;
+  /**
+   * Trigger a targeted transcript import for a completed observed turn.
+   *
+   * Preferred trigger: `log-import.importFile` with the transcript path from
+   * the hook payload (no prior discovery stub required). Fallback when the
+   * payload carries no path: `log-import.importSession`, which requires an
+   * existing discovery stub and throws otherwise — tolerated and
+   * debug-logged, because the polling watcher ingests the turn on its next
+   * pass either way. If hook payloads prove to lack the transcript path at
+   * fire time in practice, resolving the path from the statusline cache is
+   * the candidate follow-up seam.
+   * @param payload - `client.session.turn.completed` payload
+   */
+  private handleTurnCompleted;
+  /**
+   * Evaluate registered policy providers for an observed session.
+   *
+   * No provider means the current default: content tracking. When multiple
+   * providers are present, `discovered` wins so independent policy modules can
+   * only restrict content import, not override each other's deny decisions.
+   * @param input - Observed session identity and importer context
+   * @returns Import status for the registration
+   */
+  private decideImportStatus;
+  /**
+   * Determine whether a completed observed turn may trigger content import.
+   * @param input - Observed turn identity and importer context
+   * @returns True when content import should run
+   */
+  private shouldImportObservedContent;
+}
 //#endregion
 //#region services/core/src/session/observed-session-ingestion-policy.d.ts
 /** Capability id used for observed-session ingestion policy providers. */
@@ -4556,7 +4803,7 @@ declare const messages: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<{
       tableName: "messages";
       dataType: "string";
       columnType: "SQLiteText";
-      data: "text" | "voice" | "compact";
+      data: "text" | "compact" | "voice";
       driverParam: string;
       notNull: false;
       hasDefault: false;
@@ -5283,4 +5530,78 @@ declare function buildSessionContext(bus: IMakaioBus, options: BuildContextOptio
  */
 declare function getFullConversation(bus: IMakaioBus, sessionId: string): Promise<ContextAssemblyResult>;
 //#endregion
-export { emitSessionTurnStarted as $, resolveAdapterId as $t, registerMemoryTurnStorage as A, FallbackRuntimeOptions as At, ObservedSessionIngestionPolicyInput as B, registerResumeHandler as Bt, messages as C, registerMemorySessionStorage as Ct, SelectTurn as D, createSessionExtensionContext as Dt, InsertTurn as E, SessionExtensionContextImpl as Et, importCursorsDual as F, registerListActionsHandler as Ft, IngestCompletedTurnParams as G, buildTurnInitiator as Gt, unregisterObservedSessionIngestionPolicyProvider as H, AgentContextState as Ht, IObservedSessionIngestionPolicyProvider as I, registerBuiltInActions as It, ingestCompletedTurn as J, ensureAgentCwd as Jt, IngestCompletedTurnResult as K, RecoveryConfig as Kt, OBSERVED_SESSION_INGESTION_POLICY_CAPABILITY_ID as L, resetBuiltInActionsRegistration as Lt, EmbeddingIndexManager as M, CONNECTOR_SWAP_DEFAULT_PIPELINE as Mt, registerDrizzleImportCursorStorage as N, normalizeSelectionString as Nt, turns as O, SessionBridge as Ot, importCursors as P, resolveAdapterNameById as Pt, appendSessionLifecycleEvent as Q, buildRecoveryContext as Qt, ObservedSessionIngestionPolicyDecision as R, actionRegistry as Rt, SelectMessage as S, registerDrizzleSessionStorage as St, registerDrizzleMessageStorage as T, AgentStorageSubjects as Tt, LogImportTriggerSubjects as U, ContextWindowTrackerConfig as Ut, registerObservedSessionIngestionPolicyProvider as V, ContextWindowTracker as Vt, isPolicyDiscoveredObservedSession as W, SessionContextWindowState as Wt, SessionLifecycleEventArgs as X, recoverAgent as Xt, EventTransform as Y, ensureAgentModel as Yt, SessionTurnStartedPayload as Z, verifyAndRecoverAgents as Zt, messageRoutingDual as _, mapRowToSession as _t, kindToBranchKind as a, extractTextContent as an, sessionEvents as at, MessageRoutingSubjects as b, registerDrizzleAgentStorage as bt, registerSpawningToolCallResolver as c, AdapterRegistry as cn, SessionPreviewMaps as ct, MakaioSession as d, registerCoreSessionServiceHandlers as dn, mapToSession as dt, resolveExecutionTarget as en, registerSessionLifecycleEventWriters as et, MakaioSessionConfig as f, MakaioSessionService as fn, SearchFilters as ft, messageRouting as g, fetchPreviewBySession as gt, SelectMessageRouting as h, fetchMessageCountsBySession as ht, ContextAssemblyResult as i, resolveTargetAgents as in, SelectSessionEvent as it, registerDrizzleTurnStorage as j, pickFallbackRuntimeOptions as jt, turnsDual as k, assembleForkContext as kt, registerCompressLineageResolver as l, ISessionOrchestrator as ln, fetchSessionPreviewMaps as lt, InsertMessageRouting as m, fetchAgentsBySession as mt, buildSessionContext as n, findTurnByAgent as nn, registerMemorySessionEventStorage as nt, toSessionLineage as o, normalizeToBlocks as on, sessionEventsDual as ot, StartTurnOptions as p, SearchSessionRow as pt, IngestTurnMessage as q, buildRecoveryContextWithPipeline as qt, BuildContextOptions as r, getOrCreateSession as rn, InsertSessionEvent as rt, registerSessionDiscoveredHandler as s, TurnContextEnricher as sn, getSessionAncestorChain as st, getFullConversation as t, resolveModelCapabilities as tn, registerDrizzleSessionEventStorage as tt, registerParentResolver as u, SessionOrchestrator as un, mapAgentsBySession as ut, registerDrizzleMessageRoutingStorage as v, parseForkTransforms as vt, registerMemoryMessageStorage as w, AgentStorageNamespace as wt, InsertMessage as x, registerMemoryAgentStorage as xt, MessageRoutingNamespace as y, registerFtsSearchHandler as yt, ObservedSessionIngestionPolicyImportStatus as z, registerGetStatusCountsHandler as zt };
+//#region services/core/src/session/native-locality.d.ts
+/**
+ * Describes whether the session resume/fork intent is a native continuation
+ * or a new fork branching from an existing session.
+ */
+type NativeLocalityIntent = 'resume' | 'fork';
+/**
+ * All inputs required for the native locality evaluator.
+ */
+interface NativeLocalityInput {
+  /** Whether this is a resume or fork operation. */
+  readonly intent: NativeLocalityIntent;
+  /** The session being resumed or forked. */
+  readonly session: IMakaioSession;
+  /**
+   * The stable machine identity of the current host process.
+   * Undefined when the framework host has not yet resolved machine identity.
+   */
+  readonly localMachineId: string | undefined;
+  /**
+   * Whether the adapter for this session declares native resume/fork capability.
+   * Adapters that cannot natively replay/branch must always inject history.
+   */
+  readonly adapterSupportsNative: boolean;
+  /**
+   * Stable adapter type name of the target adapter (e.g. 'claude-code', 'codex-mcp').
+   *
+   * Compared against `session.adapterName` to prevent cross-adapter resume/fork:
+   * sending a Claude provider session ID to a Codex adapter (or vice versa) would
+   * corrupt the provider conversation. When the session has no stored adapterName
+   * (legacy records, sessions created before adapter identity tracking), the check
+   * is skipped — the downstream adapter will reject an incompatible session ID.
+   */
+  readonly targetAdapterName: string;
+  /**
+   * Working directory of the current adapter instance.
+   * Only relevant when `targetCwd` is also supplied.
+   */
+  readonly currentCwd?: string;
+  /**
+   * Requested working directory for the resumed or forked session.
+   * When it differs from `currentCwd`, native operation cannot reuse the
+   * existing connector.
+   */
+  readonly targetCwd?: string;
+  /**
+   * Turn-scoped context signals produced by the session orchestrator.
+   * Used to detect compression, connector swaps, and pending transforms.
+   */
+  readonly sessionContext?: SessionContext;
+  /**
+   * Whether the underlying adapter supports forking at a mid-history message.
+   * Required when `session.forkPointMessageId` is set and `intent === 'fork'`.
+   */
+  readonly midHistoryForkSupported?: boolean;
+}
+/**
+ * Evaluates whether a session can use native resume or fork, or must fall back
+ * to history injection.
+ *
+ * Checks are ordered from cheapest/most common disqualifier to most specific so
+ * that callers pay no cost for conditions that are almost never hit:
+ *
+ * 1. Adapter capability declaration
+ * 2. Provider-native session ID presence
+ * 3. Machine identity availability and ownership
+ * 4. Structural constraints (imports + orchestration, compression, transforms,
+ *    connector swap, CWD mismatch)
+ * 5. Mid-history fork support
+ * @param input - All signals needed to determine locality
+ * @returns A {@link NativeLocalityVerdict} describing the outcome
+ */
+declare function evaluateNativeLocality(input: NativeLocalityInput): NativeLocalityVerdict;
+//#endregion
+export { ingestCompletedTurn as $, ensureAgentCwd as $t, SelectTurn as A, AgentStorageSubjects as At, OBSERVED_SESSION_INGESTION_POLICY_CAPABILITY_ID as B, registerListActionsHandler as Bt, MessageRoutingSubjects as C, parseForkTransforms as Ct, registerMemoryMessageStorage as D, registerDrizzleSessionStorage as Dt, messages as E, registerMemoryAgentStorage as Et, EmbeddingIndexManager as F, FallbackRuntimeOptions as Ft, unregisterObservedSessionIngestionPolicyProvider as G, registerResumeHandler as Gt, ObservedSessionIngestionPolicyImportStatus as H, resetBuiltInActionsRegistration as Ht, registerDrizzleImportCursorStorage as I, pickFallbackRuntimeOptions as It, isPolicyDiscoveredObservedSession as J, ContextWindowTrackerConfig as Jt, LogImportTriggerSubjects as K, ContextWindowTracker as Kt, importCursors as L, CONNECTOR_SWAP_DEFAULT_PIPELINE as Lt, turnsDual as M, createSessionExtensionContext as Mt, registerMemoryTurnStorage as N, SessionBridge as Nt, registerDrizzleMessageStorage as O, registerMemorySessionStorage as Ot, registerDrizzleTurnStorage as P, assembleForkContext as Pt, IngestTurnMessage as Q, buildRecoveryContextWithPipeline as Qt, importCursorsDual as R, normalizeSelectionString as Rt, MessageRoutingNamespace as S, mapRowToSession as St, SelectMessage as T, registerDrizzleAgentStorage as Tt, ObservedSessionIngestionPolicyInput as U, actionRegistry as Ut, ObservedSessionIngestionPolicyDecision as V, registerBuiltInActions as Vt, registerObservedSessionIngestionPolicyProvider as W, registerGetStatusCountsHandler as Wt, IngestCompletedTurnParams as X, buildTurnInitiator as Xt, isTrackingStub as Y, SessionContextWindowState as Yt, IngestCompletedTurnResult as Z, RecoveryConfig as Zt, InsertMessageRouting as _, MakaioSessionService as _n, SearchFilters as _t, buildSessionContext as a, resolveExecutionTarget as an, registerSessionLifecycleEventWriters as at, messageRoutingDual as b, fetchMessageCountsBySession as bt, kindToBranchKind as c, getOrCreateSession as cn, InsertSessionEvent as ct, registerSpawningToolCallResolver as d, normalizeToBlocks as dn, sessionEventsDual as dt, ensureAgentModel as en, EventTransform as et, registerCompressLineageResolver as f, TurnContextEnricher as fn, getSessionAncestorChain as ft, StartTurnOptions as g, registerCoreSessionServiceHandlers as gn, mapToSession as gt, MakaioSessionConfig as h, SessionOrchestrator as hn, mapAgentsBySession as ht, getFullConversation as i, resolveAdapterId as in, emitSessionTurnStarted as it, turns as j, SessionExtensionContextImpl as jt, InsertTurn as k, AgentStorageNamespace as kt, toSessionLineage as l, resolveTargetAgents as ln, SelectSessionEvent as lt, MakaioSession as m, ISessionOrchestrator as mn, fetchSessionPreviewMaps as mt, NativeLocalityIntent as n, verifyAndRecoverAgents as nn, SessionTurnStartedPayload as nt, BuildContextOptions as o, resolveModelCapabilities as on, registerDrizzleSessionEventStorage as ot, registerParentResolver as p, AdapterRegistry as pn, SessionPreviewMaps as pt, ObservedSessionIngestionService as q, AgentContextState as qt, evaluateNativeLocality as r, buildRecoveryContext as rn, appendSessionLifecycleEvent as rt, ContextAssemblyResult as s, findTurnByAgent as sn, registerMemorySessionEventStorage as st, NativeLocalityInput as t, recoverAgent as tn, SessionLifecycleEventArgs as tt, registerSessionDiscoveredHandler as u, extractTextContent as un, sessionEvents as ut, SelectMessageRouting as v, SearchSessionRow as vt, InsertMessage as w, registerFtsSearchHandler as wt, registerDrizzleMessageRoutingStorage as x, fetchPreviewBySession as xt, messageRouting as y, fetchAgentsBySession as yt, IObservedSessionIngestionPolicyProvider as z, resolveAdapterNameById as zt };

package/dist/{index-DEzdNQum.d.mts → index-Di84JjS0.d.mts}

@@ -9,9 +9,9 @@ import { z } from "zod";
  * - `visible` — Model is usable and shown in the AgentPicker UI.
  */
 declare const ModelVisibilitySchema: z.ZodEnum<{
-  disabled: "disabled";
-  enabled: "enabled";
   visible: "visible";
+  enabled: "enabled";
+  disabled: "disabled";
 }>;
 type ModelVisibility = z.infer<typeof ModelVisibilitySchema>;
 /**