@makaio/framework 1.0.0-dev-1781022866275 → 1.0.0-dev-1781023871421

package/dist/index-DBw-89vC2.d.mts

@@ -0,0 +1,3640 @@
+import { r as ExecutionTarget } from "./schemas-C46QfKzv.mjs";
+import { d as Turn$1 } from "./index-DGBu6bHi2.mjs";
+import { a as PipelineStep, o as SessionEditorAction, t as ActionCategory } from "./types-C2Ob9zz_.mjs";
+import { a as agents, o as sessions } from "./schema-M5YTvSAG.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 { AIReasoningLevel, AdapterRuntimeOptions, BranchKind, ContextWindowState, ExtensionContext, ForkOptions, ForkTransforms, IMakaioSession, MakaioSessionAgent, MakaioSessionEvent, Message, MessageBlock, MessageInput, ReasoningLevelMap, SessionContext, SessionExtensionContext, SessionLineage, SessionLineageKind, SessionMessage, SessionMessageBlock, TurnInitiator } from "@makaio/framework/contracts";
+import { BaseService } from "@makaio/framework/service-base";
+import * as _$drizzle_orm_sqlite_core0 from "drizzle-orm/sqlite-core";
+import * as _$_makaio_storage_core0 from "@makaio/framework/storage";
+import { MakaioDatabase } from "@makaio/framework/storage/drizzle";
+
+//#region services/core/src/session/session-service.d.ts
+/**
+ * Framework-core session service for managing makaio sessions.
+ *
+ * Registers the minimal, load-bearing session handlers that the framework SDK
+ * requires: `session.create`, `session.get`, `session.list`, `session.close`,
+ * `session.agent.added`, and `session.agent.removed`.
+ *
+ * Host-specific handlers (search, update, resume, archive, purge, analytics,
+ * context window, branching) are registered by the host session service which
+ * depends on this service.
+ *
+ * Storage is fully decoupled via bus — this service calls
+ * `SessionStorageSubjects.*` subjects. Register appropriate storage handlers
+ * (memory or drizzle) before creating this service.
+ *
+ * `SessionLogger` is intentionally NOT a dependency here: it persists session
+ * lifecycle events consumed only by recovery context assembly, fork, merge,
+ * compress, and purge — all host features. Host services declare
+ * `SessionLogger` in their own dependency chain.
+ * @example
+ * ```typescript
+ * import { MakaioBus } from '@makaio/framework/bus';
+ * import {
+ *   MakaioSessionService,
+ *   registerMemorySessionStorage,
+ * } from '@makaio/framework/services/session';
+ *
+ * // Register storage handlers first
+ * registerMemorySessionStorage(MakaioBus);
+ *
+ * // Create and initialise the service
+ * const sessionService = new MakaioSessionService(MakaioBus);
+ * await sessionService.init();
+ *
+ * // Now clients can interact via bus
+ * const { sessionId } = await MakaioBus.request(SessionSubjects.create, {});
+ * const { session } = await MakaioBus.request(SessionSubjects.get, { sessionId });
+ *
+ * // Cleanup when done
+ * sessionService.destroy();
+ * ```
+ */
+declare class MakaioSessionService extends BaseService {
+  /**
+   * Creates a new MakaioSessionService instance.
+   * @param bus - The event bus for inter-service communication
+   */
+  constructor(bus?: IMakaioBus);
+  /**
+   * Initialize the service.
+   *
+   * Registers the six framework-core session bus handlers, then performs
+   * startup reconciliation to close any turns that were left `active` by a
+   * prior process crash. Each orphaned turn is closed with status `'error'`
+   * and a `'process-restart'` error message, and a `turn.completed` event is
+   * emitted so the UI can update accordingly.
+   *
+   * The reconciliation uses `requestOptional` so it is silently skipped when
+   * no `storage:turn.listActive` handler is registered (e.g., in unit tests
+   * that do not register turn storage).
+   */
+  protected onInit(): Promise<void>;
+  /**
+   * Close any turns left `active` from a prior process crash.
+   *
+   * Queries all active turns via `storage:turn.listActive`. For each orphaned
+   * turn, attempts to atomically mark it as `error` only if it is still `active`,
+   * then emits `session.turn.completed` only when that transition succeeds.
+   * This prevents clobbering turns completed concurrently by other components.
+   *
+   * Uses `requestOptional` so that environments without a turn storage handler
+   * (e.g., isolated unit tests) are unaffected.
+   */
+  private reconcileOrphanedTurns;
+}
+//#endregion
+//#region services/core/src/session/session-service-handlers-core.d.ts
+/**
+ * Dependencies required to register the framework-core session service handlers.
+ *
+ * Intentionally minimal — no `contextTracker` or host-layer concerns.
+ * Host-specific handlers (search, resume, context window, etc.) are registered
+ * separately via the host session service.
+ */
+interface CoreSessionServiceHandlerDeps {
+  /** The event bus used for handler registration and storage dispatch. */
+  bus: IMakaioBus;
+}
+/**
+ * Registers the framework-core session service handlers:
+ * `session.create`, `session.get`, `session.list`, `session.close`,
+ * `session.update`, `session.archive`, `session.purge`,
+ * `session.agent.added`, and `session.agent.removed`.
+ *
+ * These handlers cover the minimal, load-bearing session contract for the
+ * framework SDK. Host-specific handlers (search, resume, analytics, context
+ * window) are registered by the host session service at a higher priority.
+ *
+ * Persistence degrades gracefully when no storage handlers are registered:
+ * `session.get` / `session.list` / `session.close` all delegate to
+ * `SessionStorageSubjects.*` which may be unhandled in ephemeral mode.
+ * @param deps - Bus dependency
+ * @returns Array of cleanup callbacks, one per registered handler
+ */
+declare function registerCoreSessionServiceHandlers(deps: CoreSessionServiceHandlerDeps): Array<() => void>;
+//#endregion
+//#region services/core/src/session/session-orchestrator.d.ts
+/**
+ * Minimum public contract for a session orchestrator service.
+ *
+ * Both the framework orchestrator and host-provided orchestrators can satisfy
+ * this interface. The service token is keyed on this
+ * interface so the conditional injection pattern (same service name, different
+ * implementation per runtime) compiles without structural conflicts.
+ */
+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.sendMessage` handler only:
+ * 1. Get or create session (via `getOrCreateSession`)
+ * 2. Start agent if session has no agents — resolves the canonical
+ *    `adapterName` from direct selections, uses `adapterId` directly when
+ *    provided, otherwise resolves it via `AdapterRegistry`, then calls bare
+ *    `AdapterSubjects.startAgent`
+ * 3. Resolve target agents (via `resolveTargetAgents`)
+ * 4. Verify agent liveness and build recovery context for dead agents
+ *    (requestOptional `AdapterSubjects.getAgent` + `buildRecoveryContext`)
+ * 5. Get or create turn (via `SessionTurnManager`)
+ * 6. Generate message ID and store user message + routing records
+ *    (requestOptional, 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`
+ *
+ * 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!' },
+ * );
+ * ```
+ */
+declare class SessionOrchestrator implements ISessionOrchestrator {
+  private readonly bus;
+  private readonly turnManager;
+  private readonly adapterRegistry;
+  /** 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)
+   */
+  constructor(bus: IMakaioBus | undefined, _machineId: string);
+  /**
+   * Register the `session.sendMessage` RPC handler.
+   *
+   * Core flow:
+   * 1. Get or create session
+   * 2. Start agent if session has no agents (canonicalize direct selections,
+   *    resolve adapterId, bare startAgent)
+   * 3. Resolve target agents
+   * 4. Verify agent liveness and build recovery context for dead agents
+   * 5. Get or create turn (via SessionTurnManager)
+   * 6. Generate message ID and store user message + 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
+   */
+  private registerSendMessageHandler;
+  /**
+   * Complete a turn by delegating to `SessionTurnManager`.
+   *
+   * Called by `routeToAgentsCore` error handling and by the turn manager's
+   * own `agent.complete` listener (registered via `registerCompletionHandlers`).
+   * @param turn - The turn to complete
+   * @param result - Turn result (success status and error messages)
+   */
+  private completeTurn;
+  /**
+   * Stop the orchestrator and clean up all subscriptions and composition utilities.
+   */
+  destroy(): void;
+  /**
+   * Resolve the adapter name for a direct adapter selection.
+   *
+   * Adapter startup and persisted identity require a stable adapter name.
+   * When the caller provides `adapterId`, the framework validates any explicit
+   * name against the adapter-subsystem reverse lookup and otherwise backfills the
+   * canonical adapter name from that subsystem-owned mapping.
+   * @param selection - Direct adapter selection
+   * @param sessionId - Session ID used in error messages
+   * @returns Resolved adapter name
+   */
+  private resolveAdapterName;
+  /**
+   * Resolve the public agent selection into the direct adapter shape required
+   * by the framework orchestrator's startup path.
+   * @param selection - Public session agent selection from the request.
+   * @param sessionId - Session ID used for context and diagnostics.
+   * @param message - User message used as canonical-model prompt context.
+   * @param sessionContext - Optional session context passed through the request.
+   * @returns Direct adapter selection for `adapter.startAgent`.
+   */
+  private resolveInitialAdapterSelection;
+  /**
+   * Resolve a framework-owned canonical-model selection to a direct adapter selection.
+   * @param selection - Canonical model selection from the session request.
+   * @param sessionId - Session ID used for context and diagnostics.
+   * @param message - User message used as canonical-model prompt context.
+   * @param sessionContext - Optional session context passed through the request.
+   * @returns Direct adapter selection with resolved adapter, provider config, and model.
+   */
+  private resolveCanonicalModelSelection;
+}
+//#endregion
+//#region services/core/src/session/adapter-registry.d.ts
+/**
+ * Resolves adapterName → adapterId mappings for the framework session
+ * orchestrator.
+ *
+ * The runtime `resolveId` request is the authoritative seam. The
+ * `adapter.initialized` listener maintains a local cache for observers and for
+ * tests that intentionally exercise the event path.
+ *
+ * Lifecycle: construct to start listening, call `destroy()` when done.
+ */
+declare class AdapterRegistry {
+  private readonly bus;
+  private readonly registry;
+  private cleanup?;
+  /**
+   * Create an AdapterRegistry and start listening for adapter.initialized events.
+   *
+   * If the same `adapterName` is seen in a subsequent `adapter.initialized` event,
+   * the new `adapterId` silently overwrites the previous mapping. This is intentional:
+   * adapters that restart emit a fresh initialized event and the registry should
+   * reflect the latest instance.
+   * @param bus - The event bus to listen on
+   */
+  constructor(bus: IMakaioBus);
+  /**
+   * Resolve an adapterId from the event cache.
+   * @param adapterName - Adapter type name (e.g., `'openai-node'`, `'claude-agent-sdk'`)
+   * @returns The cached adapterId registered for this adapterName.
+   * @throws Error when no adapter with this name is present in the event cache
+   */
+  resolve(adapterName: string): string;
+  /**
+   * Resolve an adapterId from an adapterName through the runtime identity
+   * resolver.
+   *
+   * The `adapter.initialized` listener is a non-authoritative cache only. It
+   * keeps legacy event-driven tests and observers useful, but session routing
+   * must prefer the replayable request seam so a session created after adapter
+   * initialization does not miss a one-time event.
+   * @param adapterName - Adapter type name (e.g., `'openai-node'`)
+   * @returns Adapter runtime identifier for bus routing.
+   */
+  resolveAvailable(adapterName: string): Promise<string>;
+  /** Stop listening to `adapter.initialized` events and clear the registry. */
+  destroy(): void;
+}
+//#endregion
+//#region services/core/src/session/turn-context-enricher.d.ts
+/**
+ * Enriches messageHistory with turn-so-far messages for immediate delivery.
+ *
+ * Uses MessageStorageSubjects to load messages already persisted in the current turn.
+ * For immediate messages within an active turn, this provides context from:
+ * - The initiating user message
+ * - Any assistant responses from agents that have already completed
+ */
+declare class TurnContextEnricher {
+  private readonly bus;
+  constructor(bus: IMakaioBus);
+  /**
+   * Load turn-so-far messages and convert to Message[].
+   * @param turnId - Turn ID to load context for
+   * @returns Messages representing turn-so-far context
+   */
+  getTurnSoFarContext(turnId: string): Promise<Message[]>;
+  /**
+   * Enrich messageHistory for immediate delivery mode.
+   * @param originalHistory - Curated history from sessionContext
+   * @param turnId - Turn ID for current turn
+   * @param deliveryMode - Message delivery mode
+   * @returns Enriched messageHistory (original + turn-so-far for immediate)
+   */
+  enrichForDeliveryMode(originalHistory: Message[] | undefined, turnId: string, deliveryMode: 'enqueue' | 'immediate' | 'replace' | undefined): Promise<Message[] | undefined>;
+  /**
+   * Convert SessionMessage[] to shared Message[] format.
+   *
+   * Since SessionMessageBlock and MessageBlock are unified, blocks pass through directly.
+   * @param sessionMessages - Messages from storage
+   * @returns Array of Message objects
+   */
+  private convertSessionMessagesToMessages;
+}
+//#endregion
+//#region services/core/src/session/utils/message-utils.d.ts
+/**
+ * Extract plain text content from a MessageInput for FTS indexing.
+ * @param message - The message input (string or structured)
+ * @returns Plain text content
+ */
+declare function extractTextContent(message: MessageInput): string;
+/**
+ * Normalize MessageInput to SessionMessageBlock[] for storage.
+ * Preserves structured blocks instead of flattening to a single text block.
+ * @param message - The message input (string or structured)
+ * @returns Array of SessionMessageBlock for storage
+ */
+declare function normalizeToBlocks(message: MessageInput): SessionMessageBlock[];
+//#endregion
+//#region services/core/src/session/utils/session-utils.d.ts
+/**
+ * Get existing session or create a new one.
+ * @param bus - Makaio bus instance
+ * @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
+ * @returns Session ID and session object
+ */
+declare function getOrCreateSession(bus: IMakaioBus, providedSessionId: string, _sessionContext?: SessionContext, originWindowId?: string): Promise<{
+  sessionId: string;
+  session: IMakaioSession;
+}>;
+/**
+ * Resolve which agents to target based on the request.
+ * @param session - The session containing agents
+ * @param targetSpec - Target: undefined (lead agent), 'all', or specific agent IDs
+ * @returns Resolved target agents
+ */
+declare function resolveTargetAgents(session: IMakaioSession, targetSpec: string[] | 'all' | undefined): MakaioSessionAgent[];
+/**
+ * Find which turn an agent belongs to.
+ * @param activeTurns - Active turns map
+ * @param agentId - The agent ID to look up
+ * @returns The turn containing this agent, or undefined
+ */
+declare function findTurnByAgent(activeTurns: Map<string, Turn$1>, agentId: string): Turn$1 | undefined;
+//#endregion
+//#region services/core/src/session/utils/resolution.d.ts
+/**
+ * Resolve adapterName → adapterId for bus routing.
+ * Queries the adapters table for a local enabled instance.
+ * @param bus - Bus instance
+ * @param adapterName - Adapter type name
+ * @param machineId - Optional machine ID for deterministic local resolution
+ * @returns Canonical adapter ID for bus routing
+ * @throws if no enabled instance found for this adapterName
+ */
+declare function resolveAdapterId(bus: IMakaioBus, adapterName: string, machineId?: string): Promise<string>;
+/**
+ * Resolve supported reasoning levels for a model from provider definitions.
+ *
+ * Looks up the provider config by ID, finds the provider definition it belongs to,
+ * then finds the model's `supportedReasoningLevels` in the provider's `availableModels`
+ * catalog.
+ * @param bus - Bus instance for RPC calls
+ * @param providerConfigId - Canonical provider config ID (ProviderConfigRecord.id)
+ * @param model - Model identifier to look up in the provider's catalog
+ * @returns Object with `supportedReasoningLevels` when found, or `undefined` when not resolvable
+ */
+declare function resolveModelCapabilities(bus: IMakaioBus, providerConfigId: string | undefined, model: string | undefined): Promise<{
+  supportedReasoningLevels?: ReasoningLevelMap;
+} | undefined>;
+/**
+ * Resolves the effective execution target for a session.
+ * Priority: explicit executionTargetId → system default (local).
+ * @param bus - Makaio bus instance
+ * @param params - Resolution parameters from session context
+ * @returns Resolved execution target
+ */
+declare function resolveExecutionTarget(bus: IMakaioBus, params: {
+  executionTargetId?: string;
+}): Promise<ExecutionTarget>;
+//#endregion
+//#region services/core/src/session/utils/recovery-context.d.ts
+/**
+ * Build sessionContext with messageHistory for a recovered agent.
+ * Uses getFullConversation() to assemble history from stored messages.
+ *
+ * This function is framework-safe: it has no host-layer dependencies
+ * (no PersonaSubjects, ProfileSubjects, VirtualModelSubjects, etc.).
+ * @param bus - Bus instance
+ * @param session - Session to build context for
+ * @returns SessionContext with messageHistory and isFirstTurn signal
+ */
+declare function buildRecoveryContext(bus: IMakaioBus, session: IMakaioSession): Promise<SessionContext>;
+//#endregion
+//#region services/core/src/session/utils/agent-recovery.d.ts
+/**
+ * Configuration for recovering dead agents during liveness verification.
+ */
+interface RecoveryConfig {
+  /** Working directory for agent execution */
+  cwd?: string;
+  /** Model identifier (e.g., 'claude-sonnet-4-20250514', 'gpt-4o') */
+  model?: string;
+}
+/**
+ * Ensure agent cwd matches desired cwd, swapping connector if needed.
+ * Must be called while agent is idle (before message routing).
+ * @param bus - Bus instance
+ * @param agent - Agent to validate/swap
+ * @param desiredCwd - Target working directory
+ * @param options - Optional request flags (e.g., skip interactive warnings)
+ * @returns Swap result with previous cwd when a swap occurred
+ */
+declare function ensureAgentCwd(bus: IMakaioBus, agent: MakaioSessionAgent, desiredCwd: string, options?: {
+  skipWarning?: boolean;
+}): Promise<{
+  swapped: false;
+} | {
+  swapped: true;
+  previousCwd: string;
+}>;
+/**
+ * Ensure an agent uses the desired model and/or reasoning effort, performing an
+ * in-place change or connector swap as needed.
+ *
+ * Mirrors the `ensureAgentCwd()` pattern. At least one of `desiredModel`,
+ * `options.reasoningEffort`, or `options.providerConfigId` must be defined for a
+ * change to occur.
+ * @param bus - The bus instance for RPC
+ * @param agent - The agent to change (mutated in-place on success)
+ * @param desiredModel - The model identifier to switch to, or undefined to keep current model
+ * @param options - Optional configuration: `providerConfigId` triggers a swap when it differs from the
+ *   current one; `reasoningEffort` is applied after the model change; `skipWarning` suppresses the
+ *   model-change confirmation dialog
+ * @returns Discriminated union: no change, or changed with swap info
+ */
+declare function ensureAgentModel(bus: IMakaioBus, agent: MakaioSessionAgent, desiredModel: string | undefined, options?: {
+  providerConfigId?: string;
+  reasoningEffort?: AIReasoningLevel;
+  skipWarning?: boolean;
+}): Promise<{
+  changed: false;
+} | {
+  changed: true;
+  swapped: boolean;
+}>;
+/**
+ * Verify liveness of agents and recover any that are dead.
+ * Queries each agent via getAgent; if unresponsive, triggers connector swap via recoverAgent.
+ * @param bus - Bus instance
+ * @param agents - Agents to verify
+ * @param recoveryConfig - Configuration for recovering dead agents
+ * @returns Verified/recovered agents and set of recovered agent IDs
+ */
+declare function verifyAndRecoverAgents(bus: IMakaioBus, agents: MakaioSessionAgent[], recoveryConfig: RecoveryConfig): Promise<{
+  verifiedAgents: MakaioSessionAgent[];
+  recoveredAgentIds: Set<string>;
+}>;
+/**
+ * Build recovery context and apply optional additional transforms.
+ * @param bus - Bus instance
+ * @param session - Session to build context for
+ * @param options - Optional transform pipeline to run before conversion
+ * @returns SessionContext with transformed messageHistory and fresh-mode signal
+ */
+declare function buildRecoveryContextWithPipeline(bus: IMakaioBus, session: IMakaioSession, options?: {
+  pipeline?: PipelineStep[];
+}): Promise<SessionContext>;
+/**
+ * Recover a dead agent by triggering connector swap via the adapter.
+ * The agent keeps its identity — no session mutation needed.
+ *
+ * Context delivery happens via the normal sendMessage path that follows
+ * recovery (same handler invocation). No staging needed.
+ * @param bus - Bus instance
+ * @param deadAgent - The dead agent to recover
+ * @param recoveryConfig - Configuration for the recovered connector
+ * @returns Same agent reference — identity preserved
+ */
+declare function recoverAgent(bus: IMakaioBus, deadAgent: MakaioSessionAgent, recoveryConfig: RecoveryConfig): Promise<MakaioSessionAgent>;
+//#endregion
+//#region services/core/src/session/utils/turn-initiator.d.ts
+/**
+ * Builds turn initiator metadata from `sendMessage` source fields.
+ *
+ * Returns `{ source: 'extension', sourceId: extensionId }` for extension-initiated turns,
+ * `{ source }` for other explicit sources, or `{ source: 'user' }` as the default.
+ * @param source - Optional turn origin discriminator
+ * @param extensionId - Required when `source === 'extension'`
+ * @returns Normalised turn initiator
+ * @throws Error when `source` is `'extension'` and `extensionId` is absent or blank
+ */
+declare function buildTurnInitiator(source: 'extension' | 'user' | 'system' | undefined, extensionId: string | undefined): TurnInitiator;
+//#endregion
+//#region services/core/src/session/context-window/types.d.ts
+/**
+ * Context window tracking types for per-session aggregation.
+ *
+ * The tracker monitors AgentSubjects.contextWindow.updated events
+ * and maintains per-session state using "worst agent" aggregation.
+ */
+/**
+ * Per-session context window state, aggregated across agents.
+ *
+ * Uses "worst agent" strategy: reports the state of whichever
+ * agent has the highest usage percentage.
+ */
+interface SessionContextWindowState {
+  /** Current token count (worst across agents) */
+  currentTokens: number;
+  /** Max tokens for the model with lowest headroom */
+  maxTokens: number;
+  /** Percentage used (0-100) */
+  percentage: number;
+  /** Warning level based on percentage */
+  level: 'ok' | 'warn' | 'critical';
+  /** Agent ID with the highest usage */
+  worstAgentId?: string;
+  /** Timestamp of last update */
+  lastUpdatedAt: number;
+}
+/**
+ * Per-agent context state (internal tracking).
+ *
+ * Stored by the tracker to enable per-session aggregation
+ * when multiple agents are attached to the same session.
+ */
+interface AgentContextState {
+  agentId: string;
+  sessionId: string;
+  currentTokens: number;
+  maxTokens: number;
+  percentage: number;
+  level: 'ok' | 'warn' | 'critical';
+  cachedTokens?: number;
+  updatedAt: number;
+}
+/**
+ * Tracker configuration options.
+ */
+interface ContextWindowTrackerConfig {
+  /** How long to keep stale agent entries (ms). Default: 1 hour */
+  staleThresholdMs?: number;
+}
+//#endregion
+//#region services/core/src/session/context-window/context-window-tracker.d.ts
+/**
+ * Tracks context window state per session, aggregating across agents.
+ *
+ * Subscribes to AgentSubjects.contextWindow.updated and maintains
+ * per-session state using "worst agent" aggregation strategy.
+ * @example
+ * ```typescript
+ * const tracker = new ContextWindowTracker(MakaioBus);
+ * tracker.start();
+ *
+ * // Later, query session state
+ * const state = tracker.getSessionState('session-123');
+ * if (state?.level === 'critical') {
+ *   // Suggest compression
+ * }
+ *
+ * // Cleanup on shutdown
+ * tracker.stop();
+ * ```
+ */
+declare class ContextWindowTracker {
+  private readonly bus;
+  private readonly agentStates;
+  private readonly sessionStates;
+  private unsubscribe?;
+  private readonly staleThresholdMs;
+  constructor(bus: IMakaioBus, config?: ContextWindowTrackerConfig);
+  /**
+   * Start tracking context window updates.
+   * Idempotent - calling multiple times is safe.
+   */
+  start(): void;
+  /**
+   * Stop tracking and clear all state.
+   */
+  stop(): void;
+  /**
+   * Get aggregated context state for a session.
+   *
+   * State persists until explicitly cleared via clearSession().
+   * Clear is called by MakaioSessionService on:
+   * - session.close (session closed)
+   * - session.compressed (context compression)
+   *
+   * Even if we haven't heard from agents recently, the context window
+   * is still full - the state remains valid.
+   * @param sessionId - The session to get state for
+   * @returns The aggregated context window state, or undefined if no data
+   */
+  getSessionState(sessionId: string): SessionContextWindowState | undefined;
+  /**
+   * Clear state for a specific session (e.g., on session close).
+   * Removes both the session state and all agent states for that session.
+   * @param sessionId - The session to clear
+   */
+  clearSession(sessionId: string): void;
+  /**
+   * Recompute session state from all agents in that session.
+   * Uses "worst agent" strategy - highest percentage wins.
+   *
+   * Stale agent entries are pruned for memory management, but session
+   * state is preserved - context window is still full even if agent
+   * hasn't reported recently.
+   * @param sessionId - The session to recompute
+   */
+  private recomputeSessionState;
+}
+//#endregion
+//#region services/core/src/session/handlers/lifecycle-handlers.d.ts
+/**
+ * Dependencies for session lifecycle handlers.
+ */
+interface SessionLifecycleDeps {
+  bus: IMakaioBus;
+  contextTracker: ContextWindowTracker;
+}
+/**
+ * Register handler for session.getStatusCounts.
+ * @param deps - Handler dependencies
+ * @returns Cleanup function
+ */
+declare function registerGetStatusCountsHandler(deps: SessionLifecycleDeps): () => void;
+/**
+ * Register handler for session.resume.
+ * @param deps - Handler dependencies
+ * @returns Cleanup function
+ */
+declare function registerResumeHandler(deps: SessionLifecycleDeps): () => void;
+//#endregion
+//#region services/core/src/session/session-editor/action-registry.d.ts
+/**
+ * Registry for pipeline actions.
+ * Actions are registered at startup and looked up during pipeline execution.
+ */
+declare class ActionRegistry {
+  private actions;
+  /**
+   * Register a pipeline action.
+   * @param action - Action definition
+   */
+  register(action: SessionEditorAction): void;
+  /**
+   * Get an action by ID.
+   * @param id - Action identifier
+   * @returns Action or undefined if not found
+   */
+  get(id: string): SessionEditorAction | undefined;
+  /**
+   * Get all registered actions.
+   * @returns Array of all actions
+   */
+  getAll(): SessionEditorAction[];
+  /**
+   * Get actions by category.
+   * @param category - Category to filter by
+   * @returns Actions in that category
+   */
+  getByCategory(category: ActionCategory): SessionEditorAction[];
+  /**
+   * Clear all registered actions.
+   * @internal For testing only - clears state between tests.
+   */
+  reset(): void;
+}
+/** Global action registry instance */
+declare const actionRegistry: ActionRegistry;
+//#endregion
+//#region services/core/src/session/session-editor/actions/index.d.ts
+/**
+ * Register all built-in actions.
+ * Call this at service startup. Safe to call multiple times.
+ *
+ * Base actions (no bus required) are registered once on first call.
+ * Bus-dependent actions (e.g. llm-extract) are registered on the first
+ * call that supplies a `bus` instance, independently of whether base
+ * registration has already occurred.
+ * @param bus - Optional bus instance. When provided, bus-dependent actions
+ *   (e.g. llm-extract) are also registered. Existing callers that pass no
+ *   args continue to work without change.
+ */
+declare function registerBuiltInActions(bus?: IMakaioBus): void;
+/**
+ * Reset registration state.
+ * @internal For testing only.
+ */
+declare function resetBuiltInActionsRegistration(): void;
+//#endregion
+//#region services/core/src/session/session-editor/handlers.d.ts
+/**
+ * Register handler for session-editor.listActions.
+ *
+ * Maps all registered actions to UI-safe summaries by stripping the execute
+ * method and keeping only id, label, description, and category.
+ * @param bus - Bus instance to register on
+ * @returns Cleanup function to unsubscribe the handler
+ */
+declare function registerListActionsHandler(bus: IMakaioBus): () => void;
+//#endregion
+//#region services/core/src/session/selection-utils.d.ts
+/**
+ * Normalize a selection string field by trimming whitespace and coercing
+ * blank strings to `undefined`.
+ *
+ * Used wherever adapter/agent selection strings are read from wire payloads to
+ * ensure callers cannot accidentally pass whitespace-only values as meaningful
+ * adapter names or IDs.
+ * @param value - Candidate string value from a selection payload field
+ * @returns Trimmed non-empty string, or `undefined` when the input is absent
+ * or contains only whitespace
+ */
+declare function normalizeSelectionString(value: string | undefined): string | undefined;
+/**
+ * Resolve the canonical `adapterName` for a given deterministic `adapterId`,
+ * rejecting when the caller-supplied name does not match the subsystem lookup.
+ *
+ * The adapter runtime owns reverse lookup for deterministic IDs, including
+ * remote-machine IDs that still identify a known adapter type.
+ * @param bus - Bus instance used to query the adapter runtime reverse lookup
+ * @param adapterId - Adapter instance identifier to look up
+ * @param explicitAdapterName - Caller-supplied name to validate against storage;
+ * `undefined` skips the mismatch check
+ * @param errorPrefix - Prefix prepended to thrown error messages (include trailing space)
+ * @returns Canonical adapter name resolved by the adapter runtime
+ */
+declare function resolveAdapterNameById(bus: IMakaioBus, adapterId: string, explicitAdapterName: string | undefined, errorPrefix: string): Promise<string>;
+//#endregion
+//#region services/core/src/session/constants.d.ts
+/** Default transform pipeline for connector-swap history injection. */
+declare const CONNECTOR_SWAP_DEFAULT_PIPELINE: PipelineStep[];
+//#endregion
+//#region services/core/src/session/fallback-runtime-options.d.ts
+/**
+ * Runtime options preserved across a VirtualModel fallback hop.
+ *
+ * These fields are extracted from the original `agent.attach` or `adapter.startAgent`
+ * payload and re-applied to the fallback attach so the replacement agent
+ * inherits the same execution environment (cwd, tool restrictions, system prompt).
+ *
+ * `allowedDirectories` is intentionally excluded — directory restrictions are
+ * resolved at attach time and must not be blindly forwarded across adapter hops.
+ */
+type FallbackRuntimeOptions = Pick<AdapterRuntimeOptions, 'cwd' | 'systemPrompt' | 'allowedTools' | 'disallowedTools'>;
+/**
+ * Picks fallback-relevant runtime options from an object that carries
+ * `AdapterRuntimeOptions`-compatible fields.
+ *
+ * Covers both `adapter.startAgent` payloads (which merge `AdapterRuntimeOptionsSchema`
+ * at the top level) and caller-extracted `agent` sub-objects from
+ * `session.agent.attach` payloads (which carry the same fields on `AgentSelectionBase`).
+ *
+ * Only defined fields are included — omitted keys are not forwarded to avoid
+ * overwriting adapter or schema defaults with `undefined`.
+ * @param payload - Object carrying the runtime option fields
+ * @returns Sparse runtime options object used for fallback attach
+ */
+declare function pickFallbackRuntimeOptions(payload: Partial<Pick<AdapterRuntimeOptions, 'cwd' | 'systemPrompt' | 'allowedTools' | 'disallowedTools'>>): FallbackRuntimeOptions;
+//#endregion
+//#region services/core/src/session/context/assemble-fork-context.d.ts
+/**
+ * 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
+ *
+ * If not a fork first turn, returns the original sessionContext unchanged.
+ * @param bus - Bus instance for RPC calls
+ * @param session - Session to check for fork context
+ * @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)
+ * @returns Enriched or original SessionContext
+ */
+declare function assembleForkContext(bus: IMakaioBus, session: IMakaioSession, sessionId: string, originalContext?: SessionContext, isNewTurn?: boolean): Promise<SessionContext | undefined>;
+//#endregion
+//#region services/core/src/session/session-bridge.d.ts
+declare class SessionBridge {
+  private readonly bus;
+  private readonly agentToSession;
+  /** Extended mapping: agentId -\> \{ sessionId, turnId, adapterSessionId \} */
+  private readonly agentContext;
+  /** Block accumulator: agentId -\> blocks (one agent = one response per turn) */
+  private readonly agentBlocks;
+  private readonly cleanups;
+  constructor(bus?: IMakaioBus);
+  private registerHandlers;
+  /**
+   * Build and maintain agentId→sessionId mapping.
+   */
+  private registerMappingHandlers;
+  /**
+   * Track turn assignments for agents.
+   */
+  private registerTurnTrackingHandlers;
+  /**
+   * Accumulate blocks from agent events for storage on complete.
+   */
+  private registerBlockAccumulationHandlers;
+  /**
+   * Store accumulated blocks as an assistant message.
+   * @param agentId - ID of the agent that produced the message
+   * @param adapterSessionId - Optional adapter session ID
+   * @param error - Optional error message if agent failed
+   * @param messageOverride - Optional validated terminal message to store instead of accumulated provider blocks
+   */
+  private storeAssistantMessage;
+  /**
+   * Stop the bridge and clean up subscriptions.
+   */
+  destroy(): void;
+}
+//#endregion
+//#region services/core/src/session/extension-context.d.ts
+/**
+ * Implementation of SessionExtensionContext.
+ * Routes all actions through bus subjects.
+ */
+declare class SessionExtensionContextImpl implements SessionExtensionContext {
+  private readonly bus;
+  private readonly _sessionId;
+  private readonly _extensionId;
+  private readonly _turnId?;
+  private readonly _parentSessionId?;
+  private readonly contextTracker?;
+  private readonly contextContributions;
+  constructor(bus: IMakaioBus, _sessionId: string, _extensionId: string, _turnId?: string | undefined, _parentSessionId?: string | undefined, contextTracker?: ContextWindowTracker | undefined);
+  get sessionId(): string;
+  get turnId(): string | undefined;
+  get parentSessionId(): string | undefined;
+  get extensionId(): string;
+  sendToAgent(agentId: string, message: Message): Promise<void>;
+  contributeContext(key: string, value: unknown): void;
+  /**
+   * Get all contributions (called by orchestrator at turn boundary).
+   * @returns Record of all context contributions
+   */
+  getContributions(): Record<string, unknown>;
+  fork(options: ForkOptions): Promise<string>;
+  merge(childSessionId: string, summary?: string): Promise<void>;
+  abandon(childSessionId: string): Promise<void>;
+  requestCompression(reason: string): Promise<void>;
+  getContextWindowState(): Promise<ContextWindowState>;
+  getChildSessions(): Promise<string[]>;
+}
+/**
+ * Factory function for creating SessionExtensionContext instances.
+ * @param bus - The bus instance for communication
+ * @param sessionId - The session identifier
+ * @param extensionId - The extension identifier for audit trail
+ * @param turnId - Optional current turn identifier
+ * @param parentSessionId - Optional parent session identifier (for forked sessions)
+ * @param contextTracker - Optional ContextWindowTracker for real-time context state
+ * @returns A new SessionExtensionContextImpl instance
+ */
+declare function createSessionExtensionContext(bus: IMakaioBus, sessionId: string, extensionId: string, turnId?: string, parentSessionId?: string, contextTracker?: ContextWindowTracker): SessionExtensionContextImpl;
+//#endregion
+//#region services/core/src/session/storage/agent-namespace.d.ts
+/**
+ * Agent storage namespace.
+ *
+ * Provides bus subjects for agent CRUD operations and
+ * Drizzle schemas for SQL-based persistence.
+ * @example
+ * ```typescript
+ * import { AgentStorageSubjects } from '@makaio/framework/services/session';
+ *
+ * const { agent } = await bus.request(AgentStorageSubjects.get, { agentId: '123' });
+ * ```
+ */
+declare const AgentStorageNamespace: _$_makaio_storage_core0.StorageNamespaceDefinition<"agent", {
+  /**
+   * Get an agent by ID.
+   *
+   * Subject: `storage:agent.get`
+   * Type: Request (RPC)
+   */
+  get: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      agent: z.ZodNullable<z.ZodObject<{
+        agentId: z.ZodString;
+        adapterId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        adapterSessionId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        providerConfigId: z.ZodOptional<z.ZodString>;
+        personaId: z.ZodOptional<z.ZodString>;
+        profileId: z.ZodOptional<z.ZodString>;
+        harnessId: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        compressionMode: z.ZodOptional<z.ZodEnum<{
+          auto: "auto";
+          manual: "manual";
+          off: "off";
+        }>>;
+        role: z.ZodEnum<{
+          lead: "lead";
+          member: "member";
+        }>;
+        status: z.ZodEnum<{
+          active: "active";
+          idle: "idle";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        createdAt: z.ZodNumber;
+        lastActivityAt: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Store or update an agent.
+   *
+   * Subject: `storage:agent.set`
+   * Type: Request (RPC)
+   */
+  set: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      agent: z.ZodObject<{
+        agentId: z.ZodString;
+        adapterId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        adapterSessionId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        providerConfigId: z.ZodOptional<z.ZodString>;
+        personaId: z.ZodOptional<z.ZodString>;
+        profileId: z.ZodOptional<z.ZodString>;
+        harnessId: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        compressionMode: z.ZodOptional<z.ZodEnum<{
+          auto: "auto";
+          manual: "manual";
+          off: "off";
+        }>>;
+        role: z.ZodEnum<{
+          lead: "lead";
+          member: "member";
+        }>;
+        status: z.ZodEnum<{
+          active: "active";
+          idle: "idle";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        createdAt: z.ZodNumber;
+        lastActivityAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * Delete an agent by ID.
+   *
+   * Subject: `storage:agent.delete`
+   * Type: Request (RPC)
+   */
+  delete: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * List agents by adapter name with optional status filter.
+   *
+   * Subject: `storage:agent.listByAdapter`
+   * Type: Request (RPC)
+   */
+  listByAdapter: {
+    request: z.ZodObject<{
+      adapterName: z.ZodString;
+      status: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        active: "active";
+        idle: "idle";
+        dead: "dead";
+        disposed: "disposed";
+      }>>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      agents: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        adapterId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        adapterSessionId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        providerConfigId: z.ZodOptional<z.ZodString>;
+        personaId: z.ZodOptional<z.ZodString>;
+        profileId: z.ZodOptional<z.ZodString>;
+        harnessId: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        compressionMode: z.ZodOptional<z.ZodEnum<{
+          auto: "auto";
+          manual: "manual";
+          off: "off";
+        }>>;
+        role: z.ZodEnum<{
+          lead: "lead";
+          member: "member";
+        }>;
+        status: z.ZodEnum<{
+          active: "active";
+          idle: "idle";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        createdAt: z.ZodNumber;
+        lastActivityAt: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * List agents by session ID.
+   *
+   * Subject: `storage:agent.listBySession`
+   * Type: Request (RPC)
+   */
+  listBySession: {
+    request: z.ZodObject<{
+      sessionId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      agents: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        adapterId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        adapterSessionId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        providerConfigId: z.ZodOptional<z.ZodString>;
+        personaId: z.ZodOptional<z.ZodString>;
+        profileId: z.ZodOptional<z.ZodString>;
+        harnessId: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        compressionMode: z.ZodOptional<z.ZodEnum<{
+          auto: "auto";
+          manual: "manual";
+          off: "off";
+        }>>;
+        role: z.ZodEnum<{
+          lead: "lead";
+          member: "member";
+        }>;
+        status: z.ZodEnum<{
+          active: "active";
+          idle: "idle";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        createdAt: z.ZodNumber;
+        lastActivityAt: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Update agent status.
+   *
+   * Subject: `storage:agent.updateStatus`
+   * Type: Request (RPC)
+   */
+  updateStatus: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      status: z.ZodEnum<{
+        active: "active";
+        idle: "idle";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * Update agent last activity timestamp.
+   *
+   * Subject: `storage:agent.updateActivity`
+   * Type: Request (RPC)
+   */
+  updateActivity: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      lastActivityAt: z.ZodNumber;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * Update runtime-mutable agent fields without full record overwrite.
+   *
+   * Subject: `storage:agent.updateRuntime`
+   * Type: Request (RPC)
+   */
+  updateRuntime: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      cwd: z.ZodOptional<z.ZodString>;
+      model: z.ZodOptional<z.ZodString>;
+      providerConfigId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+}, {
+  drizzle: {
+    agents: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<{
+      name: "agents";
+      schema: undefined;
+      columns: {
+        agentId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "agent_id";
+          tableName: "agents";
+          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;
+        }>;
+        adapterId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "adapter_id";
+          tableName: "agents";
+          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;
+        }>;
+        adapterName: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "adapter_name";
+          tableName: "agents";
+          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;
+        }>;
+        sessionId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "session_id";
+          tableName: "agents";
+          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;
+        }>;
+        adapterSessionId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "adapter_session_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;
+        }>;
+        model: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "model";
+          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;
+        }>;
+        cwd: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "cwd";
+          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;
+        }>;
+        providerConfigId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "provider_config_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;
+        }>;
+        personaId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "persona_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;
+        }>;
+        profileId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "profile_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;
+        }>;
+        harnessId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "harness_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;
+        }>;
+        clientId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "client_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;
+        }>;
+        compressionMode: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "compression_mode";
+          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;
+        }>;
+        role: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "role";
+          tableName: "agents";
+          dataType: "string";
+          columnType: "SQLiteText";
+          data: "lead" | "member";
+          driverParam: string;
+          notNull: true;
+          hasDefault: false;
+          isPrimaryKey: false;
+          isAutoincrement: false;
+          hasRuntimeDefault: false;
+          enumValues: ["lead", "member"];
+          baseColumn: never;
+          identity: undefined;
+          generated: undefined;
+        }, {}, {
+          length: number | undefined;
+        }>;
+        status: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "status";
+          tableName: "agents";
+          dataType: "string";
+          columnType: "SQLiteText";
+          data: "active" | "idle" | "dead" | "disposed";
+          driverParam: string;
+          notNull: true;
+          hasDefault: false;
+          isPrimaryKey: false;
+          isAutoincrement: false;
+          hasRuntimeDefault: false;
+          enumValues: ["idle", "active", "dead", "disposed"];
+          baseColumn: never;
+          identity: undefined;
+          generated: undefined;
+        }, {}, {
+          length: number | undefined;
+        }>;
+        createdAt: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "created_at";
+          tableName: "agents";
+          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;
+        }, {}, {}>;
+        lastActivityAt: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "last_activity_at";
+          tableName: "agents";
+          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";
+    }>;
+  };
+}>;
+/**
+ * Typed subjects for agent storage operations.
+ */
+declare const AgentStorageSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSubjectDefinitions<"storage:agent", {
+  /**
+   * Get an agent by ID.
+   *
+   * Subject: `storage:agent.get`
+   * Type: Request (RPC)
+   */
+  get: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      agent: z.ZodNullable<z.ZodObject<{
+        agentId: z.ZodString;
+        adapterId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        adapterSessionId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        providerConfigId: z.ZodOptional<z.ZodString>;
+        personaId: z.ZodOptional<z.ZodString>;
+        profileId: z.ZodOptional<z.ZodString>;
+        harnessId: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        compressionMode: z.ZodOptional<z.ZodEnum<{
+          auto: "auto";
+          manual: "manual";
+          off: "off";
+        }>>;
+        role: z.ZodEnum<{
+          lead: "lead";
+          member: "member";
+        }>;
+        status: z.ZodEnum<{
+          active: "active";
+          idle: "idle";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        createdAt: z.ZodNumber;
+        lastActivityAt: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Store or update an agent.
+   *
+   * Subject: `storage:agent.set`
+   * Type: Request (RPC)
+   */
+  set: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      agent: z.ZodObject<{
+        agentId: z.ZodString;
+        adapterId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        adapterSessionId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        providerConfigId: z.ZodOptional<z.ZodString>;
+        personaId: z.ZodOptional<z.ZodString>;
+        profileId: z.ZodOptional<z.ZodString>;
+        harnessId: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        compressionMode: z.ZodOptional<z.ZodEnum<{
+          auto: "auto";
+          manual: "manual";
+          off: "off";
+        }>>;
+        role: z.ZodEnum<{
+          lead: "lead";
+          member: "member";
+        }>;
+        status: z.ZodEnum<{
+          active: "active";
+          idle: "idle";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        createdAt: z.ZodNumber;
+        lastActivityAt: z.ZodNumber;
+      }, z.core.$strip>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * Delete an agent by ID.
+   *
+   * Subject: `storage:agent.delete`
+   * Type: Request (RPC)
+   */
+  delete: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * List agents by adapter name with optional status filter.
+   *
+   * Subject: `storage:agent.listByAdapter`
+   * Type: Request (RPC)
+   */
+  listByAdapter: {
+    request: z.ZodObject<{
+      adapterName: z.ZodString;
+      status: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        active: "active";
+        idle: "idle";
+        dead: "dead";
+        disposed: "disposed";
+      }>>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      agents: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        adapterId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        adapterSessionId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        providerConfigId: z.ZodOptional<z.ZodString>;
+        personaId: z.ZodOptional<z.ZodString>;
+        profileId: z.ZodOptional<z.ZodString>;
+        harnessId: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        compressionMode: z.ZodOptional<z.ZodEnum<{
+          auto: "auto";
+          manual: "manual";
+          off: "off";
+        }>>;
+        role: z.ZodEnum<{
+          lead: "lead";
+          member: "member";
+        }>;
+        status: z.ZodEnum<{
+          active: "active";
+          idle: "idle";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        createdAt: z.ZodNumber;
+        lastActivityAt: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * List agents by session ID.
+   *
+   * Subject: `storage:agent.listBySession`
+   * Type: Request (RPC)
+   */
+  listBySession: {
+    request: z.ZodObject<{
+      sessionId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      agents: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        adapterId: z.ZodString;
+        adapterName: z.ZodString;
+        sessionId: z.ZodString;
+        adapterSessionId: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        cwd: z.ZodOptional<z.ZodString>;
+        providerConfigId: z.ZodOptional<z.ZodString>;
+        personaId: z.ZodOptional<z.ZodString>;
+        profileId: z.ZodOptional<z.ZodString>;
+        harnessId: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        compressionMode: z.ZodOptional<z.ZodEnum<{
+          auto: "auto";
+          manual: "manual";
+          off: "off";
+        }>>;
+        role: z.ZodEnum<{
+          lead: "lead";
+          member: "member";
+        }>;
+        status: z.ZodEnum<{
+          active: "active";
+          idle: "idle";
+          dead: "dead";
+          disposed: "disposed";
+        }>;
+        createdAt: z.ZodNumber;
+        lastActivityAt: z.ZodNumber;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Update agent status.
+   *
+   * Subject: `storage:agent.updateStatus`
+   * Type: Request (RPC)
+   */
+  updateStatus: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      status: z.ZodEnum<{
+        active: "active";
+        idle: "idle";
+        dead: "dead";
+        disposed: "disposed";
+      }>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * Update agent last activity timestamp.
+   *
+   * Subject: `storage:agent.updateActivity`
+   * Type: Request (RPC)
+   */
+  updateActivity: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      lastActivityAt: z.ZodNumber;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * Update runtime-mutable agent fields without full record overwrite.
+   *
+   * Subject: `storage:agent.updateRuntime`
+   * Type: Request (RPC)
+   */
+  updateRuntime: {
+    request: z.ZodObject<{
+      agentId: z.ZodString;
+      cwd: z.ZodOptional<z.ZodString>;
+      model: z.ZodOptional<z.ZodString>;
+      providerConfigId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+}>, "storage:agent">;
+//#endregion
+//#region services/core/src/session/storage/memory-handler.d.ts
+/**
+ * Register in-memory session storage handlers.
+ *
+ * Suitable for development, testing, and single-instance deployments.
+ * Data is lost when the process exits.
+ * @param bus - The bus instance to register handlers on
+ * @returns Cleanup function to unsubscribe all handlers
+ * @example
+ * ```typescript
+ * import { registerMemorySessionStorage } from '@makaio/framework/services/session';
+ *
+ * const cleanup = registerMemorySessionStorage(bus);
+ *
+ * // Later, when shutting down:
+ * cleanup();
+ * ```
+ */
+declare function registerMemorySessionStorage(bus: IMakaioBus): () => void;
+//#endregion
+//#region services/core/src/session/storage/drizzle-handler.d.ts
+/**
+ * Register Drizzle-based session storage handlers.
+ *
+ * Persists sessions to SQLite/libSQL via Drizzle ORM.
+ * Provides durable storage suitable for production deployments.
+ *
+ * CONCURRENCY INVARIANT: All handlers must use single-statement operations only.
+ * Storage handlers share a single DB connection. Fire-and-forget bus events
+ * (e.g., agent.added) race with sequential RPC handlers (e.g., turn.create).
+ * db.transaction() holds write locks across await boundaries, causing SQLITE_BUSY
+ * deadlocks on the same connection. Single statements serialize automatically
+ * via SQLite's busy_timeout + WAL mode.
+ * @param bus - The bus instance to register handlers on
+ * @param db - The Drizzle database instance (any libSQL database)
+ * @param _ctx - Extension context (unused; reserved for future use)
+ * @returns Cleanup function to unsubscribe all handlers
+ * @example
+ * ```typescript
+ * import { registerDrizzleSessionStorage } from '@makaio/framework/services/session';
+ * import { drizzle } from 'drizzle-orm/libsql';
+ * import { createClient } from '@libsql/client';
+ *
+ * const client = createClient({ url: 'file:./makaio.db' });
+ * const db = drizzle(client);
+ * const cleanup = registerDrizzleSessionStorage(bus, db, ctx);
+ *
+ * // Later, when shutting down:
+ * cleanup();
+ * ```
+ */
+declare function registerDrizzleSessionStorage(bus: IMakaioBus, db: MakaioDatabase, _ctx: ExtensionContext): () => void;
+//#endregion
+//#region services/core/src/session/storage/agent-memory-handler.d.ts
+/**
+ * Register in-memory agent storage handlers.
+ *
+ * Suitable for development and testing. Data is lost when the process exits.
+ * @param bus - The bus instance to register handlers on
+ * @returns Cleanup function to unsubscribe all handlers
+ */
+declare function registerMemoryAgentStorage(bus: IMakaioBus): () => void;
+//#endregion
+//#region services/core/src/session/storage/agent-drizzle-handler.d.ts
+/**
+ * Register Drizzle-based agent storage handlers.
+ *
+ * Persists agents to SQLite/libSQL via Drizzle ORM.
+ * Provides durable storage suitable for production deployments.
+ * @param bus - The bus instance to register handlers on
+ * @param db - The MakaioDatabase instance
+ * @param _ctx - Extension context (unused; reserved for future use)
+ * @returns Cleanup function to unsubscribe all handlers
+ * @example
+ * ```typescript
+ * import { registerDrizzleAgentStorage } from '@makaio/framework/services/session';
+ * import { drizzle } from 'drizzle-orm/libsql';
+ * import { createClient } from '@libsql/client';
+ *
+ * const client = createClient({ url: 'file:./makaio.db' });
+ * const db = drizzle(client);
+ * const cleanup = registerDrizzleAgentStorage(bus, db, ctx);
+ *
+ * // Later, when shutting down:
+ * cleanup();
+ * ```
+ */
+declare function registerDrizzleAgentStorage(bus: IMakaioBus, db: MakaioDatabase, _ctx: ExtensionContext): () => void;
+//#endregion
+//#region services/core/src/session/storage/fts-search-handler.d.ts
+/**
+ * Registers FTS-backed `storage:session.search` handler.
+ * @param bus - Bus instance used for handler registration
+ * @param db - Drizzle database instance
+ * @returns Cleanup function that unregisters the search handler
+ */
+declare function registerFtsSearchHandler(bus: IMakaioBus, db: MakaioDatabase): () => void;
+//#endregion
+//#region services/core/src/session/storage/fts-search-utils.d.ts
+/**
+ * Row shape returned by FTS session search queries.
+ *
+ * Contains only framework-owned columns. Scope fields (`project_id`,
+ * `worktree_id`, `workstream_id`) are intentionally absent — they are
+ * managed by the host-owned junction table after the sealed-sessions
+ * refactor.
+ */
+interface SearchSessionRow {
+  session_id: string;
+  created_at: number;
+  last_activity_at: number;
+  status: IMakaioSession['status'];
+  title: string | null;
+  lead_agent_id: string | null;
+  parent_session_id: string | null;
+  root_session_id: string | null;
+  fork_point_message_id: string | null;
+  branch_kind: IMakaioSession['branchKind'] | null;
+  adapter_name: string | null;
+  adapter_session_id: string | null;
+  adapter_id: string | null;
+  is_orchestrated: number | null;
+  is_imported: number | null;
+  summary: string | null;
+  summary_updated_at: number | null;
+  fork_transforms: string | null;
+  target_working_directory: string | null;
+}
+/**
+ * Filter parameters accepted by FTS search queries.
+ *
+ * Scope filters (`projectId`, `worktreeId`) are intentionally absent —
+ * scope-aware filtering is the responsibility of host priority-100
+ * handlers that JOIN with the `session_scopes` junction table.
+ */
+interface SearchFilters {
+  status: IMakaioSession['status'] | 'all';
+  isImported?: boolean;
+}
+/**
+ * Loads agent rows and groups them by session ID.
+ * @param db - Drizzle database instance
+ * @param sessionIds - Matched session IDs
+ * @returns Agent rows keyed by session ID
+ */
+declare function fetchAgentsBySession(db: MakaioDatabase, sessionIds: string[]): Promise<Map<string, Array<typeof agents.$inferSelect>>>;
+/**
+ * Resolves first-user-message previews for matched sessions.
+ * @param db - Drizzle database instance
+ * @param sessionIds - Matched session IDs
+ * @returns First user message text keyed by session ID
+ */
+declare function fetchPreviewBySession(db: MakaioDatabase, sessionIds: string[]): Promise<Map<string, string | null>>;
+/**
+ * Counts messages per matched session.
+ * @param db - Drizzle database instance
+ * @param sessionIds - Matched session IDs
+ * @returns Message counts keyed by session ID
+ */
+declare function fetchMessageCountsBySession(db: MakaioDatabase, sessionIds: string[]): Promise<Map<string, number>>;
+/**
+ * Parses serialized fork transform JSON.
+ * @param raw - Raw JSON column value
+ * @returns Parsed fork transforms, or undefined on invalid JSON
+ */
+declare function parseForkTransforms(raw: string | null): ForkTransforms | undefined;
+/**
+ * Maps a raw search row to session API format with preview metadata.
+ *
+ * Scope fields are intentionally absent from the returned `IMakaioSession`.
+ * Host handlers composing a scoped search must augment the result with
+ * scope data read from the junction table after calling this utility.
+ * @param row - Raw session row from SQL search query
+ * @param sessionAgents - Agents attached to the session
+ * @param previewBySession - First-user-message map
+ * @param countBySession - Message count map
+ * @returns Session payload with preview block
+ */
+declare function mapRowToSession(row: SearchSessionRow, sessionAgents: Array<typeof agents.$inferSelect>, previewBySession: Map<string, string | null>, countBySession: Map<string, number>): IMakaioSession & {
+  preview: {
+    messageCount: number;
+    firstUserMessage: string | null;
+  };
+};
+//#endregion
+//#region services/core/src/session/storage/drizzle-utils.d.ts
+type SessionRow = typeof sessions.$inferSelect;
+type AgentRow = typeof agents.$inferSelect;
+/**
+ * Preview maps for session list response hydration.
+ */
+interface SessionPreviewMaps {
+  previewBySession?: Map<string, string | null>;
+  countBySession?: Map<string, number>;
+}
+/**
+ * Map a Drizzle session row to the `IMakaioSession` API type.
+ *
+ * Scope fields (`projectId`, `worktreeId`, `workstreamId`) are intentionally
+ * absent from the returned object. They are managed by the host-owned
+ * junction table after the sealed-sessions refactor. Host handlers
+ * composing a scoped query must augment the result with scope data read
+ * from the junction table.
+ * @param sessionRow - The session table row
+ * @param agentRows - The associated agent rows
+ * @returns The mapped session object
+ */
+declare function mapToSession(sessionRow: SessionRow, agentRows: AgentRow[]): IMakaioSession;
+/**
+ * Groups agent rows by session ID for list response hydration.
+ * @param agentRows - Agent table rows
+ * @returns Map keyed by session ID
+ */
+declare function mapAgentsBySession(agentRows: AgentRow[]): Map<string, AgentRow[]>;
+/**
+ * Fetches optional preview maps for session list responses.
+ * @param db - Drizzle database client
+ * @param sessionIds - Session IDs in current result page
+ * @param includePreview - Whether preview fields are requested
+ * @returns Preview maps for first user message and message count
+ */
+declare function fetchSessionPreviewMaps(db: MakaioDatabase, sessionIds: string[], includePreview: boolean): Promise<SessionPreviewMaps>;
+//#endregion
+//#region services/core/src/session/session-events/schema.d.ts
+/**
+ * Session events table schema.
+ *
+ * Stores immutable, append-only session events for unified history reconstruction.
+ * Events are persisted by SessionLogger via storage service.
+ *
+ * **Event Types:**
+ * - Message references (type='message' with messageId FK to messages table)
+ * - Agent lifecycle (agent.added)
+ * - Turn lifecycle (turn.started, turn.completed)
+ * - User message events (user_message.sent/acknowledged/completed)
+ *
+ * Design rationale:
+ * - First-class columns for queryable fields (IDs, timestamp, type)
+ * - `contentText` extracted for FTS5/embeddings (future)
+ * - `payload` stores full JSON for exact API reconstruction
+ *
+ * SEAM: The `sessionId` FK enables cascade delete when sessions are purged.
+ * Future embeddings table can reference `eventId` for vector search.
+ */
+declare const sessionEvents: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<{
+  name: "session_events";
+  schema: undefined;
+  columns: {
+    id: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "id";
+      tableName: "session_events";
+      dataType: "number";
+      columnType: "SQLiteInteger";
+      data: number;
+      driverParam: number;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: true;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+    sessionId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "session_id";
+      tableName: "session_events";
+      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;
+    }>;
+    eventId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "event_id";
+      tableName: "session_events";
+      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;
+    }>;
+    timestamp: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "timestamp";
+      tableName: "session_events";
+      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;
+    }, {}, {}>;
+    type: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "type";
+      tableName: "session_events";
+      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;
+    }>;
+    agentId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "agent_id";
+      tableName: "session_events";
+      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;
+    }>;
+    adapterId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "adapter_id";
+      tableName: "session_events";
+      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;
+    }>;
+    originatingMessageId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "originating_message_id";
+      tableName: "session_events";
+      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;
+    }>;
+    messageId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "message_id";
+      tableName: "session_events";
+      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;
+    }>;
+    turnId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "turn_id";
+      tableName: "session_events";
+      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;
+    }>;
+    contentText: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "content_text";
+      tableName: "session_events";
+      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;
+    }>;
+    payload: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "payload";
+      tableName: "session_events";
+      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;
+    }>;
+  };
+  dialect: "sqlite";
+}>;
+/**
+ * Type for inserting a new session event.
+ */
+type InsertSessionEvent = typeof sessionEvents.$inferInsert;
+/**
+ * Type for a selected session event row.
+ */
+type SelectSessionEvent = typeof sessionEvents.$inferSelect;
+//#endregion
+//#region services/core/src/session/session-events/memory-handler.d.ts
+/**
+ * Register in-memory session event storage handlers.
+ *
+ * Suitable for development, testing, and single-instance deployments.
+ * Data is lost when the process exits.
+ *
+ * Events are stored per-session in insertion order. Cursor-based pagination
+ * uses a stable, monotonically-increasing sequence ID (`seqIdByEventId`)
+ * assigned at append time — semantically equivalent to the Drizzle handler's
+ * auto-increment `id` column. Cursors survive concurrent appends and remain
+ * meaningful after deletes: an `after` cursor simply skips all events whose
+ * seqId is ≤ the cursor value, regardless of whether the referenced event
+ * still exists.
+ * @param bus - The bus instance to register handlers on
+ * @returns Cleanup function to unsubscribe all handlers
+ * @example
+ * ```typescript
+ * import { registerMemorySessionEventStorage } from '@makaio/framework/services/session';
+ *
+ * const cleanup = registerMemorySessionEventStorage(bus);
+ *
+ * // Later, when shutting down:
+ * cleanup();
+ * ```
+ */
+declare function registerMemorySessionEventStorage(bus: IMakaioBus): () => void;
+//#endregion
+//#region services/core/src/session/session-events/drizzle-handler.d.ts
+/**
+ * Register Drizzle-based session event storage handlers.
+ *
+ * Persists events to SQLite/libSQL via Drizzle ORM with cursor-based
+ * pagination and content extraction for future FTS/embedding support.
+ * @param bus - The bus instance to register handlers on
+ * @param db - The Drizzle database instance (any libSQL database)
+ * @param _ctx - Extension context (unused; reserved for future use)
+ * @returns Cleanup function to unsubscribe all handlers
+ * @example
+ * ```typescript
+ * import { registerDrizzleSessionEventStorage } from '@makaio/framework/services/session';
+ * import { drizzle } from 'drizzle-orm/libsql';
+ * import { createClient } from '@libsql/client';
+ *
+ * const client = createClient({ url: 'file:./makaio.db' });
+ * const db = drizzle(client);
+ * const cleanup = registerDrizzleSessionEventStorage(bus, db, ctx);
+ *
+ * // Later, when shutting down:
+ * cleanup();
+ * ```
+ */
+declare function registerDrizzleSessionEventStorage(bus: IMakaioBus, db: MakaioDatabase, _ctx: ExtensionContext): () => void;
+//#endregion
+//#region services/core/src/session/session-logger.d.ts
+/**
+ * Transform function for event payloads before storage emission.
+ * Use for redaction, PII filtering, or payload normalization.
+ *
+ * **Scope:** Only affects events emitted to `storage:sessionEvent.append`.
+ * Individual subjects (`session.agent.*`, `session.user_message.*`) still receive
+ * raw payloads. For full bus-level PII protection, redaction must happen at emit sites
+ * (e.g., in SessionOrchestrator before emitting user_message.sent).
+ * @param event - The event to transform
+ * @returns Transformed event, or null to skip storage emission
+ */
+type EventTransform = (event: MakaioSessionEvent) => MakaioSessionEvent | null;
+/**
+ * Options for SessionLogger.
+ */
+interface SessionLoggerOptions {
+  /**
+   * Transform function applied before storage emission.
+   * Return null to skip storage entirely.
+   * Note: Does not affect individual session.* subjects (see EventTransform docs).
+   * Default: identity (no transformation)
+   */
+  transform?: EventTransform;
+}
+/**
+ * Bridges session lifecycle events to storage layer for persistence.
+ *
+ * **Architecture (Normalized Message Model):**
+ * - Messages: Stored in `messages` table via MessageStorageSubjects (by SessionOrchestrator/SessionBridge)
+ * - SessionLogger: Stores LIFECYCLE events only — agent.added, turn.started, turn.completed
+ *
+ * **NO longer subscribes to user_message.* events** — user messages are now
+ * first-class entities in the `messages` table, not embedded in event payloads.
+ *
+ * The correlation link is `session.agent.added` which maps:
+ * `sessionId ↔ agentId ↔ adapterSessionId`
+ *
+ * Subscribes to:
+ * - session.agent.added — correlation link for multi-agent reconstruction
+ * - session.turn.started, session.turn.completed — turn lifecycle
+ * - session.branch.created — branch creation audit trail
+ *
+ * Does NOT subscribe to session.branch.merged or session.squash — those
+ * handlers (merge-handler, compress-handler) own their persistence directly
+ * using a stable eventId so retries are idempotent.
+ *
+ * Emits transformed events to `storage:sessionEvent.append` for persistence.
+ * @example
+ * ```typescript
+ * // Basic usage - lifecycle events are emitted to storage:sessionEvent.append
+ * const sessionLogger = new SessionLogger(MakaioBus);
+ *
+ * // With redaction transform (mainly for turn error messages)
+ * const sessionLogger = new SessionLogger(MakaioBus, {
+ *   transform: (event) => {
+ *     // Redact sensitive info if needed
+ *     return event;
+ *   },
+ * });
+ * ```
+ */
+declare class SessionLogger {
+  private readonly bus;
+  private readonly options;
+  private readonly cleanups;
+  private readonly transform;
+  constructor(bus?: IMakaioBus, options?: SessionLoggerOptions);
+  /**
+   * Emit a session event to storage layer.
+   *
+   * Creates event envelope, applies transform, and emits to storage subject.
+   * If transform returns null, event is skipped.
+   * @param eventType - Event type for classification
+   * @param sessionId - Session identifier
+   * @param payload - Event payload to persist
+   */
+  private emitStorageEvent;
+  /**
+   * Register a handler for a session event subject.
+   * @param subject - Subject definition to subscribe to
+   * @param eventType - Event type for persistence
+   */
+  private registerHandler;
+  /**
+   * Register all session lifecycle event handlers.
+   *
+   * **Normalized Message Model:**
+   * - User messages are stored in `messages` table by SessionOrchestrator
+   * - Assistant messages are stored by SessionBridge on agent.complete
+   * - SessionLogger only stores LIFECYCLE events for audit/correlation
+   */
+  private registerHandlers;
+  /**
+   * Stop the logger and clean up subscriptions.
+   */
+  destroy(): void;
+}
+//#endregion
+//#region services/core/src/session/import-cursors/schema.d.ts
+/**
+ * Import cursors table schema.
+ *
+ * Tracks byte offsets for incremental log file import.
+ * Enables resuming import from the last processed position after restarts.
+ */
+declare const importCursors: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<{
+  name: "import_cursors";
+  schema: undefined;
+  columns: {
+    filePath: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "file_path";
+      tableName: "import_cursors";
+      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;
+    }>;
+    bytesRead: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "bytes_read";
+      tableName: "import_cursors";
+      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;
+    }, {}, {}>;
+    lastModified: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "last_modified";
+      tableName: "import_cursors";
+      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;
+    }>;
+    updatedAt: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "updated_at";
+      tableName: "import_cursors";
+      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";
+}>;
+//#endregion
+//#region services/core/src/session/import-cursors/drizzle-handler.d.ts
+/**
+ * Register Drizzle-backed import cursor storage handlers.
+ *
+ * Provides persistent cursor storage for efficient log import resume.
+ * On restart, import continues from the last processed byte offset.
+ * @param bus - The bus instance to register handlers on
+ * @param db - Drizzle database instance
+ * @param _ctx - Extension context (unused; reserved for future use)
+ * @returns Cleanup function to unsubscribe all handlers
+ * @example
+ * ```typescript
+ * import { registerDrizzleImportCursorStorage } from '@makaio/framework/services/session';
+ *
+ * const cleanup = registerDrizzleImportCursorStorage(bus, db, ctx);
+ *
+ * // Later, when shutting down:
+ * cleanup();
+ * ```
+ */
+declare function registerDrizzleImportCursorStorage(bus: IMakaioBus, db: MakaioDatabase, _ctx: ExtensionContext): () => void;
+//#endregion
+//#region services/core/src/session/turns/drizzle-handler.d.ts
+/**
+ * Register Drizzle-based turn storage handlers.
+ *
+ * Manages turn lifecycle in SQLite/libSQL via Drizzle ORM.
+ *
+ * CONCURRENCY INVARIANT: All handlers must use single-statement operations only.
+ * Storage handlers share a single DB connection. Fire-and-forget bus events
+ * (e.g., agent.added) race with sequential RPC handlers (e.g., turn.create).
+ * db.transaction() holds write locks across await boundaries, causing SQLITE_BUSY
+ * deadlocks on the same connection. Single statements serialize automatically
+ * via SQLite's busy_timeout + WAL mode.
+ * @param bus - The bus instance to register handlers on
+ * @param db - The Drizzle database instance
+ * @param _ctx - Extension context (unused; reserved for future use)
+ * @returns Cleanup function to unsubscribe all handlers
+ */
+declare function registerDrizzleTurnStorage(bus: IMakaioBus, db: MakaioDatabase, _ctx: ExtensionContext): () => void;
+//#endregion
+//#region services/core/src/session/turns/memory-handler.d.ts
+/**
+ * Register in-memory turn storage handlers.
+ *
+ * Suitable for development and tests. Data is lost on process exit.
+ * @param bus - The bus instance to register handlers on
+ * @returns Cleanup function to unsubscribe all handlers
+ */
+declare function registerMemoryTurnStorage(bus: IMakaioBus): () => void;
+//#endregion
+//#region services/core/src/session/turns/schema.d.ts
+/**
+ * Turns table schema.
+ *
+ * A turn represents a user message and all agent responses to it.
+ * Extracted from events to provide explicit turn boundaries.
+ *
+ * Design rationale:
+ * - First-class entity for turn lifecycle tracking
+ * - Links to session via FK for cascade delete
+ * - Status tracks completion state for UI progress indication
+ */
+declare const turns: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<{
+  name: "turns";
+  schema: undefined;
+  columns: {
+    turnId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "turn_id";
+      tableName: "turns";
+      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;
+    }>;
+    sessionId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "session_id";
+      tableName: "turns";
+      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;
+    }>;
+    turnNumber: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "turn_number";
+      tableName: "turns";
+      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: "started_at";
+      tableName: "turns";
+      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;
+    }, {}, {}>;
+    completedAt: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "completed_at";
+      tableName: "turns";
+      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;
+    }, {}, {}>;
+    status: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "status";
+      tableName: "turns";
+      dataType: "string";
+      columnType: "SQLiteText";
+      data: "error" | "active" | "completed";
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: ["active", "completed", "error"];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: number | undefined;
+    }>;
+    error: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "error";
+      tableName: "turns";
+      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;
+    }>;
+    usage: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "usage";
+      tableName: "turns";
+      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";
+}>;
+/**
+ * Type for inserting a new turn.
+ */
+type InsertTurn = typeof turns.$inferInsert;
+/**
+ * Type for a selected turn row.
+ */
+type SelectTurn = typeof turns.$inferSelect;
+//#endregion
+//#region services/core/src/session/messages/drizzle-handler.d.ts
+/**
+ * Register Drizzle-based message storage handlers.
+ *
+ * Manages message persistence in SQLite/libSQL via Drizzle ORM.
+ * @param bus - The bus instance to register handlers on
+ * @param db - The Drizzle database instance
+ * @param _ctx - Extension context (unused; reserved for future use)
+ * @returns Cleanup function to unsubscribe all handlers
+ */
+declare function registerDrizzleMessageStorage(bus: IMakaioBus, db: MakaioDatabase, _ctx: ExtensionContext): () => void;
+//#endregion
+//#region services/core/src/session/messages/memory-handler.d.ts
+/**
+ * Register in-memory message storage handlers.
+ *
+ * Intended for dev/test runtime usage. Durable storage is provided by the
+ * Drizzle handlers in ./drizzle-handler.ts.
+ * @param bus - The bus instance to register handlers on
+ * @returns Cleanup function to unregister handlers
+ */
+declare function registerMemoryMessageStorage(bus: IMakaioBus): () => void;
+//#endregion
+//#region services/core/src/session/messages/schema.d.ts
+/**
+ * Messages table schema.
+ *
+ * The single source of truth for conversation content as consumed by Makaio
+ * (UI history, search, transforms, routing).
+ *
+ * Design principles:
+ * - Messages are first-class entities, not embedded in events
+ * - Single source of truth for conversation content
+ * - Blocks stored as JSON for flexible structure
+ * - contentText extracted for FTS5 search
+ * - session_events tracks lifecycle (turns, branches) but not content
+ */
+declare const messages: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<{
+  name: "messages";
+  schema: undefined;
+  columns: {
+    messageId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "message_id";
+      tableName: "messages";
+      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;
+    }>;
+    turnId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "turn_id";
+      tableName: "messages";
+      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;
+    }>;
+    sessionId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "session_id";
+      tableName: "messages";
+      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;
+    }>;
+    role: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "role";
+      tableName: "messages";
+      dataType: "string";
+      columnType: "SQLiteText";
+      data: "user" | "assistant";
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: ["user", "assistant"];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: number | undefined;
+    }>;
+    contentText: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "content_text";
+      tableName: "messages";
+      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;
+    }>;
+    blocks: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "blocks";
+      tableName: "messages";
+      dataType: "string";
+      columnType: "SQLiteText";
+      data: string;
+      driverParam: string;
+      notNull: true;
+      hasDefault: true;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: [string, ...string[]];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: number | undefined;
+    }>;
+    agentId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "agent_id";
+      tableName: "messages";
+      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: "messages";
+      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;
+    }>;
+    adapterMessageId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "adapter_message_id";
+      tableName: "messages";
+      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;
+    }>;
+    timestamp: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "timestamp";
+      tableName: "messages";
+      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;
+    }, {}, {}>;
+    editOf: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "edit_of";
+      tableName: "messages";
+      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;
+    }>;
+    origin: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "origin";
+      tableName: "messages";
+      dataType: "string";
+      columnType: "SQLiteText";
+      data: "text" | "voice" | "compact";
+      driverParam: string;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: ["voice", "text", "compact"];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: number | undefined;
+    }>;
+  };
+  dialect: "sqlite";
+}>;
+/**
+ * Type for inserting a new message.
+ */
+type InsertMessage = typeof messages.$inferInsert;
+/**
+ * Type for a selected message row.
+ */
+type SelectMessage = typeof messages.$inferSelect;
+//#endregion
+//#region services/core/src/session/message-routing/namespace.d.ts
+/**
+ * Message routing storage namespace.
+ *
+ * Tracks delivery status of messages to agents in multi-agent sessions.
+ * Enables querying completion status for turn coordination.
+ */
+declare const MessageRoutingNamespace: _$_makaio_storage_core0.StorageNamespaceDefinition<"messageRouting", {
+  /**
+   * Record routing status for a message to an agent.
+   *
+   * Subject: `storage:messageRouting.record`
+   * Type: Request (RPC)
+   */
+  record: {
+    request: z.ZodObject<{
+      messageId: z.ZodString;
+      agentId: z.ZodString;
+      status: z.ZodEnum<{
+        completed: "completed";
+        sent: "sent";
+        acknowledged: "acknowledged";
+      }>;
+      timestamp: z.ZodNumber;
+      error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * Get routing status for a message.
+   *
+   * Subject: `storage:messageRouting.getByMessage`
+   * Type: Request (RPC)
+   */
+  getByMessage: {
+    request: z.ZodObject<{
+      messageId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      routing: z.ZodArray<z.ZodObject<{
+        messageId: z.ZodString;
+        agentId: z.ZodString;
+        status: z.ZodEnum<{
+          completed: "completed";
+          sent: "sent";
+          acknowledged: "acknowledged";
+        }>;
+        timestamp: z.ZodNumber;
+        error: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Get all completed routings for a message.
+   * Used to check if all target agents have responded.
+   *
+   * Subject: `storage:messageRouting.getCompleted`
+   * Type: Request (RPC)
+   */
+  getCompleted: {
+    request: z.ZodObject<{
+      messageId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      agentIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Check if all target agents have completed for a message.
+   *
+   * Subject: `storage:messageRouting.isComplete`
+   * Type: Request (RPC)
+   */
+  isComplete: {
+    request: z.ZodObject<{
+      messageId: z.ZodString;
+      targetAgentIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      complete: z.ZodBoolean;
+      pending: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+  };
+}, {
+  drizzle: {
+    messageRouting: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<{
+      name: "message_routing";
+      schema: undefined;
+      columns: {
+        messageId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "message_id";
+          tableName: "message_routing";
+          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;
+        }>;
+        agentId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "agent_id";
+          tableName: "message_routing";
+          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;
+        }>;
+        status: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "status";
+          tableName: "message_routing";
+          dataType: "string";
+          columnType: "SQLiteText";
+          data: "completed" | "sent" | "acknowledged";
+          driverParam: string;
+          notNull: true;
+          hasDefault: false;
+          isPrimaryKey: false;
+          isAutoincrement: false;
+          hasRuntimeDefault: false;
+          enumValues: ["sent", "acknowledged", "completed"];
+          baseColumn: never;
+          identity: undefined;
+          generated: undefined;
+        }, {}, {
+          length: number | undefined;
+        }>;
+        timestamp: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "timestamp";
+          tableName: "message_routing";
+          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;
+        }, {}, {}>;
+        error: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+          name: "error";
+          tableName: "message_routing";
+          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";
+    }>;
+  };
+}>;
+/**
+ * Typed subjects for message routing storage operations.
+ */
+declare const MessageRoutingSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatSubjectDefinitions<"storage:messageRouting", {
+  /**
+   * Record routing status for a message to an agent.
+   *
+   * Subject: `storage:messageRouting.record`
+   * Type: Request (RPC)
+   */
+  record: {
+    request: z.ZodObject<{
+      messageId: z.ZodString;
+      agentId: z.ZodString;
+      status: z.ZodEnum<{
+        completed: "completed";
+        sent: "sent";
+        acknowledged: "acknowledged";
+      }>;
+      timestamp: z.ZodNumber;
+      error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      success: z.ZodBoolean;
+    }, z.core.$strip>;
+  };
+  /**
+   * Get routing status for a message.
+   *
+   * Subject: `storage:messageRouting.getByMessage`
+   * Type: Request (RPC)
+   */
+  getByMessage: {
+    request: z.ZodObject<{
+      messageId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      routing: z.ZodArray<z.ZodObject<{
+        messageId: z.ZodString;
+        agentId: z.ZodString;
+        status: z.ZodEnum<{
+          completed: "completed";
+          sent: "sent";
+          acknowledged: "acknowledged";
+        }>;
+        timestamp: z.ZodNumber;
+        error: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Get all completed routings for a message.
+   * Used to check if all target agents have responded.
+   *
+   * Subject: `storage:messageRouting.getCompleted`
+   * Type: Request (RPC)
+   */
+  getCompleted: {
+    request: z.ZodObject<{
+      messageId: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      agentIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+  };
+  /**
+   * Check if all target agents have completed for a message.
+   *
+   * Subject: `storage:messageRouting.isComplete`
+   * Type: Request (RPC)
+   */
+  isComplete: {
+    request: z.ZodObject<{
+      messageId: z.ZodString;
+      targetAgentIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+      complete: z.ZodBoolean;
+      pending: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+  };
+}>, "storage:messageRouting">;
+//#endregion
+//#region services/core/src/session/message-routing/drizzle-handler.d.ts
+/**
+ * Register Drizzle-based message routing storage handlers.
+ *
+ * Manages message delivery tracking in SQLite/libSQL via Drizzle ORM.
+ * @param bus - The bus instance to register handlers on
+ * @param db - The Drizzle database instance
+ * @param _ctx - Extension context (unused; reserved for future use)
+ * @returns Cleanup function to unsubscribe all handlers
+ */
+declare function registerDrizzleMessageRoutingStorage(bus: IMakaioBus, db: MakaioDatabase, _ctx: ExtensionContext): () => void;
+//#endregion
+//#region services/core/src/session/message-routing/schema.d.ts
+/**
+ * Message routing table schema.
+ *
+ * Tracks delivery status of messages to agents in multi-agent sessions.
+ * Each row represents a message-agent pair with status progression.
+ *
+ * Status progression: sent -\> acknowledged -\> completed
+ *
+ * Design rationale:
+ * - Composite primary key allows multiple status entries per message-agent pair
+ * - Enables tracking of delivery lifecycle for each target agent
+ * - Supports querying "which agents have completed for this message?"
+ */
+declare const messageRouting: _$drizzle_orm_sqlite_core0.SQLiteTableWithColumns<{
+  name: "message_routing";
+  schema: undefined;
+  columns: {
+    messageId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "message_id";
+      tableName: "message_routing";
+      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;
+    }>;
+    agentId: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "agent_id";
+      tableName: "message_routing";
+      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;
+    }>;
+    status: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "status";
+      tableName: "message_routing";
+      dataType: "string";
+      columnType: "SQLiteText";
+      data: "completed" | "sent" | "acknowledged";
+      driverParam: string;
+      notNull: true;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: ["sent", "acknowledged", "completed"];
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {
+      length: number | undefined;
+    }>;
+    timestamp: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "timestamp";
+      tableName: "message_routing";
+      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;
+    }, {}, {}>;
+    error: _$drizzle_orm_sqlite_core0.SQLiteColumn<{
+      name: "error";
+      tableName: "message_routing";
+      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";
+}>;
+/**
+ * Type for inserting a new routing entry.
+ */
+type InsertMessageRouting = typeof messageRouting.$inferInsert;
+/**
+ * Type for a selected routing entry row.
+ */
+type SelectMessageRouting = typeof messageRouting.$inferSelect;
+//#endregion
+//#region services/core/src/session/entities/makaio-session.d.ts
+/**
+ * Configuration for creating a MakaioSession.
+ */
+interface MakaioSessionConfig {
+  /** Session ID (generated if not provided) */
+  sessionId?: string;
+  /** Bus for event emission */
+  bus: IMakaioBus;
+  /** Parent session ID (for forks) */
+  parentSessionId?: string;
+}
+/**
+ * Options for starting a turn.
+ */
+interface StartTurnOptions {
+  /** Agents participating in this turn */
+  agentIds: string[];
+  /** Initial message ID (required - turn.started schema mandates it) */
+  messageId: string;
+  /** Monotonic per-session ordinal (1-based), assigned by turn storage. */
+  turnNumber: number;
+  /** Optional pre-generated turn ID */
+  turnId?: string;
+}
+/**
+ * MakaioSession is the aggregate root for session state.
+ *
+ * It owns Turn[] children and emits lifecycle events from within,
+ * mirroring the AIAgent pattern. Events are emitted when state changes,
+ * not by external orchestration code.
+ *
+ * SEAM: This entity is designed to support future buildContext() method
+ * for projecting raw history to effective history (transforms, token budgets).
+ */
+declare class MakaioSession {
+  readonly sessionId: string;
+  readonly parentSessionId?: string;
+  status: 'active' | 'closed' | 'archived';
+  /** Turn children - owned by this aggregate */
+  private readonly _turns;
+  /** Track which turns have been completed */
+  private readonly _completedTurnIds;
+  /** Bus for event emission */
+  protected readonly bus: IMakaioBus;
+  constructor(config: MakaioSessionConfig);
+  /**
+   * Get turns owned by this session (read-only view).
+   * @returns Immutable array of turns
+   */
+  get turns(): readonly Turn$1[];
+  /**
+   * Start a new turn in this session.
+   *
+   * Creates a Turn child entity and emits turn.started event.
+   * This is the key pattern: state change + event emission happen together
+   * inside the aggregate, not in external orchestration code.
+   * @param options - Turn configuration
+   * @returns The created Turn
+   * @throws Error if session is not active (for example closed or archived)
+   */
+  startTurn(options: StartTurnOptions): Promise<Turn$1>;
+  /**
+   * Get the currently active (incomplete) turn.
+   * @returns The active turn, or undefined if no turn is active
+   */
+  getActiveTurn(): Turn$1 | undefined;
+  /**
+   * Complete a turn and emit turn.completed event.
+   * @param turn - The turn to complete
+   */
+  completeTurn(turn: Turn$1): Promise<void>;
+  /**
+   * Emit an event with sessionId auto-enriched.
+   *
+   * Mirrors AIAgent.emitGlobal pattern - entity emits its own events
+   * with context automatically included.
+   * @param subject - The subject to emit to
+   * @param payload - The payload (without sessionId - it's added automatically)
+   */
+  protected emit<S extends SubjectDefinition>(subject: S, payload: Omit<ExtractSubjectPayload<S>, 'sessionId'>): Promise<void>;
+}
+//#endregion
+//#region services/core/src/session/import/parent-resolver.d.ts
+/**
+ * Register handler to resolve parent relationships when sessions are imported.
+ *
+ * When `session.import.completed` is emitted:
+ * 1. Query sessions for children whose `parentExternalSessionId` matches
+ *    the just-imported session's `adapterSessionId` and whose `parentSessionId`
+ *    is still null (unresolved).
+ * 2. For each unresolved child, update its `parentSessionId` and `rootSessionId`.
+ * 3. Cascade `rootSessionId` down the tree to any already-resolved grandchildren.
+ * @param bus - The bus instance to register handlers on
+ * @param db - The Drizzle database instance for direct queries
+ * @returns Cleanup function to unsubscribe the handler
+ * @example
+ * ```typescript
+ * import { registerParentResolver } from '@makaio/framework/services/session';
+ *
+ * const cleanup = registerParentResolver(bus, db);
+ *
+ * // Later, when shutting down:
+ * cleanup();
+ * ```
+ */
+declare function registerParentResolver(bus: IMakaioBus, db: MakaioDatabase): () => void;
+//#endregion
+//#region services/core/src/session/import/compress-lineage-resolver.d.ts
+/**
+ * Re-parents post-compaction subagents from the parent session to the compress child.
+ *
+ * Handles two scenarios triggered by `session.import.completed`:
+ *
+ * **Path A — compress child imported first (batch import)**:
+ * When a compress child import completes, subagents spawned after compaction are
+ * already parented to the parent Makaio session (by the parent-resolver).
+ * This path scans the compress child's messages and re-parents matching subagents.
+ *
+ * **Path B — subagent imported after compress child (incremental / separate files)**:
+ * When a subagent import completes and its parent has compress children, the compress
+ * children and their messages already exist. This path scans those compress
+ * children for the subagent's spawning tool_call and re-parents when found.
+ *
+ * Must be registered BEFORE registerSpawningToolCallResolver so it runs
+ * first on `session.import.completed` (bus handlers fire in registration order).
+ * @param bus - The bus instance to register handlers on
+ * @returns Cleanup function to unsubscribe the handler
+ * @example
+ * ```typescript
+ * import { registerCompressLineageResolver } from '@makaio/framework/services/session';
+ *
+ * const cleanup = registerCompressLineageResolver(bus);
+ *
+ * // Later, when shutting down:
+ * cleanup();
+ * ```
+ */
+declare function registerCompressLineageResolver(bus: IMakaioBus): () => void;
+//#endregion
+//#region services/core/src/session/import/spawning-tool-call-resolver.d.ts
+/**
+ * Register handler to backfill `spawningToolCallId` for imported subagent sessions.
+ *
+ * When `session.import.completed` is emitted:
+ * 1. Fetch children of the newly imported parent session.
+ * 2. Filter to subagent children with no `spawningToolCallId`.
+ * 3. Fetch parent session messages and scan for Agent/spawn_subagent tool_call blocks.
+ * 4. Match each unmatched child to a tool_call by tool_output content reference
+ *    (session ID in output string). Unmatched children are left as null.
+ * 5. Update matched children via `SessionStorageSubjects.update`.
+ * @param bus - The bus instance to register handlers on
+ * @returns Cleanup function to unsubscribe the handler
+ * @example
+ * ```typescript
+ * import { registerSpawningToolCallResolver } from '@makaio/framework/services/session';
+ *
+ * const cleanup = registerSpawningToolCallResolver(bus);
+ *
+ * // Later, when shutting down:
+ * cleanup();
+ * ```
+ */
+declare function registerSpawningToolCallResolver(bus: IMakaioBus): () => void;
+//#endregion
+//#region services/core/src/session/import/session-discovered-handler.d.ts
+/**
+ * Register a bus handler for `adapter.session.discovered` events.
+ *
+ * When a session is discovered from a log watcher:
+ * 1. Validates the payload with `SessionDiscoveredSchema` (fail-fast on schema violations).
+ * 2. Calls `storage:session.importUpsert` to create or enrich the session record atomically.
+ *    - On first discovery: inserts a stub session with `importStatus='discovered'` and
+ *      eagerly resolves `parentSessionId` / `rootSessionId` when the parent is already imported.
+ *    - On re-discovery: COALESCE-merges enrichment fields (title, cwd, logFilePath)
+ *      so subsequent scans can supply previously-unknown values without overwriting existing data.
+ * @param bus - The bus instance to register the handler on
+ * @returns Cleanup function to unsubscribe the handler
+ * @example
+ * ```typescript
+ * import { registerSessionDiscoveredHandler } from '@makaio/framework/services/session';
+ *
+ * const cleanup = registerSessionDiscoveredHandler(bus);
+ *
+ * // Later, when shutting down:
+ * cleanup();
+ * ```
+ */
+declare function registerSessionDiscoveredHandler(bus: IMakaioBus): () => void;
+//#endregion
+//#region services/core/src/session/import/lineage-utils.d.ts
+/**
+ * Maps adapter-level session lineage kind to Makaio session branch kind.
+ * Root sessions have no branch kind (undefined).
+ * @param kind - The adapter session's lineage kind
+ * @returns The corresponding BranchKind, or undefined for root sessions
+ */
+declare function kindToBranchKind(kind: SessionLineageKind): BranchKind | undefined;
+/**
+ * Convert lineage metadata to a canonical `SessionLineage` discriminated union.
+ * @param metadata - Object with kind, parentAdapterSessionId, and forkPointMessageId
+ * @returns Canonical lineage object matching session contracts
+ */
+declare function toSessionLineage(metadata: {
+  kind: SessionLineageKind;
+  parentAdapterSessionId: string | null;
+  forkPointMessageId: string | null;
+}): SessionLineage;
+//#endregion
+//#region services/core/src/session/context/types.d.ts
+/**
+ * Options for building session context.
+ */
+interface BuildContextOptions {
+  /** Session ID to build context for */
+  sessionId: string;
+  /** Maximum messages to return (for token budgeting, default: no limit) */
+  limit?: number;
+}
+/**
+ * Result of context assembly.
+ */
+interface ContextAssemblyResult {
+  /** Assembled messages in chronological order */
+  messages: SessionMessage[];
+  /** Whether a squash boundary was encountered */
+  hasSquashBoundary: boolean;
+  /** Sessions traversed (for debugging) */
+  sessionChain: string[];
+  /** Whether results were truncated due to limit or pagination */
+  truncated: boolean;
+  /** Whether parent chain is incomplete (missing session in ancestry) */
+  incomplete: boolean;
+}
+//#endregion
+//#region services/core/src/session/context/build-context.d.ts
+/**
+ * Build context for a single session by walking session_events.
+ *
+ * Respects squash boundaries: if a squash event is encountered,
+ * messages before it are replaced with the summary.
+ * Paginates through all events until no more cursors or message limit is reached.
+ * @param bus - Bus instance for RPC calls
+ * @param options - Build context options
+ * @returns Assembled context result
+ */
+declare function buildSessionContext(bus: IMakaioBus, options: BuildContextOptions): Promise<ContextAssemblyResult>;
+//#endregion
+//#region services/core/src/session/context/get-full-conversation.d.ts
+/**
+ * Get full conversation for a session, traversing parent chain.
+ *
+ * For forked sessions, this walks up the parent chain and assembles
+ * messages from each ancestor, respecting forkPointMessageId boundaries.
+ *
+ * IMPORTANT: forkPointMessageId must be a Makaio message ID (not adapter ID).
+ * Normalization happens at adapter session link time.
+ * @param bus - Bus instance for RPC calls
+ * @param sessionId - Session to get conversation for
+ * @returns Full conversation with lineage
+ */
+declare function getFullConversation(bus: IMakaioBus, sessionId: string): Promise<ContextAssemblyResult>;
+//#endregion
+export { registerMemoryAgentStorage as $, registerDrizzleImportCursorStorage as A, buildRecoveryContext as At, SessionPreviewMaps as B, AdapterRegistry as Bt, registerMemoryMessageStorage as C, buildTurnInitiator as Ct, turns as D, ensureAgentModel as Dt, SelectTurn as E, ensureAgentCwd as Et, registerDrizzleSessionEventStorage as F, getOrCreateSession as Ft, SearchSessionRow as G, mapAgentsBySession as H, SessionOrchestrator as Ht, registerMemorySessionEventStorage as I, resolveTargetAgents as It, fetchPreviewBySession as J, fetchAgentsBySession as K, InsertSessionEvent as L, extractTextContent as Lt, EventTransform as M, resolveExecutionTarget as Mt, SessionLogger as N, resolveModelCapabilities as Nt, registerMemoryTurnStorage as O, recoverAgent as Ot, SessionLoggerOptions as P, findTurnByAgent as Pt, registerDrizzleAgentStorage as Q, SelectSessionEvent as R, normalizeToBlocks as Rt, messages as S, SessionContextWindowState as St, InsertTurn as T, buildRecoveryContextWithPipeline as Tt, mapToSession as U, registerCoreSessionServiceHandlers as Ut, fetchSessionPreviewMaps as V, ISessionOrchestrator as Vt, SearchFilters as W, MakaioSessionService as Wt, parseForkTransforms as X, mapRowToSession as Y, registerFtsSearchHandler as Z, registerDrizzleMessageRoutingStorage as _, registerGetStatusCountsHandler as _t, kindToBranchKind as a, createSessionExtensionContext as at, InsertMessage as b, AgentContextState as bt, registerSpawningToolCallResolver as c, FallbackRuntimeOptions as ct, MakaioSession as d, normalizeSelectionString as dt, registerDrizzleSessionStorage as et, MakaioSessionConfig as f, resolveAdapterNameById as ft, messageRouting as g, actionRegistry as gt, SelectMessageRouting as h, resetBuiltInActionsRegistration as ht, ContextAssemblyResult as i, SessionExtensionContextImpl as it, importCursors as j, resolveAdapterId as jt, registerDrizzleTurnStorage as k, verifyAndRecoverAgents as kt, registerCompressLineageResolver as l, pickFallbackRuntimeOptions as lt, InsertMessageRouting as m, registerBuiltInActions as mt, buildSessionContext as n, AgentStorageNamespace as nt, toSessionLineage as o, SessionBridge as ot, StartTurnOptions as p, registerListActionsHandler as pt, fetchMessageCountsBySession as q, BuildContextOptions as r, AgentStorageSubjects as rt, registerSessionDiscoveredHandler as s, assembleForkContext as st, getFullConversation as t, registerMemorySessionStorage as tt, registerParentResolver as u, CONNECTOR_SWAP_DEFAULT_PIPELINE as ut, MessageRoutingNamespace as v, registerResumeHandler as vt, registerDrizzleMessageStorage as w, RecoveryConfig as wt, SelectMessage as x, ContextWindowTrackerConfig as xt, MessageRoutingSubjects as y, ContextWindowTracker as yt, sessionEvents as z, TurnContextEnricher as zt };