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

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

@@ -2059,7 +2059,7 @@ declare const sessionStorageSchema: _$_makaio_storage_drizzle0.DialectSchema<{
         tableName: "sessions";
         dataType: "string";
         columnType: "SQLiteText";
-        data: "fork" | "subagent" | "compress" | "branch" | "rewrite" | "coordinator" | "aside";
+        data: "fork" | "subagent" | "branch" | "compress" | "rewrite" | "coordinator" | "aside";
         driverParam: string;
         notNull: false;
         hasDefault: false;
@@ -3733,6 +3733,194 @@ declare const LogImportTriggerSubjects: _$_makaio_core0.BusSubjects<_$_makaio_co
  * @returns True when content import must be suppressed
  */
 declare function isPolicyDiscoveredObservedSession(session: Pick<IMakaioSession, 'clientId' | 'importStatus'>): boolean;
+/**
+ * Check whether a stored session is a hook-first tracking stub.
+ *
+ * A tracking stub is the session row created by
+ * `ObservedSessionIngestionService.handleSessionStarted` when the
+ * `SessionStart` hook fires before the suppression gate is populated.
+ * Its fingerprint is:
+ * - `isImported: true` (set by `importUpsert`)
+ * - `importStatus: 'tracking'` (live-followed observed session)
+ * - `clientId` is present (hook-observed, not watcher-discovered)
+ *
+ * This predicate is the single source of truth for stub identification
+ * across reconciliation and diagnostic paths. Externally observed
+ * terminal sessions share this fingerprint, but they never trigger
+ * `client.runtime.started` — the caller discriminates by context.
+ * @param session - Stored session row to inspect
+ * @returns True when the session matches the tracking-stub fingerprint
+ */
+declare function isTrackingStub(session: Pick<IMakaioSession, 'isImported' | 'importStatus' | 'clientId'>): boolean;
+/**
+ * Bridges observed client sessions into the canonical session model.
+ *
+ * Responsibilities:
+ * - Register observed sessions on `client.session.started` through the
+ *   unified registration seam (`storage:session.importUpsert`), keyed on the
+ *   importer's adapter name so hook-first registration and later transcript
+ *   imports converge on the same `(source, adapterSessionId)` identity.
+ * - Trigger targeted transcript imports on `client.session.turn.completed`
+ *   (`log-import.importFile` when the transcript path is known, discovery
+ *   fallback via `log-import.importSession` otherwise).
+ * - Suppress all work for adapter-managed sessions: sessions the managed
+ *   orchestration path drives already flow through the orchestrator and must
+ *   not be double-ingested (gate fed by `client.runtime.started`).
+ *
+ * Non-responsibilities:
+ * - Holds NO turn state — turn boundaries and content come exclusively from
+ *   the transcript reconstruction during import (design Principle 4).
+ * - Never emits `session.*` subjects itself — the turn lifecycle ingestion
+ *   seam is the single emitter (design Principle 2).
+ *
+ * The component is client-agnostic: client and importer identities come from
+ * event payloads and the log-import registry, never from hard-coded client
+ * ids. A single subscription per subject on the global `client` namespace
+ * covers every emitting client; `clientId` in the payload is the
+ * discriminator. When no log-import service or no matching importer is
+ * registered (framework-only mode), all work is skipped silently.
+ */
+declare class ObservedSessionIngestionService {
+  private readonly bus;
+  /**
+   * Adapter session IDs owned by the managed orchestration path.
+   *
+   * FIFO-capped at {@link MANAGED_SESSION_CAP}; insertion order is the
+   * eviction order (mirrors the client services' gate).
+   */
+  private readonly managedAdapterSessionIds;
+  /**
+   * Importer resolutions per client id.
+   *
+   * Importers register at boot and do not un-register mid-session, so this
+   * cache (including misses) is valid for the lifetime of the service instance.
+   */
+  private readonly importerByClientId;
+  /** Client ids already debug-logged as unresolvable (one log per client id). */
+  private readonly unresolvedClientIds;
+  /** Registered optional policy providers; deny/discovered decisions win. */
+  private readonly policyProviders;
+  private readonly cleanups;
+  /**
+   * Create the service and subscribe to the observed-session subjects.
+   * @param bus - Application bus instance
+   */
+  constructor(bus?: IMakaioBus);
+  /** Unsubscribe all bus handlers. */
+  destroy(): void;
+  /**
+   * Record adapter-managed sessions in the suppression gate and reconcile
+   * any hook-first tracking stub.
+   *
+   * Unlike the per-client gates inside the client services, this component
+   * does not filter by `clientId`: it is client-agnostic, and an adapter
+   * session ID marked as managed must suppress observed ingestion regardless
+   * of which client runtime reported it. Non-adapter source layers (e.g.
+   * `'supervisor'`, `'statusline'`) never suppress — they observe sessions
+   * the managed path does not own.
+   *
+   * **Stub reconciliation:** When the `SessionStart` hook fires before this
+   * gate is populated (hook-first ingestion race), `handleSessionStarted`
+   * creates a tracking stub via `importUpsert`. This stub and the live
+   * session row coexist as duplicates. `client.runtime.started` is the
+   * authoritative, guaranteed-to-arrive signal that the adapter session is
+   * managed. On arrival, any existing tracking stub for the same
+   * `(source, adapterSessionId)` is reconciled: deleted when inert, or
+   * preserved when it already carries imported messages (native takeover
+   * of an externally observed session — see the content guard below).
+   *
+   * Externally observed terminal sessions share the same storage fingerprint
+   * (`isImported: true`, `importStatus: 'tracking'`, `clientId` set) but
+   * never trigger `client.runtime.started` for their `adapterSessionId` —
+   * they are observed via hooks only, without a `client.runtime.observe`
+   * preceding them. Therefore `client.runtime.started` itself is the
+   * discriminator: if we receive it for an adapterSessionId, the session is
+   * adapter-managed and any tracking stub is a racy artifact.
+   * @param payload - `client.runtime.started` payload
+   */
+  private handleRuntimeStarted;
+  /**
+   * Reconcile a hook-first tracking stub for a managed adapter session.
+   *
+   * Looks up a tracking stub by `(source, adapterSessionId)` and deletes it
+   * when it carries no imported messages (pure race artifact). Stubs with
+   * content are preserved (native takeover of an externally observed session).
+   * When message storage is unavailable (unhandled lookup), the stub is
+   * preserved defensively to avoid data loss.
+   *
+   * Called from two sites to close the in-flight importUpsert window:
+   * - `handleRuntimeStarted`: runtime side adds to gate, then reconciles.
+   * - `handleSessionStarted`: hook side writes storage, then reconciles
+   *   (post-upsert double-check when the gate was populated concurrently).
+   * @param clientId - Client identity for importer resolution
+   * @param adapterSessionId - External adapter session ID to reconcile
+   */
+  private reconcileTrackingStub;
+  /**
+   * Resolve the log-import importer responsible for a client's sessions.
+   *
+   * Bridges the correlation gap between hook identity and import identity:
+   * hooks report the client id (e.g. `'claude-code'`) while the import path
+   * keys sessions on the importer's adapter name. Registrations advertise
+   * their `clientId` via `log-import.listImporters`.
+   *
+   * Graceful absence: `null` means framework-only mode (no log-import
+   * service, or no importer registered for this client) — callers skip
+   * silently. At most one debug log is emitted per unresolved client id.
+   * @param clientId - Stable client id from the observed event payload
+   * @returns Importer adapter name, or `null` when no importer is registered
+   */
+  private resolveImporter;
+  /**
+   * Debug-log an unresolved client id at most once.
+   * @param clientId - Client id that could not be resolved to an importer
+   * @param reason - Why resolution failed
+   */
+  private debugUnresolved;
+  /**
+   * Register an observed session through the unified registration seam.
+   *
+   * Skipped for managed sessions and when no importer is resolvable — a
+   * session that can never receive imported content must not create a
+   * dangling stub. The registration `source` is the importer's adapter name,
+   * NOT the raw client id: the `(source, adapterSessionId)` upsert key must
+   * match what the import path writes, otherwise hook-first registration
+   * would fork the session identity and every import would create a
+   * duplicate session.
+   * @param payload - `client.session.started` payload
+   */
+  private handleSessionStarted;
+  /**
+   * Trigger a targeted transcript import for a completed observed turn.
+   *
+   * Preferred trigger: `log-import.importFile` with the transcript path from
+   * the hook payload (no prior discovery stub required). Fallback when the
+   * payload carries no path: `log-import.importSession`, which requires an
+   * existing discovery stub and throws otherwise — tolerated and
+   * debug-logged, because the polling watcher ingests the turn on its next
+   * pass either way. If hook payloads prove to lack the transcript path at
+   * fire time in practice, resolving the path from the statusline cache is
+   * the candidate follow-up seam.
+   * @param payload - `client.session.turn.completed` payload
+   */
+  private handleTurnCompleted;
+  /**
+   * Evaluate registered policy providers for an observed session.
+   *
+   * No provider means the current default: content tracking. When multiple
+   * providers are present, `discovered` wins so independent policy modules can
+   * only restrict content import, not override each other's deny decisions.
+   * @param input - Observed session identity and importer context
+   * @returns Import status for the registration
+   */
+  private decideImportStatus;
+  /**
+   * Determine whether a completed observed turn may trigger content import.
+   * @param input - Observed turn identity and importer context
+   * @returns True when content import should run
+   */
+  private shouldImportObservedContent;
+}
 //#endregion
 //#region services/core/src/session/observed-session-ingestion-policy.d.ts
 /** Capability id used for observed-session ingestion policy providers. */
@@ -5416,4 +5604,4 @@ interface NativeLocalityInput {
  */
 declare function evaluateNativeLocality(input: NativeLocalityInput): NativeLocalityVerdict;
 //#endregion
-export { SessionLifecycleEventArgs as $, recoverAgent as $t, SelectTurn as A, createSessionExtensionContext as At, OBSERVED_SESSION_INGESTION_POLICY_CAPABILITY_ID as B, resetBuiltInActionsRegistration as Bt, MessageRoutingSubjects as C, registerDrizzleAgentStorage as Ct, registerMemoryMessageStorage as D, AgentStorageNamespace as Dt, messages as E, registerMemorySessionStorage as Et, EmbeddingIndexManager as F, CONNECTOR_SWAP_DEFAULT_PIPELINE as Ft, unregisterObservedSessionIngestionPolicyProvider as G, AgentContextState as Gt, ObservedSessionIngestionPolicyImportStatus as H, registerGetStatusCountsHandler as Ht, registerDrizzleImportCursorStorage as I, normalizeSelectionString as It, IngestCompletedTurnParams as J, buildTurnInitiator as Jt, LogImportTriggerSubjects as K, ContextWindowTrackerConfig as Kt, importCursors as L, resolveAdapterNameById as Lt, turnsDual as M, assembleForkContext as Mt, registerMemoryTurnStorage as N, FallbackRuntimeOptions as Nt, registerDrizzleMessageStorage as O, AgentStorageSubjects as Ot, registerDrizzleTurnStorage as P, pickFallbackRuntimeOptions as Pt, EventTransform as Q, ensureAgentModel as Qt, importCursorsDual as R, registerListActionsHandler as Rt, MessageRoutingNamespace as S, registerFtsSearchHandler as St, SelectMessage as T, registerDrizzleSessionStorage as Tt, ObservedSessionIngestionPolicyInput as U, registerResumeHandler as Ut, ObservedSessionIngestionPolicyDecision as V, actionRegistry as Vt, registerObservedSessionIngestionPolicyProvider as W, ContextWindowTracker as Wt, IngestTurnMessage as X, buildRecoveryContextWithPipeline as Xt, IngestCompletedTurnResult as Y, RecoveryConfig as Yt, ingestCompletedTurn as Z, ensureAgentCwd as Zt, InsertMessageRouting as _, fetchAgentsBySession as _t, buildSessionContext as a, findTurnByAgent as an, registerMemorySessionEventStorage as at, messageRoutingDual as b, mapRowToSession as bt, kindToBranchKind as c, extractTextContent as cn, sessionEvents as ct, registerSpawningToolCallResolver as d, AdapterRegistry as dn, SessionPreviewMaps as dt, verifyAndRecoverAgents as en, SessionTurnStartedPayload as et, registerCompressLineageResolver as f, ISessionOrchestrator as fn, fetchSessionPreviewMaps as ft, StartTurnOptions as g, SearchSessionRow as gt, MakaioSessionConfig as h, MakaioSessionService as hn, SearchFilters as ht, getFullConversation as i, resolveModelCapabilities as in, registerDrizzleSessionEventStorage as it, turns as j, SessionBridge as jt, InsertTurn as k, SessionExtensionContextImpl as kt, toSessionLineage as l, normalizeToBlocks as ln, sessionEventsDual as lt, MakaioSession as m, registerCoreSessionServiceHandlers as mn, mapToSession as mt, NativeLocalityIntent as n, resolveAdapterId as nn, emitSessionTurnStarted as nt, BuildContextOptions as o, getOrCreateSession as on, InsertSessionEvent as ot, registerParentResolver as p, SessionOrchestrator as pn, mapAgentsBySession as pt, isPolicyDiscoveredObservedSession as q, SessionContextWindowState as qt, evaluateNativeLocality as r, resolveExecutionTarget as rn, registerSessionLifecycleEventWriters as rt, ContextAssemblyResult as s, resolveTargetAgents as sn, SelectSessionEvent as st, NativeLocalityInput as t, buildRecoveryContext as tn, appendSessionLifecycleEvent as tt, registerSessionDiscoveredHandler as u, TurnContextEnricher as un, getSessionAncestorChain as ut, SelectMessageRouting as v, fetchMessageCountsBySession as vt, InsertMessage as w, registerMemoryAgentStorage as wt, registerDrizzleMessageRoutingStorage as x, parseForkTransforms as xt, messageRouting as y, fetchPreviewBySession as yt, IObservedSessionIngestionPolicyProvider as z, registerBuiltInActions as zt };
+export { ingestCompletedTurn as $, ensureAgentCwd as $t, SelectTurn as A, AgentStorageSubjects as At, OBSERVED_SESSION_INGESTION_POLICY_CAPABILITY_ID as B, registerListActionsHandler as Bt, MessageRoutingSubjects as C, parseForkTransforms as Ct, registerMemoryMessageStorage as D, registerDrizzleSessionStorage as Dt, messages as E, registerMemoryAgentStorage as Et, EmbeddingIndexManager as F, FallbackRuntimeOptions as Ft, unregisterObservedSessionIngestionPolicyProvider as G, registerResumeHandler as Gt, ObservedSessionIngestionPolicyImportStatus as H, resetBuiltInActionsRegistration as Ht, registerDrizzleImportCursorStorage as I, pickFallbackRuntimeOptions as It, isPolicyDiscoveredObservedSession as J, ContextWindowTrackerConfig as Jt, LogImportTriggerSubjects as K, ContextWindowTracker as Kt, importCursors as L, CONNECTOR_SWAP_DEFAULT_PIPELINE as Lt, turnsDual as M, createSessionExtensionContext as Mt, registerMemoryTurnStorage as N, SessionBridge as Nt, registerDrizzleMessageStorage as O, registerMemorySessionStorage as Ot, registerDrizzleTurnStorage as P, assembleForkContext as Pt, IngestTurnMessage as Q, buildRecoveryContextWithPipeline as Qt, importCursorsDual as R, normalizeSelectionString as Rt, MessageRoutingNamespace as S, mapRowToSession as St, SelectMessage as T, registerDrizzleAgentStorage as Tt, ObservedSessionIngestionPolicyInput as U, actionRegistry as Ut, ObservedSessionIngestionPolicyDecision as V, registerBuiltInActions as Vt, registerObservedSessionIngestionPolicyProvider as W, registerGetStatusCountsHandler as Wt, IngestCompletedTurnParams as X, buildTurnInitiator as Xt, isTrackingStub as Y, SessionContextWindowState as Yt, IngestCompletedTurnResult as Z, RecoveryConfig as Zt, InsertMessageRouting as _, MakaioSessionService as _n, SearchFilters as _t, buildSessionContext as a, resolveExecutionTarget as an, registerSessionLifecycleEventWriters as at, messageRoutingDual as b, fetchMessageCountsBySession as bt, kindToBranchKind as c, getOrCreateSession as cn, InsertSessionEvent as ct, registerSpawningToolCallResolver as d, normalizeToBlocks as dn, sessionEventsDual as dt, ensureAgentModel as en, EventTransform as et, registerCompressLineageResolver as f, TurnContextEnricher as fn, getSessionAncestorChain as ft, StartTurnOptions as g, registerCoreSessionServiceHandlers as gn, mapToSession as gt, MakaioSessionConfig as h, SessionOrchestrator as hn, mapAgentsBySession as ht, getFullConversation as i, resolveAdapterId as in, emitSessionTurnStarted as it, turns as j, SessionExtensionContextImpl as jt, InsertTurn as k, AgentStorageNamespace as kt, toSessionLineage as l, resolveTargetAgents as ln, SelectSessionEvent as lt, MakaioSession as m, ISessionOrchestrator as mn, fetchSessionPreviewMaps as mt, NativeLocalityIntent as n, verifyAndRecoverAgents as nn, SessionTurnStartedPayload as nt, BuildContextOptions as o, resolveModelCapabilities as on, registerDrizzleSessionEventStorage as ot, registerParentResolver as p, AdapterRegistry as pn, SessionPreviewMaps as pt, ObservedSessionIngestionService as q, AgentContextState as qt, evaluateNativeLocality as r, buildRecoveryContext as rn, appendSessionLifecycleEvent as rt, ContextAssemblyResult as s, findTurnByAgent as sn, registerMemorySessionEventStorage as st, NativeLocalityInput as t, recoverAgent as tn, SessionLifecycleEventArgs as tt, registerSessionDiscoveredHandler as u, extractTextContent as un, sessionEvents as ut, SelectMessageRouting as v, SearchSessionRow as vt, InsertMessage as w, registerFtsSearchHandler as wt, registerDrizzleMessageRoutingStorage as x, fetchPreviewBySession as xt, messageRouting as y, fetchAgentsBySession as yt, IObservedSessionIngestionPolicyProvider as z, resolveAdapterNameById as zt };

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

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