@makaio/framework 1.0.0-dev-1779046984397

package/dist/index-C_kS2aqV2.d.mts

@@ -0,0 +1,438 @@
+import { IMakaioBus } from "@makaio/framework/bus";
+import { IMakaioSession, MakaioSessionAgent, Message, MessageInput, SessionContext, TurnInitiator } from "@makaio/framework/contracts";
+
+//#region packages/services/core/src/session/entities/turn.d.ts
+/**
+ * Result of a completed turn.
+ */
+interface TurnResult {
+  /** Whether all agents completed successfully */
+  success: boolean;
+  /** Error messages from agents that failed */
+  errors: string[];
+}
+/**
+ * State change returned by Turn mutation methods.
+ * Orchestrator uses this to decide whether to emit turn.completed.
+ */
+type TurnStateChange = {
+  turnComplete: false;
+} | {
+  turnComplete: true;
+  result: TurnResult;
+};
+/**
+ * Context for dispatching messages to agents.
+ * Passed to agent.sendMessage for context propagation.
+ */
+interface TurnContext {
+  /** Turn identifier */
+  turnId: string;
+  /** Current/latest message ID in this turn */
+  messageId: string;
+}
+/**
+ * Configuration for creating a Turn.
+ */
+interface TurnConfig {
+  /** Session this turn belongs to */
+  sessionId: string;
+  /** Agents participating in this turn */
+  agentIds: string[];
+  /** Monotonic per-session ordinal (1-based), assigned by turn storage. */
+  turnNumber: number;
+  /** Optional turn ID (generated if not provided) */
+  turnId?: string;
+  /** Optional start timestamp (defaults to Date.now()) */
+  startedAt?: number;
+  /** Origin of this turn (for loop prevention and audit). Defaults to user-initiated. */
+  initiator?: TurnInitiator;
+}
+/**
+ * Represents a single turn in a session.
+ *
+ * A turn is a semantic bracket: user message(s) → agent response(s).
+ * Turn encapsulates state and logic, while SessionOrchestrator handles
+ * bus events and emissions.
+ *
+ * Design:
+ * - Immutable identity (turnId, sessionId, agentIds set at creation)
+ * - Mutable state (messages, completion tracking)
+ * - State changes return results for orchestrator to act on
+ * - No bus dependency (testable in isolation)
+ * @example
+ * ```typescript
+ * const turn = new Turn({ sessionId: 'sess1', agentIds: ['agent1', 'agent2'] });
+ * turn.addMessage('msg1');
+ *
+ * const change = turn.markAgentCompleted('agent1');
+ * // change.turnComplete === false (agent2 still pending)
+ *
+ * const change2 = turn.markAgentCompleted('agent2');
+ * // change2.turnComplete === true, change2.result.success === true
+ * ```
+ */
+declare class Turn$1 {
+  /** Unique turn identifier */
+  readonly turnId: string;
+  /** Session this turn belongs to */
+  readonly sessionId: string;
+  /** Monotonic per-session ordinal (1-based). */
+  readonly turnNumber: number;
+  /** Timestamp when turn was created */
+  readonly startedAt: number;
+  /** Origin of this turn, used for loop prevention and audit. */
+  private readonly _initiator;
+  /** Agents participating in this turn (immutable after creation) */
+  private readonly _agentIds;
+  /** Messages sent during this turn */
+  private readonly _messageIds;
+  /** Agents that have completed successfully */
+  private readonly _completedAgents;
+  /** Agents that errored (agentId → error message) */
+  private readonly _erroredAgents;
+  constructor(config: TurnConfig);
+  /**
+   * Agents participating in this turn.
+   * @returns Immutable array of agent IDs
+   */
+  get agentIds(): readonly string[];
+  /**
+   * Origin of this turn for loop prevention and audit.
+   * Returned as a defensive copy to avoid external mutation of internal state.
+   * @returns Defensive copy of turn initiator metadata
+   */
+  get initiator(): TurnInitiator;
+  /**
+   * Messages sent during this turn.
+   * @returns Immutable array of message IDs
+   */
+  get messageIds(): readonly string[];
+  /**
+   * Agents that have completed successfully.
+   * @returns Read-only set of completed agent IDs
+   */
+  get completedAgents(): ReadonlySet<string>;
+  /**
+   * Agents that errored.
+   * @returns Read-only map of agent ID to error message
+   */
+  get erroredAgents(): ReadonlyMap<string, string>;
+  /**
+   * Add a message to this turn.
+   * @param messageId - The message ID to add
+   */
+  addMessage(messageId: string): void;
+  /**
+   * Mark an agent as completed successfully.
+   * @param agentId - The agent that completed
+   * @returns State change indicating if turn is now complete
+   */
+  markAgentCompleted(agentId: string): TurnStateChange;
+  /**
+   * Mark an agent as errored.
+   * @param agentId - The agent that errored
+   * @param error - Error message
+   * @returns State change indicating if turn is now complete
+   */
+  markAgentErrored(agentId: string, error: string): TurnStateChange;
+  /**
+   * Check if an agent is part of this turn.
+   * @param agentId - The agent ID to check
+   * @returns True if agent is participating in this turn
+   */
+  hasAgent(agentId: string): boolean;
+  /**
+   * Check if the turn is complete (all agents finished).
+   * @returns True if all agents have completed or errored
+   */
+  isComplete(): boolean;
+  /**
+   * Get the turn result (only meaningful when turn is complete).
+   * @returns Turn result with success status and any errors
+   */
+  getResult(): TurnResult;
+  /**
+   * Get context for agent dispatch.
+   * Used when sending messages to agents for context propagation.
+   * @returns Turn context with turnId and current messageId
+   * @throws Error if no messages have been added yet
+   */
+  getContext(): TurnContext;
+  /**
+   * Get context for a specific message (for events emitted per-message).
+   * @param messageId - The message ID to get context for
+   * @returns Turn context with turnId and the specified messageId
+   */
+  getContextForMessage(messageId: string): TurnContext;
+  /**
+   * Check if turn should complete and return appropriate state change.
+   * @returns State change indicating completion status and result if complete
+   */
+  private checkCompletion;
+}
+//#endregion
+//#region packages/services/core/src/session/session-turn-manager.d.ts
+/**
+ * Result of a completed turn.
+ */
+interface TurnCompletionResult {
+  /** Whether all agents completed successfully. */
+  success: boolean;
+  /** Error messages from agents that failed. */
+  errors: string[];
+}
+/**
+ * Callback invoked when a turn completes (all agents finished).
+ * @param turn - The completed turn
+ * @param result - Success/error status with error messages
+ */
+type TurnCompleteCallback = (turn: Turn$1, result: TurnCompletionResult) => Promise<void>;
+/**
+ * Composable turn lifecycle manager.
+ *
+ * Owns all stateful turn tracking: active turns, usage accumulation,
+ * completion guards, and buffered-usage-during-completion. Both the
+ * framework `SessionOrchestrator` and host-provided orchestrators create their
+ * own instance.
+ *
+ * Storage calls use `bus.requestOptional` so the manager degrades
+ * gracefully in ephemeral mode (no storage handlers registered). When
+ * `TurnStorageSubjects.create` is unhandled, synthetic IDs are generated
+ * locally. When `TurnStorageSubjects.complete` is unhandled, the turn is
+ * still cleared from memory and `session.turn.completed` is emitted.
+ */
+declare class SessionTurnManager {
+  private readonly bus;
+  /** Active turns keyed by sessionId (one turn per session). */
+  private readonly activeTurns;
+  /** Per-session usage accumulators, parallel to activeTurns. */
+  private readonly usageAccumulators;
+  /** Sessions currently persisting turn completion (prevents concurrent writes). */
+  private readonly completingSessions;
+  /** Usage events received while completion persistence is in-flight. */
+  private readonly bufferedUsageDuringCompletion;
+  /**
+   * Synthetic turn number counters for ephemeral mode (no storage handlers).
+   * Keyed by sessionId, incremented on each turn creation.
+   *
+   * Intentionally never pruned: turn numbers must be monotonically increasing
+   * across all turns in a session. Pruning after a turn completes would reset
+   * the counter and cause duplicate turn numbers if the session continues.
+   */
+  private readonly syntheticTurnCounters;
+  /** Bus subscription cleanup functions. */
+  private readonly cleanups;
+  /**
+   * @param bus - Event bus used for storage RPCs and event emission
+   */
+  constructor(bus: IMakaioBus);
+  /**
+   * Create a new turn, tracking it as active.
+   *
+   * Calls `TurnStorageSubjects.create` via `requestOptional`. If no storage
+   * handler is registered (ephemeral mode), generates a synthetic UUID turn ID
+   * and a per-session incrementing turn number.
+   * @param sessionId - Session the turn belongs to
+   * @param agentIds - Agents participating in this turn
+   * @param initiator - Turn origin metadata (user, plugin, system)
+   * @param turnId - Optional pre-assigned turn ID (passed through to storage)
+   * @returns The newly created and activated Turn entity
+   */
+  createTurn(sessionId: string, agentIds: string[], initiator?: TurnInitiator, turnId?: string): Promise<Turn$1>;
+  /**
+   * Register bus listeners for `agent.usage` and `agent.complete` events.
+   *
+   * Must be called once during initialisation. The `onTurnComplete` callback
+   * is invoked when all agents in a turn have finished (success or error);
+   * typically the orchestrator passes its own `completeTurn` method.
+   * @param onTurnComplete - Callback invoked when all agents in a turn finish
+   */
+  registerCompletionHandlers(onTurnComplete: TurnCompleteCallback): void;
+  /**
+   * Complete a turn: persist via storage, emit `session.turn.completed`, clear state.
+   *
+   * A concurrent-completion guard prevents duplicate writes when two agent
+   * completions race. The second call is a no-op.
+   *
+   * Usage is snapshotted before the storage call. Any usage events that arrive
+   * while persistence is in-flight are buffered and merged into a second
+   * `TurnStorageSubjects.complete` call. State is cleared only after durable
+   * persistence succeeds; if persistence fails, the state remains intact so
+   * completion can be retried.
+   * @param turn - The turn to complete
+   * @param result - Turn result (success status and error messages)
+   */
+  completeTurn(turn: Turn$1, result: TurnCompletionResult): Promise<void>;
+  /**
+   * Get the active turn for a session, if any.
+   * @param sessionId - Session identifier
+   * @returns Active turn, or `undefined` if no turn is in progress
+   */
+  getActiveTurn(sessionId: string): Turn$1 | undefined;
+  /**
+   * Expose the active turns map for handlers that need direct access.
+   *
+   * Used by `registerAttachHandler` which tracks turns started via
+   * `session.agent.attach` (with an `initialMessage`) in the shared map so
+   * that the completion handler can detect when the attached turn finishes.
+   * @returns Reference to the internal active turns map
+   */
+  getActiveTurnsMap(): Map<string, Turn$1>;
+  /**
+   * Find an active turn by turn ID (scans all sessions).
+   *
+   * Used to correlate `agent.usage` events that carry a `turnId` rather
+   * than a `sessionId`.
+   * @param turnId - Turn identifier from an agent event payload
+   * @returns Matching active turn, or `undefined` if not found
+   */
+  findActiveTurnByTurnId(turnId: string): Turn$1 | undefined;
+  /**
+   * Cancel all bus subscriptions and clear all in-memory state.
+   *
+   * Call when the owning orchestrator is destroyed.
+   */
+  destroy(): void;
+  /**
+   * Handle an agent completing (success or error).
+   *
+   * Marks the agent on the turn, emits `user_message.completed` for each
+   * message in the turn, then calls `onTurnComplete` when all agents are done.
+   * @param agentId - The agent that completed
+   * @param success - Whether the agent completed successfully
+   * @param error - Error message if the agent failed
+   * @param onTurnComplete - Callback to invoke when the turn is complete
+   */
+  private handleAgentCompletion;
+  /**
+   * Buffer a usage event that arrived while turn completion persistence is in-flight.
+   * @param sessionId - Session whose turn is currently completing
+   * @param usageEvent - Usage event to defer until after persistence
+   */
+  private bufferUsageDuringCompletion;
+}
+//#endregion
+//#region packages/services/core/src/session/handlers/abandon-handler.d.ts
+/**
+ * Registers the session.abandon RPC handler.
+ *
+ * Abandons a child session without merging (no handoff).
+ * @param bus - Bus instance for communication
+ * @returns Cleanup function to unsubscribe
+ */
+declare function registerAbandonHandler(bus: IMakaioBus): () => void;
+//#endregion
+//#region packages/services/core/src/session/handlers/attach-handler.d.ts
+/**
+ * Registers the session.agent.attach RPC handler.
+ *
+ * Explicitly attaches a fresh agent to a session with full control over:
+ * - Role assignment (lead vs member)
+ * - Optional initial message
+ *
+ * For branching conversations (fork), use session.fork to create a new session
+ * with copied history, then attach agents to the new session.
+ * @param bus - Bus instance for communication
+ * @param activeTurns - Shared turn state map
+ * @param machineId - Optional machine ID for deterministic adapter resolution
+ * @returns Cleanup function to unsubscribe
+ */
+declare function registerAttachHandler(bus: IMakaioBus, activeTurns: Map<string, Turn$1>, machineId?: string): () => void;
+//#endregion
+//#region packages/services/core/src/session/handlers/compress-handler.d.ts
+/**
+ * Registers the session.compress RPC handler.
+ *
+ * Executes a pipeline on session messages and inserts a squash event.
+ * The squash event marks a context boundary - messages before it
+ * are summarized by the context JSON.
+ * @param bus - Bus instance
+ * @returns Cleanup function
+ */
+declare function registerCompressHandler(bus: IMakaioBus): () => void;
+//#endregion
+//#region packages/services/core/src/session/handlers/fork-handler.d.ts
+/**
+ * Registers the session.fork RPC handler.
+ *
+ * Creates a new session with parent reference. The forked session starts
+ * empty - its full conversation is assembled by traversing the parent chain.
+ * @param bus - Bus instance for communication
+ * @returns Cleanup function to unsubscribe
+ */
+declare function registerForkHandler(bus: IMakaioBus): () => void;
+//#endregion
+//#region packages/services/core/src/session/handlers/merge-handler.d.ts
+/**
+ * Registers the session.merge RPC handler.
+ *
+ * Merges a child session's work back into parent with a handoff summary.
+ * @param bus - Bus instance for communication
+ * @returns Cleanup function to unsubscribe
+ */
+declare function registerMergeHandler(bus: IMakaioBus): () => void;
+//#endregion
+//#region packages/services/core/src/session/handlers/route-to-agents.d.ts
+/**
+ * Interface for turn context enrichment.
+ * Implemented by TurnContextEnricher in orchestration package.
+ */
+interface ITurnContextEnricher {
+  enrichForDeliveryMode(originalHistory: Message[] | undefined, turnId: string, deliveryMode: 'enqueue' | 'immediate' | 'replace' | undefined): Promise<Message[] | undefined>;
+}
+interface CwdSwapMeta {
+  previousCwd: string;
+  newCwd: string;
+}
+/**
+ * Route a message to target agents via agent.sendMessage.
+ *
+ * Fans out to all agents in parallel. On routing failure, marks agent as errored
+ * and checks for turn completion.
+ *
+ * For fork sessions on their first turn, assembles projected context from parent chain.
+ * @param bus - Bus instance for communication
+ * @param session - Session metadata (for fork detection)
+ * @param agents - Target agents to route to
+ * @param message - Message content to send
+ * @param messageId - Message identifier
+ * @param turn - Turn tracking object
+ * @param deliveryMode - How to deliver the message
+ * @param onTurnComplete - Callback when turn completes (all agents done)
+ * @param sessionContext - Session context with curated messageHistory and decision signals
+ * @param turnContextEnricher - Optional enricher for immediate message context
+ * @param isNewTurn - Whether this is the first message in a new turn
+ * @param recoveryContext - Context enriched with messageHistory for agents that were just recovered
+ * @param recoveredAgentIds - Set of agent IDs that were recovered in this handler invocation
+ * @param swappedAgentIds - Set of agent IDs that swapped connector due to cwd mismatch
+ * @param swappedAgentCwd - Previous/new cwd metadata keyed by agent ID
+ * @param freshMessageHistory - Curated history for agents forced into fresh mode
+ * @param responseSchema - Optional JSON schema for structured responses
+ */
+declare function routeToAgents(bus: IMakaioBus, session: IMakaioSession, agents: MakaioSessionAgent[], message: MessageInput, messageId: string, turn: Turn$1, deliveryMode: 'enqueue' | 'immediate' | undefined, onTurnComplete: (turn: Turn$1, result: {
+  success: boolean;
+  errors: string[];
+}) => Promise<void>, sessionContext?: SessionContext, turnContextEnricher?: ITurnContextEnricher, isNewTurn?: boolean, recoveryContext?: SessionContext, recoveredAgentIds?: ReadonlySet<string>, swappedAgentIds?: ReadonlySet<string>, swappedAgentCwd?: ReadonlyMap<string, CwdSwapMeta>, freshMessageHistory?: Message[], responseSchema?: Record<string, unknown>): Promise<void>;
+//#endregion
+//#region packages/services/core/src/session/handlers/route-to-agents-core.d.ts
+/**
+ * Route a message to target agents using a single shared session context.
+ *
+ * Fans out to all agents in parallel. On routing failure, marks the agent
+ * as errored and checks for turn completion. On `HookAbortError`, marks
+ * the agent as completed with `cancelled` outcome.
+ * @param bus - Bus instance for communication
+ * @param session - Session metadata (for session ID)
+ * @param agents - Target agents to route to
+ * @param message - Message content to send
+ * @param messageId - Message identifier
+ * @param turn - Turn tracking object
+ * @param deliveryMode - How to deliver the message to the agent
+ * @param onTurnComplete - Callback invoked when the turn completes (all agents done)
+ * @param sessionContext - Optional shared session context forwarded to all agents
+ * @param responseSchema - Optional JSON schema for structured responses
+ */
+declare function routeToAgentsCore(bus: IMakaioBus, session: IMakaioSession, agents: MakaioSessionAgent[], message: MessageInput, messageId: string, turn: Turn$1, deliveryMode: 'enqueue' | 'immediate' | undefined, onTurnComplete: TurnCompleteCallback, sessionContext?: SessionContext, responseSchema?: Record<string, unknown>): Promise<void>;
+//#endregion
+export { registerCompressHandler as a, SessionTurnManager as c, Turn$1 as d, TurnConfig as f, TurnStateChange as h, registerForkHandler as i, TurnCompleteCallback as l, TurnResult as m, routeToAgents as n, registerAttachHandler as o, TurnContext as p, registerMergeHandler as r, registerAbandonHandler as s, routeToAgentsCore as t, TurnCompletionResult as u };

package/dist/index-Ch3ph52M2.d.mts

@@ -0,0 +1,40 @@
+import { IMakaioBus } from "@makaio/framework/bus";
+import { ProviderContext } from "@makaio/framework/contracts";
+
+//#region packages/services/core/src/provider-context/build-provider-context.d.ts
+/**
+ * Resolve the bus-safe provider context via the adapter subsystem subject.
+ *
+ * The adapter subsystem owns the canonical provider-context assembly. This
+ * helper keeps framework consumers on that seam while preserving the local
+ * error contract for missing provider configs.
+ * @param bus - Bus instance used to request the subsystem subject
+ * @param providerConfigId - Provider config identifier to resolve
+ * @returns Unresolved provider context with credential refs
+ * @throws Error when the config cannot be found
+ */
+declare function buildProviderContext(bus: IMakaioBus, providerConfigId: string): Promise<ProviderContext>;
+//#endregion
+//#region packages/services/core/src/provider-context/activate-provider-context.d.ts
+/**
+ * Fire the credential activation hook for a provider context.
+ *
+ * Callers await this before starting an adapter so extensions such as
+ * account-manager can prepare native credential stores ahead of connector-side
+ * resolution. Missing handlers are treated as a no-op and handler failures are
+ * intentionally suppressed because activation must not block agent startup.
+ * @param bus - Bus used to invoke the activation hook
+ * @param providerContext - Provider context whose refs should be activated
+ */
+declare function activateProviderContext(bus: IMakaioBus, providerContext: ProviderContext): Promise<void>;
+/**
+ * Fire the credential activation hook and propagate failures.
+ *
+ * Rotation paths use this stricter variant so a failed native-store update does
+ * not report a successful credential swap.
+ * @param bus - Bus used to invoke the activation hook
+ * @param providerContext - Provider context whose refs should be activated
+ */
+declare function activateProviderContextStrict(bus: IMakaioBus, providerContext: ProviderContext): Promise<void>;
+//#endregion
+export { activateProviderContextStrict as n, buildProviderContext as r, activateProviderContext as t };

package/dist/index-CnZOKNjU.d.mts

@@ -0,0 +1,89 @@
+import { n as ResolveIdRequest } from "./schemas-Di0XnnMX.mjs";
+import { IMakaioBus } from "@makaio/framework/bus";
+
+//#region packages/services/core/src/adapter-runtime/identity.d.ts
+/**
+ * Build the deterministic runtime adapter id for a machine-local adapter.
+ * @param machineId - Runtime machine identifier.
+ * @param adapterName - Stable adapter driver name.
+ * @returns Deterministic UUID-shaped runtime adapter id.
+ */
+declare function buildDeterministicAdapterId(machineId: string, adapterName: string): string;
+/**
+ * Resolve an adapter id request against the current runtime machine.
+ * @param request - Forward lookup payload.
+ * @param currentMachineId - Runtime-default machine identifier.
+ * @returns Deterministic UUID-shaped runtime adapter id.
+ */
+declare function resolveDeterministicAdapterId(request: ResolveIdRequest, currentMachineId?: string): string;
+/**
+ * Service-lifetime adapter identity index.
+ */
+declare class AdapterIdentityRegistry {
+  private readonly currentMachineId?;
+  private readonly adapterNamesById;
+  private localAdapterIds;
+  /**
+   * Create a new identity registry.
+   * @param currentMachineId - Runtime-default machine identifier.
+   */
+  constructor(currentMachineId?: string | undefined);
+  /**
+   * Replace the set of locally known adapters while preserving remote ids
+   * already resolved during this service lifetime.
+   * @param adapterNames - Current local adapter names.
+   */
+  replaceKnownAdapterNames(adapterNames: Iterable<string>): void;
+  /**
+   * Resolve and remember an adapter id.
+   * @param request - Forward lookup payload.
+   * @returns Deterministic runtime adapter id.
+   */
+  resolveId(request: ResolveIdRequest): string;
+  /**
+   * Remember a resolved adapter id without re-deriving it.
+   * @param adapterId - Runtime adapter id.
+   * @param adapterName - Stable adapter driver name.
+   */
+  rememberAdapterId(adapterId: string, adapterName: string): void;
+  /**
+   * Resolve a runtime adapter id back to its known adapter name.
+   * @param adapterId - Runtime adapter id.
+   * @returns Adapter name when known.
+   */
+  resolveAdapterName(adapterId: string): string | undefined;
+  /**
+   * Hydrate local deterministic adapter names from the provided catalog and
+   * retry the reverse lookup.
+   * @param adapterId - Runtime adapter id to resolve.
+   * @param listKnownAdapterNames - Canonical name supplier.
+   * @returns Adapter name when known after hydration.
+   */
+  resolveAdapterNameFromKnownNames(adapterId: string, listKnownAdapterNames: () => Promise<Iterable<string>>): Promise<string | undefined>;
+  /**
+   * Clear all remembered ids.
+   */
+  clear(): void;
+}
+/**
+ * Registered adapter identity helpers for tests and lightweight hosts.
+ */
+interface RegisteredAdapterRuntimeIdentityHandlers {
+  /** Mutable identity registry backing the registered handlers. */
+  readonly registry: AdapterIdentityRegistry;
+  /** Cleanup function that unregisters the handlers. */
+  readonly cleanup: () => void;
+}
+/**
+ * Register runtime adapter identity handlers.
+ * @param bus - Bus instance used for registration.
+ * @param options - Runtime identity configuration.
+ * @returns Registry instance and cleanup function.
+ */
+declare function registerAdapterRuntimeIdentityHandlers(bus: IMakaioBus, options?: {
+  currentMachineId?: string;
+  knownAdapterNames?: Iterable<string>;
+  listKnownAdapterNames?: () => Promise<Iterable<string>>;
+}): RegisteredAdapterRuntimeIdentityHandlers;
+//#endregion
+export { resolveDeterministicAdapterId as a, registerAdapterRuntimeIdentityHandlers as i, RegisteredAdapterRuntimeIdentityHandlers as n, buildDeterministicAdapterId as r, AdapterIdentityRegistry as t };

package/dist/index-D1T-PPqF.d.mts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+
+//#region packages/services/log-import/src/schemas/mode.d.ts
+/**
+ * Tri-state import mode for external session discovery.
+ *
+ * - `disabled`: No scanning or import
+ * - `discover`: Shallow scan creates stubs in session list (lazy-load on demand)
+ * - `import`: Full import of all sessions and messages
+ */
+declare const LogImportModeSchema: z.ZodEnum<{
+  disabled: "disabled";
+  discover: "discover";
+  import: "import";
+}>;
+/** Tri-state import mode for external session discovery. */
+type LogImportMode = z.infer<typeof LogImportModeSchema>;
+/**
+ * Persisted settings shape for the `log_import_settings` table.
+ *
+ * Represents a global (adapter-level) import mode row. Project-scoped settings
+ * live in the host-owned `log_import_scoped_settings` table and are not
+ * represented here.
+ */
+declare const LogImportSettingsSchema: z.ZodObject<{
+  adapterName: z.ZodString;
+  mode: z.ZodEnum<{
+    disabled: "disabled";
+    discover: "discover";
+    import: "import";
+  }>;
+  createdAt: z.ZodNumber;
+  updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * Persisted settings shape for the `log_import_settings` table.
+ *
+ * Represents a global (adapter-level) import mode row.
+ */
+type LogImportSettings = z.infer<typeof LogImportSettingsSchema>;
+//#endregion
+//#region packages/services/log-import/src/schemas/settings.d.ts
+/**
+ * Category key for last scan timestamp in preferences storage.
+ * Separate from settings to avoid read-modify-write race conditions.
+ */
+declare const IMPORT_LAST_SCAN_CATEGORY = "import-last-scan";
+//#endregion
+//#region packages/services/log-import/src/schemas/list-importers.d.ts
+/**
+ * Information about a registered log importer.
+ */
+declare const LogImporterInfoSchema: z.ZodObject<{
+  id: z.ZodString;
+  adapterName: z.ZodString;
+  displayName: z.ZodString;
+  source: z.ZodEnum<{
+    adapter: "adapter";
+    extension: "extension";
+  }>;
+  logFilePattern: z.ZodString;
+  isRunning: z.ZodBoolean;
+  supportsManualImport: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type LogImporterInfo = z.infer<typeof LogImporterInfoSchema>;
+//#endregion
+export { LogImportSettings as i, IMPORT_LAST_SCAN_CATEGORY as n, LogImportMode as r, LogImporterInfo as t };