@ai-matrx/chat 0.1.77 → 0.2.1

package/dist/agents/redux/agent-shortcuts/types.d.ts

@@ -0,0 +1,415 @@
+import type { ContextPolicy, LLMParams } from "../../types/agent-api-types.js";
+import type { VariableDefinition } from "../../types/agent-definition.types.js";
+import type { ResultDisplayMode } from "../../utils/run-ui-utils.js";
+import type { ShortcutContext } from "../../utils/shortcut-context-utils.js";
+import type { VariablesPanelStyle } from "../../components/inputs/variable-input-variations/variable-input-options.js";
+import type { JsonExtractionConfig } from "../../types/instance.types.js";
+import type { FieldFlags } from "@ai-matrx/agents/field-flags";
+import type { ValueMappingMap, WritePolicyMap } from "../../../surfaces/types.js";
+import type { AnyMandateKey } from "@ai-matrx/agents/mandates";
+export type { ResultDisplayMode, ShortcutContext };
+export interface AgentShortcut {
+    id: string;
+    categoryId: string;
+    label: string;
+    description: string | null;
+    iconName: string | null;
+    keyboardShortcut: string | null;
+    sortOrder: number;
+    agentId: string | null;
+    agentVersionId: string | null;
+    useLatest: boolean;
+    /**
+     * The id the API must be called with. When `useLatest` is true this
+     * equals `agentId`; when false it equals `agentVersionId` (the frozen
+     * version). Always the safe choice for execution.
+     */
+    resolvedId: string | null;
+    /**
+     * Whether `resolvedId` points at an agx_version row (true) or an
+     * agent.definition row (false). Must be sent with the API call so the server
+     * knows which table to read. Mirrors `!useLatest` for version-pinned
+     * shortcuts.
+     */
+    isVersion: boolean;
+    agentName: string | null;
+    variableDefinitions: VariableDefinition[];
+    contextPolicies: ContextPolicy[];
+    /** App features/surfaces where this shortcut is available (chat, notes, code-editor, …). */
+    enabledFeatures: ShortcutContext[];
+    /**
+     * Registered ui_surface.name this shortcut targets. Successor to
+     * `enabledFeatures` — points the resolver at a specific surface's
+     * declared values. Optional during the dual-system window.
+     */
+    surfaceName: string | null;
+    /** UI scope key → agent variable name. */
+    scopeMappings: Record<string, string> | null;
+    /**
+     * Successor to `scopeMappings`. Canonical DSL direction: keyed by AGENT
+     * variable / context-policy name; each value is a rich ValueMapping
+     * (surface_value | direct_value | prompt_user | unmapped) whose `target`
+     * names the surface value. Reads should go through
+     * `resolveShortcutMappings()`, which layers this over the promoted legacy
+     * columns.
+     */
+    valueMappings: ValueMappingMap | null;
+    /**
+     * Per-write-target applyPolicy overrides — the shortcut is the STRONGEST
+     * layer of the same launch-time merge as binding `write_policies`.
+     * Stored (no DDL) INSIDE the `value_mappings` JSONB under the reserved
+     * `__write_policies` key; the converters are the ONE serializer pair
+     * (`parseShortcutWritePolicies` lifts, `packShortcutValueMappings` nests).
+     * Optional so partial record constructions don't have to name it; treat
+     * absent as null.
+     */
+    writePolicies?: WritePolicyMap | null;
+    /**
+     * Tools this shortcut's run is never offered (names, or `prefix*` groups) —
+     * the show-only shortcuts list `apply_surface_write` + `widget_*`. Stored in
+     * the treatment (`never_include_tools`); see `readShortcutNeverIncludeTools`.
+     * Optional so partial record constructions don't have to name it.
+     */
+    neverIncludeTools?: string[] | null;
+    /** UI scope key → agent context-policy key. Parity with scopeMappings. */
+    contextMappings: Record<string, string> | null;
+    displayMode: ResultDisplayMode;
+    showVariablePanel: boolean;
+    variablesPanelStyle: VariablesPanelStyle;
+    autoRun: boolean;
+    allowChat: boolean;
+    showDefinitionMessages: boolean;
+    showDefinitionMessageContent: boolean;
+    hideReasoning: boolean;
+    hideToolResults: boolean;
+    responseDensity: "comfortable" | "compact";
+    showPreExecutionGate: boolean;
+    preExecutionMessage: string | null;
+    bypassGateSeconds: number;
+    defaultUserInput: string | null;
+    defaultVariables: Record<string, unknown> | null;
+    contextOverrides: Record<string, unknown> | null;
+    llmOverrides: Partial<LLMParams> | null;
+    /**
+     * Streaming JSON extraction config. Set on direct-mode shortcuts whose
+     * agent emits structured JSON; the launch thunk forwards this to the
+     * request so process-stream activates a StreamingJsonTracker. NULL =
+     * no extraction.
+     */
+    jsonExtraction: JsonExtractionConfig | null;
+    /**
+     * 🚨 THE BATCH GENERALIZATION (census #47, VISION-GAP §6). The batch grid
+     * is "the surface that makes one intelligence portable across many places",
+     * and the row it edits must therefore be a MANDATE row, not a shortcut row.
+     * Everything else about this type already is storage-agnostic: it is
+     * camelCase, semantic, and produced from `shortcutTable()` — the
+     * `lib/supabase/shortcutStorage.ts` router — in BOTH switch positions.
+     * These two fields were the one thing that stopped at the router: the only
+     * columns that differ between `agent.shortcut` and `mandate.vw_shortcut`
+     * are `mandate_id` + `mandate_key`, and `mandateIdOfShortcutRow` /
+     * `mandateKeyOfShortcutRow` existed with ZERO callers, so the mandate
+     * behind a row could not be seen by anything above the converters.
+     *
+     * Now every consumer of a shortcut row — the batch grid, the menu, the
+     * surface disclosure section — reads the same rows carrying their mandate
+     * identity. NULL in both positions today because the switch is OFF; the
+     * helpers return null by design until it flips, at which point these
+     * populate with no further change. Never written back: the mandate row is
+     * the writer's business (`mandate.definition`), not the shortcut view's.
+     */
+    mandateId?: string | null;
+    mandateKey?: AnyMandateKey | null;
+    isActive: boolean;
+    userId: string | null;
+    organizationId: string | null;
+    projectId: string | null;
+    taskId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Returned by `agx_get_shortcuts_initial()` and `agx_get_shortcuts_for_context()`.
+ *
+ * The RPC resolves the version reference and returns:
+ *   resolved_id  — ONE uuid to pass to the backend for execution
+ *   is_version   — false = resolved_id is an agent.definition.id, true = agx_version.id
+ *   is_behind    — true = a newer version of the agent exists (drift indicator)
+ *
+ * Resolution logic (handled inside the RPC):
+ *   use_latest = true OR version is current → resolved_id = agent_id, is_version = false
+ *   version is behind                       → resolved_id = agent_version_id, is_version = true
+ */
+export interface AgentShortcutInitialRow {
+    shortcut_id: string;
+    category_id: string;
+    label: string;
+    description: string;
+    icon_name: string;
+    keyboard_shortcut: string;
+    sort_order: number;
+    resolved_id: string;
+    is_version: boolean;
+    is_behind: boolean;
+    agent_id: string;
+    agent_version_id: string;
+    current_version: number;
+    use_latest: boolean;
+    enabled_features: ShortcutContext[];
+    surface_name: string | null;
+    scope_mappings: Record<string, string> | null;
+    value_mappings: ValueMappingMap | null;
+    context_mappings: Record<string, string> | null;
+    display_mode: ResultDisplayMode;
+    show_variable_panel: boolean;
+    variables_panel_style: string;
+    auto_run: boolean;
+    allow_chat: boolean;
+    show_definition_messages: boolean;
+    show_definition_message_content: boolean;
+    hide_reasoning: boolean;
+    hide_tool_results: boolean;
+    show_pre_execution_gate: boolean;
+    pre_execution_message: string;
+    bypass_gate_seconds: number;
+    default_user_input: string;
+    default_variables: Record<string, unknown> | null;
+    context_overrides: Record<string, unknown> | null;
+    llm_overrides: Record<string, unknown> | null;
+    shortcut_user_id: string;
+    shortcut_org_id: string;
+    agent_name: string;
+    agent_variable_definitions: VariableDefinition[] | null;
+    agent_context_policies: ContextPolicy[] | null;
+}
+/**
+ * Returned by `agx_get_shortcuts_for_context(project_id?, task_id?)`.
+ * Extends initial with hierarchy ids. Overlapping shortcut ids overwrite phase-1 data.
+ */
+export interface AgentShortcutContextRow extends AgentShortcutInitialRow {
+    shortcut_project_id: string;
+    shortcut_task_id: string;
+}
+/**
+ * Menu item shape from `agx_build_shortcut_menu(placement_types[])`.
+ */
+export interface AgentShortcutMenuResult {
+    placement_type: string;
+    menu_data: AgentShortcutCategory[];
+}
+export interface AgentShortcutCategory {
+    category: {
+        id: string;
+        label: string;
+        description: string | null;
+        icon_name: string | null;
+        color: string | null;
+        sort_order: number;
+        parent_category_id: string | null;
+        enabled_features: string[] | null;
+    };
+    shortcuts: AgentShortcutMenuItem[];
+}
+export interface AgentShortcutMenuItem {
+    id: string;
+    label: string;
+    description: string | null;
+    icon_name: string | null;
+    keyboard_shortcut: string | null;
+    sort_order: number;
+    resolved_id: string | null;
+    is_version: boolean;
+    is_behind: boolean;
+    agent_id: string | null;
+    use_latest: boolean;
+    enabled_features: ShortcutContext[];
+    surface_name: string | null;
+    scope_mappings: Record<string, string> | null;
+    value_mappings: ValueMappingMap | null;
+    context_mappings: Record<string, string> | null;
+    display_mode: ResultDisplayMode;
+    show_variable_panel: boolean;
+    variables_panel_style: string;
+    auto_run: boolean;
+    allow_chat: boolean;
+    show_definition_messages: boolean;
+    show_definition_message_content: boolean;
+    hide_reasoning: boolean;
+    hide_tool_results: boolean;
+    show_pre_execution_gate: boolean;
+    pre_execution_message: string | null;
+    bypass_gate_seconds: number;
+    default_user_input: string | null;
+    default_variables: Record<string, unknown> | null;
+    context_overrides: Record<string, unknown> | null;
+    llm_overrides: Record<string, unknown> | null;
+    agent: {
+        name: string;
+        variable_definitions: VariableDefinition[] | null;
+        context_policies: ContextPolicy[] | null;
+    } | null;
+}
+/**
+ * Returned by `agx_get_user_shortcuts()`.
+ * All shortcuts the current user owns or can admin, across all scopes.
+ * Used by the management page to display and group shortcuts.
+ */
+export interface UserShortcutItem {
+    id: string;
+    label: string;
+    description: string;
+    icon_name: string;
+    keyboard_shortcut: string;
+    sort_order: number;
+    category_id: string;
+    category_label: string;
+    agent_id: string;
+    agent_name: string;
+    agent_version_id: string;
+    use_latest: boolean;
+    scope_type: "personal" | "organization" | "project" | "task" | "system";
+    scope_name: string;
+    user_id: string;
+    organization_id: string;
+    project_id: string;
+    task_id: string;
+    enabled_features: ShortcutContext[];
+    /**
+     * Not part of the RPC's declared Returns — an extra field carried on the FE
+     * interface for the directory/management UI. Extra properties don't break the
+     * DB-shape guard below (the interface is still assignable to the RPC row).
+     */
+    surface_name: string | null;
+    scope_mappings: Record<string, string> | null;
+    /** Extra FE field, not in the RPC Returns — see `surface_name` note. */
+    value_mappings: ValueMappingMap | null;
+    context_mappings: Record<string, string> | null;
+    display_mode: ResultDisplayMode;
+    show_variable_panel: boolean;
+    variables_panel_style: string;
+    auto_run: boolean;
+    allow_chat: boolean;
+    show_definition_messages: boolean;
+    show_definition_message_content: boolean;
+    hide_reasoning: boolean;
+    hide_tool_results: boolean;
+    show_pre_execution_gate: boolean;
+    pre_execution_message: string;
+    bypass_gate_seconds: number;
+    default_user_input: string;
+    default_variables: Record<string, unknown> | null;
+    context_overrides: Record<string, unknown> | null;
+    llm_overrides: Record<string, unknown> | null;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+}
+/**
+ * Returned by `agx_list_non_global_shortcuts_for_admin()`.
+ * Admin-only: every non-global shortcut across users/orgs/projects/tasks, for
+ * the "Import to Global" picker. Row shape mirrors the generated RPC Returns
+ * (all identity/text columns are non-null), plus `owner_email` / `owner_display`
+ * for attribution. Standalone (does NOT extend the loose REST `ShortcutApiRow`)
+ * so the DB-shape guard below can enforce the real RPC contract.
+ */
+export type AdminNonGlobalShortcutRow = {
+    id: string;
+    category_id: string;
+    label: string;
+    description: string;
+    icon_name: string;
+    keyboard_shortcut: string;
+    sort_order: number;
+    agent_id: string;
+    agent_version_id: string;
+    use_latest: boolean;
+    owner_email: string;
+    owner_display: string;
+    scope_type: "user" | "organization" | "project" | "task" | string;
+    user_id: string;
+    organization_id: string;
+    project_id: string;
+    task_id: string;
+    enabled_features: ShortcutContext[];
+    scope_mappings: Record<string, string> | null;
+    context_mappings: Record<string, string> | null;
+    /**
+     * `surface_name` and `value_mappings` are NOT in the RPC's declared Returns —
+     * extra fields carried on the FE interface (for the directory UI, and so this
+     * row stays assignable to the loose `ShortcutApiRow` consumed by
+     * `shortcutRowToFrontend`). Extra properties don't break the DB-shape guard
+     * below (the interface is still assignable to the RPC row).
+     */
+    surface_name: string | null;
+    value_mappings: ValueMappingMap | null;
+    display_mode: ResultDisplayMode;
+    show_variable_panel: boolean;
+    variables_panel_style: string;
+    auto_run: boolean;
+    allow_chat: boolean;
+    show_definition_messages: boolean;
+    show_definition_message_content: boolean;
+    hide_reasoning: boolean;
+    hide_tool_results: boolean;
+    show_pre_execution_gate: boolean;
+    pre_execution_message: string;
+    bypass_gate_seconds: number;
+    default_user_input: string;
+    default_variables: Record<string, unknown> | null;
+    context_overrides: Record<string, unknown> | null;
+    llm_overrides: Record<string, unknown> | null;
+    is_active: boolean;
+    created_at: string;
+    updated_at: string;
+};
+/**
+ * Input for `agx_create_shortcut(...)`.
+ * Quick-create from the agent page or a picker.
+ * Automatically pins to the agent's current version unless use_latest = true.
+ * Returns the new shortcut UUID.
+ */
+export interface CreateShortcutForAgentParams {
+    p_agent_id: string;
+    p_label: string;
+    p_category_id: string;
+    p_user_id?: string | null;
+    p_organization_id?: string | null;
+    p_project_id?: string | null;
+    p_task_id?: string | null;
+    p_use_latest?: boolean;
+}
+/**
+ * Snapshot of field values before user edits.
+ * Anchored to last clean fetch. Enables per-field undo.
+ */
+export type ShortcutFieldSnapshot = {
+    [K in keyof AgentShortcut]?: AgentShortcut[K];
+};
+/**
+ * Tracks which fields have been explicitly fetched from the DB.
+ *   key set to true → field was fetched (null/empty IS the DB value)
+ *   key absent     → field has not been fetched yet
+ *
+ * Uses FieldFlags (a Partial<Record<K, true>>) instead of Set<K> to keep the
+ * Redux state JSON-serializable for persistence and the upcoming shared
+ * agent-state package.
+ */
+export type ShortcutLoadedFields = FieldFlags<keyof AgentShortcut>;
+export interface AgentShortcutRecord extends AgentShortcut {
+    _dirty: boolean;
+    _dirtyFields: FieldFlags<keyof AgentShortcut>;
+    _fieldHistory: ShortcutFieldSnapshot;
+    _loadedFields: ShortcutLoadedFields;
+    _loading: boolean;
+    _error: string | null;
+}
+export interface AgentShortcutSliceState {
+    shortcuts: Record<string, AgentShortcutRecord>;
+    activeShortcutId: string | null;
+    initialLoaded: boolean;
+    contextLoaded: Record<string, boolean>;
+    scopeLoaded: Record<string, boolean>;
+    status: "idle" | "loading" | "succeeded" | "failed";
+    error: string | null;
+}
+/** The editor's form for one shortcut (everything the store assigns is left out). */
+export type ShortcutFormData = Omit<AgentShortcut, "id" | "createdAt" | "updatedAt">;

package/dist/agents/redux/agent-shortcuts/types.js

@@ -0,0 +1,5 @@
+true;
+true;
+true;
+true;
+true;

package/dist/agents/redux/chat/chat-incognito.slice.d.ts

@@ -0,0 +1,8 @@
+import type { ChatRootState } from "../../../store/root-state.js";
+export interface ChatIncognitoState {
+    isActive: boolean;
+}
+export declare const setChatIncognitoActive: import("@reduxjs/toolkit").ActionCreatorWithPayload<boolean, "chatIncognito/setChatIncognitoActive">, toggleChatIncognito: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"chatIncognito/toggleChatIncognito">;
+declare const _default: import("redux").Reducer<ChatIncognitoState>;
+export default _default;
+export declare const selectChatIncognitoActive: (state: ChatRootState) => boolean;

package/dist/agents/redux/chat/chat-incognito.slice.js

@@ -0,0 +1,25 @@
+import { createSlice } from "@reduxjs/toolkit";
+const initialState = {
+  isActive: false
+};
+const chatIncognitoSlice = createSlice({
+  name: "chatIncognito",
+  initialState,
+  reducers: {
+    setChatIncognitoActive(state, action) {
+      state.isActive = action.payload;
+    },
+    toggleChatIncognito(state) {
+      state.isActive = !state.isActive;
+    }
+  }
+});
+const { setChatIncognitoActive, toggleChatIncognito } = chatIncognitoSlice.actions;
+var chat_incognito_slice_default = chatIncognitoSlice.reducer;
+const selectChatIncognitoActive = (state) => state.chatIncognito.isActive;
+export {
+  chat_incognito_slice_default as default,
+  selectChatIncognitoActive,
+  setChatIncognitoActive,
+  toggleChatIncognito
+};

package/dist/agents/redux/chat/chat-route.slice.d.ts

@@ -0,0 +1,43 @@
+import type { ChatRootState } from "../../../store/root-state.js";
+import type { ComposerMode } from "../../components/inputs/smart-input/composer/composer-types.js";
+export interface ChatRouteState {
+    /**
+     * The composer's page mode (Chat · Work · Advanced — Amendment 1, A1). ONE
+     * value for the whole tab: the top-bar switch, every composer and a
+     * popped-out floating chat read it, so the floating panel "inherits the
+     * mode" by construction. `null` until the first composer host seeds it from
+     * the server-read cookie (`useComposerMode`).
+     */
+    composerMode: ComposerMode | null;
+    /** Bumped when the user explicitly starts a new chat (+). Drives reminting
+     *  on fresh routes even when the URL stays on `/chat/new`. */
+    freshSessionNonce: number;
+    /**
+     * A same-tab agent switch. This deliberately holds identities only: request
+     * content remains in the initialized Redux instance, never in storage.
+     */
+    draftHandoff: {
+        sourceConversationId: string;
+        resourceSourceConversationId: string;
+        connectorSourceConversationId: string;
+        pinnedSourceConversationIds: string[];
+        targetAgentId: string;
+    } | null;
+}
+export declare const setComposerMode: import("@reduxjs/toolkit").ActionCreatorWithPayload<ComposerMode, "chatRoute/setComposerMode">, bumpFreshSession: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"chatRoute/bumpFreshSession">, stageDraftHandoff: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    sourceConversationId: string;
+    targetAgentId: string;
+}, "chatRoute/stageDraftHandoff">, acknowledgeDraftHandoff: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    targetAgentId: string;
+}, "chatRoute/acknowledgeDraftHandoff">;
+declare const _default: import("redux").Reducer<ChatRouteState>;
+export default _default;
+export declare const selectChatFreshSessionNonce: (state: ChatRootState) => number;
+export declare const selectChatDraftHandoff: (state: ChatRootState) => {
+    sourceConversationId: string;
+    resourceSourceConversationId: string;
+    connectorSourceConversationId: string;
+    pinnedSourceConversationIds: string[];
+    targetAgentId: string;
+} | null;
+export declare const selectComposerMode: (state: ChatRootState) => ComposerMode | null;

package/dist/agents/redux/chat/chat-route.slice.js

@@ -0,0 +1,58 @@
+import { createSlice } from "@reduxjs/toolkit";
+const initialState = {
+  composerMode: null,
+  freshSessionNonce: 0,
+  draftHandoff: null
+};
+const chatRouteSlice = createSlice({
+  name: "chatRoute",
+  initialState,
+  reducers: {
+    setComposerMode(state, action) {
+      state.composerMode = action.payload;
+    },
+    bumpFreshSession(state) {
+      state.freshSessionNonce += 1;
+    },
+    stageDraftHandoff(state, action) {
+      const previous = state.draftHandoff;
+      state.draftHandoff = {
+        sourceConversationId: action.payload.sourceConversationId,
+        resourceSourceConversationId: previous?.resourceSourceConversationId ?? action.payload.sourceConversationId,
+        connectorSourceConversationId: previous?.connectorSourceConversationId ?? action.payload.sourceConversationId,
+        pinnedSourceConversationIds: Array.from(
+          /* @__PURE__ */ new Set([
+            ...previous?.pinnedSourceConversationIds ?? [],
+            action.payload.sourceConversationId
+          ])
+        ),
+        targetAgentId: action.payload.targetAgentId
+      };
+    },
+    acknowledgeDraftHandoff(state, action) {
+      if (state.draftHandoff?.targetAgentId === action.payload.targetAgentId) {
+        state.draftHandoff = null;
+      }
+    }
+  }
+});
+const {
+  setComposerMode,
+  bumpFreshSession,
+  stageDraftHandoff,
+  acknowledgeDraftHandoff
+} = chatRouteSlice.actions;
+var chat_route_slice_default = chatRouteSlice.reducer;
+const selectChatFreshSessionNonce = (state) => state.chatRoute.freshSessionNonce;
+const selectChatDraftHandoff = (state) => state.chatRoute.draftHandoff;
+const selectComposerMode = (state) => state.chatRoute.composerMode;
+export {
+  acknowledgeDraftHandoff,
+  bumpFreshSession,
+  chat_route_slice_default as default,
+  selectChatDraftHandoff,
+  selectChatFreshSessionNonce,
+  selectComposerMode,
+  setComposerMode,
+  stageDraftHandoff
+};

package/dist/agents/redux/conversation-history/conversation-search.d.ts

@@ -0,0 +1,33 @@
+import type { Database } from "../../../host/db-types.js";
+import type { ConversationListItem } from "../conversation-list/conversation-list.types.js";
+import type { ConversationHistoryScopeState, SourceFacet } from "./types.js";
+export type ConversationSearchRange = "7d" | "30d" | "90d" | "all";
+type SearchScope = Pick<ConversationHistoryScopeState, "agentIds" | "excludeSourceFeatures" | "includeSourceFeatures" | "includeSourceApps" | "includeEmptySource" | "includeOriginClasses" | "includeLanes">;
+export interface ConversationSearchRequest {
+    query: string;
+    range: ConversationSearchRange;
+    deep: boolean;
+    limit: number;
+    offset: number;
+    scope: SearchScope;
+    signal?: AbortSignal;
+}
+export interface ConversationSearchPage {
+    items: ConversationListItem[];
+    total: number;
+}
+type SearchArgs = Database["public"]["Functions"]["cx_search_conversations"]["Args"];
+/** Small libraries search everything immediately; larger ones start cheaper. */
+export declare function initialConversationSearchRange(conversationCount: number | null, pageSize: number): ConversationSearchRange;
+export declare function nextConversationSearchRange(range: ConversationSearchRange): ConversationSearchRange | null;
+export declare function conversationSearchRangeLabel(range: ConversationSearchRange): string;
+export declare function buildConversationSearchArgs(request: ConversationSearchRequest): SearchArgs;
+/** Exact facet-derived size when every active filter exists in the facet key. */
+export declare function countConversationSearchCorpus(facets: SourceFacet[], scope: SearchScope): number | null;
+/**
+ * Authoritative search. SQL ranks exact ids and labels first, then metadata.
+ * Indexed message bodies are searched only on the explicit deep path (or for
+ * identifier-shaped queries recognized by the shared SQL rule).
+ */
+export declare function searchConversations(request: ConversationSearchRequest): Promise<ConversationSearchPage>;
+export {};