@kb-labs/mind-contracts 2.93.0 → 2.96.0

package/dist/index.d.ts

@@ -1,95 +1,1947 @@
-export { A as ApiContract, a as ArtifactContractsMap, b as ArtifactExample, c as ArtifactKind, C as CommandContract, d as CommandContractsMap, P as PluginArtifactContract, e as PluginContracts, R as RestApiContract, f as RestRouteContract, S as SchemaReference, W as WorkflowContract, g as WorkflowContractsMap, h as WorkflowStepContract, i as contractsSchemaId, j as contractsVersion, p as pluginContractsManifest } from './contract-D29vlhme.js';
-export { MindFeedCommandInputSchema, MindFeedCommandOutputSchema, MindInitCommandInputSchema, MindPackCommandInputSchema, MindPackCommandOutputSchema, MindQueryCommandInputSchema, MindQueryCommandOutputSchema, MindQueryRequestSchema, MindQueryResponseSchema, MindUpdateCommandInputSchema, MindUpdateCommandOutputSchema, MindVerifyCommandInputSchema, MindVerifyCommandOutputSchema, MindVerifyResponseSchema, PluginContractsSchema, apiContractSchema, artifactContractSchema, artifactExampleSchema, artifactsContractMapSchema, commandContractMapSchema, commandContractSchema, parsePluginContracts, pluginContractsSchema, restApiContractSchema, restRouteContractSchema, schemaReferenceSchema, workflowContractMapSchema, workflowContractSchema, workflowStepSchema } from './schema.js';
-import 'zod';
+import { z } from 'zod';
+import * as _kb_labs_shared_command_kit from '@kb-labs/shared-command-kit';
 
 /**
- * Registry configuration for Mind sync
+ * REST route constants for Mind.
+ *
+ * `BASE_PATH` is temporary (`/v1/plugins/mind`) for coexistence with the
+ * legacy plugin; it becomes `/v1/plugins/mind` at the Phase 6 rename.
  */
-interface MindSyncRegistryConfig {
-    type: 'filesystem';
-    path: string;
-}
+declare const MIND_BASE_PATH: "/v1/plugins/mind";
+declare const MIND_ROUTES: {
+    readonly INDEX: "/index";
+    readonly SEARCH: "/search";
+    readonly QUERY: "/query";
+    readonly EXPLORE: "/explore";
+    readonly DROP: "/index";
+    readonly SYNC_ADD: "/sync/add";
+    readonly SYNC_UPDATE: "/sync/update";
+    readonly SYNC_DELETE: "/sync/delete";
+    readonly SYNC_LIST: "/sync/list";
+    readonly SYNC_STATUS: "/sync/status";
+    readonly STATUS: "/status";
+    readonly HEALTH: "/health";
+    readonly REINDEX: "/reindex";
+};
+declare const MIND_FULL_ROUTES: {
+    readonly INDEX: "/v1/plugins/mind/index";
+    readonly SEARCH: "/v1/plugins/mind/search";
+    readonly QUERY: "/v1/plugins/mind/query";
+    readonly EXPLORE: "/v1/plugins/mind/explore";
+    readonly DROP: "/v1/plugins/mind/index";
+    readonly SYNC_ADD: "/v1/plugins/mind/sync/add";
+    readonly SYNC_UPDATE: "/v1/plugins/mind/sync/update";
+    readonly SYNC_DELETE: "/v1/plugins/mind/sync/delete";
+    readonly SYNC_LIST: "/v1/plugins/mind/sync/list";
+    readonly SYNC_STATUS: "/v1/plugins/mind/sync/status";
+    readonly STATUS: "/v1/plugins/mind/status";
+    readonly HEALTH: "/v1/plugins/mind/health";
+    readonly REINDEX: "/v1/plugins/mind/reindex";
+};
+/** Cache + vector-store namespace prefix; renamed to `mind:` at Phase 6. */
+declare const MIND_NAMESPACE_PREFIX: "mind:";
+
 /**
- * Soft delete configuration for Mind sync
+ * Mind configuration (`configSection: 'mind'`).
+ *
+ * Pure wire/config types — no platform internals. `resolveMindConfig` merges a
+ * partial file config onto defaults so callers always get a complete config.
  */
-interface MindSyncSoftDeleteConfig {
-    enabled: boolean;
-    ttlDays: number;
-}
+
+declare const ChunkConfigSchema: z.ZodObject<{
+    /** Target chunk size in tokens. */
+    maxTokens: z.ZodDefault<z.ZodNumber>;
+    /** Overlap between adjacent chunks, in tokens. */
+    overlapTokens: z.ZodDefault<z.ZodNumber>;
+    /** Use AST-aware chunking where a parser exists (falls back to sliding window). */
+    ast: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    maxTokens: number;
+    overlapTokens: number;
+    ast: boolean;
+}, {
+    maxTokens?: number | undefined;
+    overlapTokens?: number | undefined;
+    ast?: boolean | undefined;
+}>;
+/** Per-mode pipeline budget. Modes are configs of one pipeline, not code paths. */
+declare const ModeBudgetSchema: z.ZodObject<{
+    /** Max chunks fed into the answer stage. */
+    maxChunks: z.ZodNumber;
+    /** Max sub-queries from decomposition (0 = no decomposition). */
+    maxSubqueries: z.ZodNumber;
+    /** Completeness-check iterations. */
+    maxIterations: z.ZodNumber;
+    /** Whether the synthesize stage calls the LLM. */
+    useLLM: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    maxChunks: number;
+    maxSubqueries: number;
+    maxIterations: number;
+    useLLM: boolean;
+}, {
+    maxChunks: number;
+    maxSubqueries: number;
+    maxIterations: number;
+    useLLM: boolean;
+}>;
+declare const ModesConfigSchema: z.ZodObject<{
+    instant: z.ZodDefault<z.ZodObject<{
+        /** Max chunks fed into the answer stage. */
+        maxChunks: z.ZodNumber;
+        /** Max sub-queries from decomposition (0 = no decomposition). */
+        maxSubqueries: z.ZodNumber;
+        /** Completeness-check iterations. */
+        maxIterations: z.ZodNumber;
+        /** Whether the synthesize stage calls the LLM. */
+        useLLM: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    }, {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    }>>;
+    auto: z.ZodDefault<z.ZodObject<{
+        /** Max chunks fed into the answer stage. */
+        maxChunks: z.ZodNumber;
+        /** Max sub-queries from decomposition (0 = no decomposition). */
+        maxSubqueries: z.ZodNumber;
+        /** Completeness-check iterations. */
+        maxIterations: z.ZodNumber;
+        /** Whether the synthesize stage calls the LLM. */
+        useLLM: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    }, {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    }>>;
+    thinking: z.ZodDefault<z.ZodObject<{
+        /** Max chunks fed into the answer stage. */
+        maxChunks: z.ZodNumber;
+        /** Max sub-queries from decomposition (0 = no decomposition). */
+        maxSubqueries: z.ZodNumber;
+        /** Completeness-check iterations. */
+        maxIterations: z.ZodNumber;
+        /** Whether the synthesize stage calls the LLM. */
+        useLLM: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    }, {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    instant: {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    };
+    auto: {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    };
+    thinking: {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    };
+}, {
+    instant?: {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    } | undefined;
+    auto?: {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    } | undefined;
+    thinking?: {
+        maxChunks: number;
+        maxSubqueries: number;
+        maxIterations: number;
+        useLLM: boolean;
+    } | undefined;
+}>;
+declare const RetrievalConfigSchema: z.ZodObject<{
+    /** Default number of results returned by `search`. */
+    limit: z.ZodDefault<z.ZodNumber>;
+    /** Reciprocal-rank-fusion constant. */
+    rrfK: z.ZodDefault<z.ZodNumber>;
+    /** Enable heuristic reranking of fused candidates. */
+    rerank: z.ZodDefault<z.ZodBoolean>;
+    /** Enable semantic dedup of retrieved chunks. */
+    dedup: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * HyDE (Hypothetical Document Embeddings): embed an LLM-generated hypothetical
+     * answer instead of the raw query for the vector search (BM25 still uses the
+     * raw query). Trades one LLM call per query for better concept-query recall.
+     * Off by default — enable only where the bench A/B shows a lift.
+     */
+    hyde: z.ZodDefault<z.ZodBoolean>;
+    /**
+     * Query expansion: ask the LLM for related identifiers/synonyms and append
+     * them to the BM25 (lexical) query, so vocabulary mismatch between the query
+     * wording and the code/doc terms still surfaces lexical hits. Orthogonal to
+     * HyDE (which bridges the vector side). Trades one LLM call per query.
+     * Off by default — enable only where the bench A/B shows a lift.
+     */
+    expand: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    rrfK: number;
+    rerank: boolean;
+    dedup: boolean;
+    hyde: boolean;
+    expand: boolean;
+}, {
+    limit?: number | undefined;
+    rrfK?: number | undefined;
+    rerank?: boolean | undefined;
+    dedup?: boolean | undefined;
+    hyde?: boolean | undefined;
+    expand?: boolean | undefined;
+}>;
+declare const ConfidenceConfigSchema: z.ZodObject<{
+    /** Below this, agent answers abstain in strict mode. */
+    floor: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    floor: number;
+}, {
+    floor?: number | undefined;
+}>;
 /**
- * Partial updates configuration for Mind sync
+ * Index scope. Either a single path/glob (shorthand) or an explicit
+ * include/exclude set. Paths are repo-relative; a bare dir means "everything
+ * under it". `exclude` globs are subtracted from `include` at discovery time.
+ *
+ *   "core"                                   just core/
+ *   { include: ["core","plugins","sdk"] }    those roots
+ *   { include: ["."], exclude: ["sites/**"] } whole repo minus noise
  */
-interface MindSyncPartialUpdatesConfig {
-    enabled: boolean;
+declare const IndexScopeSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
+    include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+}, {
+    include?: string[] | undefined;
+    exclude?: string[] | undefined;
+}>]>;
+type IndexScope = z.infer<typeof IndexScopeSchema>;
+/** Normalized scope the engine consumes. */
+interface ResolvedScope {
+    /** Repo-relative roots/globs to index (default: whole repo). */
+    include: string[];
+    /** Globs subtracted from the include set. */
+    exclude: string[];
+}
+/** Normalize the config/shorthand scope into `{ include, exclude }`. */
+declare function resolveScope(scope: IndexScope | undefined): ResolvedScope;
+declare const IndexConfigSchema: z.ZodObject<{
+    /** Path/glob or include/exclude set indexed into this index (CLI `--scope` overrides). */
+    scope: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    }, {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    }>]>>;
+    /** Human label (optional, for status/UX). */
+    label: z.ZodOptional<z.ZodString>;
+    /** Per-index chunk overrides; unset fields fall back to the global `chunk`. */
+    chunk: z.ZodOptional<z.ZodObject<{
+        maxTokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        overlapTokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        ast: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        maxTokens?: number | undefined;
+        overlapTokens?: number | undefined;
+        ast?: boolean | undefined;
+    }, {
+        maxTokens?: number | undefined;
+        overlapTokens?: number | undefined;
+        ast?: boolean | undefined;
+    }>>;
+    /** Per-index retrieval overrides; unset fields fall back to global `retrieval`. */
+    retrieval: z.ZodOptional<z.ZodObject<{
+        limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        rrfK: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        rerank: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        dedup: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        hyde: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        expand: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        limit?: number | undefined;
+        rrfK?: number | undefined;
+        rerank?: boolean | undefined;
+        dedup?: boolean | undefined;
+        hyde?: boolean | undefined;
+        expand?: boolean | undefined;
+    }, {
+        limit?: number | undefined;
+        rrfK?: number | undefined;
+        rerank?: boolean | undefined;
+        dedup?: boolean | undefined;
+        hyde?: boolean | undefined;
+        expand?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    scope?: string | {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    } | undefined;
+    label?: string | undefined;
+    chunk?: {
+        maxTokens?: number | undefined;
+        overlapTokens?: number | undefined;
+        ast?: boolean | undefined;
+    } | undefined;
+    retrieval?: {
+        limit?: number | undefined;
+        rrfK?: number | undefined;
+        rerank?: boolean | undefined;
+        dedup?: boolean | undefined;
+        hyde?: boolean | undefined;
+        expand?: boolean | undefined;
+    } | undefined;
+}, {
+    scope?: string | {
+        include?: string[] | undefined;
+        exclude?: string[] | undefined;
+    } | undefined;
+    label?: string | undefined;
+    chunk?: {
+        maxTokens?: number | undefined;
+        overlapTokens?: number | undefined;
+        ast?: boolean | undefined;
+    } | undefined;
+    retrieval?: {
+        limit?: number | undefined;
+        rrfK?: number | undefined;
+        rerank?: boolean | undefined;
+        dedup?: boolean | undefined;
+        hyde?: boolean | undefined;
+        expand?: boolean | undefined;
+    } | undefined;
+}>;
+declare const MindConfigSchema: z.ZodObject<{
+    /** Default index used when a command omits `--index`. */
+    defaultIndex: z.ZodDefault<z.ZodString>;
+    /** Named indexes with per-index scope + overrides. */
+    indexes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        /** Path/glob or include/exclude set indexed into this index (CLI `--scope` overrides). */
+        scope: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
+            include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        }, {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        }>]>>;
+        /** Human label (optional, for status/UX). */
+        label: z.ZodOptional<z.ZodString>;
+        /** Per-index chunk overrides; unset fields fall back to the global `chunk`. */
+        chunk: z.ZodOptional<z.ZodObject<{
+            maxTokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            overlapTokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            ast: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            maxTokens?: number | undefined;
+            overlapTokens?: number | undefined;
+            ast?: boolean | undefined;
+        }, {
+            maxTokens?: number | undefined;
+            overlapTokens?: number | undefined;
+            ast?: boolean | undefined;
+        }>>;
+        /** Per-index retrieval overrides; unset fields fall back to global `retrieval`. */
+        retrieval: z.ZodOptional<z.ZodObject<{
+            limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            rrfK: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            rerank: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            dedup: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            hyde: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            expand: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+        }, "strip", z.ZodTypeAny, {
+            limit?: number | undefined;
+            rrfK?: number | undefined;
+            rerank?: boolean | undefined;
+            dedup?: boolean | undefined;
+            hyde?: boolean | undefined;
+            expand?: boolean | undefined;
+        }, {
+            limit?: number | undefined;
+            rrfK?: number | undefined;
+            rerank?: boolean | undefined;
+            dedup?: boolean | undefined;
+            hyde?: boolean | undefined;
+            expand?: boolean | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        scope?: string | {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        } | undefined;
+        label?: string | undefined;
+        chunk?: {
+            maxTokens?: number | undefined;
+            overlapTokens?: number | undefined;
+            ast?: boolean | undefined;
+        } | undefined;
+        retrieval?: {
+            limit?: number | undefined;
+            rrfK?: number | undefined;
+            rerank?: boolean | undefined;
+            dedup?: boolean | undefined;
+            hyde?: boolean | undefined;
+            expand?: boolean | undefined;
+        } | undefined;
+    }, {
+        scope?: string | {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        } | undefined;
+        label?: string | undefined;
+        chunk?: {
+            maxTokens?: number | undefined;
+            overlapTokens?: number | undefined;
+            ast?: boolean | undefined;
+        } | undefined;
+        retrieval?: {
+            limit?: number | undefined;
+            rrfK?: number | undefined;
+            rerank?: boolean | undefined;
+            dedup?: boolean | undefined;
+            hyde?: boolean | undefined;
+            expand?: boolean | undefined;
+        } | undefined;
+    }>>>;
+    chunk: z.ZodDefault<z.ZodObject<{
+        /** Target chunk size in tokens. */
+        maxTokens: z.ZodDefault<z.ZodNumber>;
+        /** Overlap between adjacent chunks, in tokens. */
+        overlapTokens: z.ZodDefault<z.ZodNumber>;
+        /** Use AST-aware chunking where a parser exists (falls back to sliding window). */
+        ast: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        maxTokens: number;
+        overlapTokens: number;
+        ast: boolean;
+    }, {
+        maxTokens?: number | undefined;
+        overlapTokens?: number | undefined;
+        ast?: boolean | undefined;
+    }>>;
+    retrieval: z.ZodDefault<z.ZodObject<{
+        /** Default number of results returned by `search`. */
+        limit: z.ZodDefault<z.ZodNumber>;
+        /** Reciprocal-rank-fusion constant. */
+        rrfK: z.ZodDefault<z.ZodNumber>;
+        /** Enable heuristic reranking of fused candidates. */
+        rerank: z.ZodDefault<z.ZodBoolean>;
+        /** Enable semantic dedup of retrieved chunks. */
+        dedup: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * HyDE (Hypothetical Document Embeddings): embed an LLM-generated hypothetical
+         * answer instead of the raw query for the vector search (BM25 still uses the
+         * raw query). Trades one LLM call per query for better concept-query recall.
+         * Off by default — enable only where the bench A/B shows a lift.
+         */
+        hyde: z.ZodDefault<z.ZodBoolean>;
+        /**
+         * Query expansion: ask the LLM for related identifiers/synonyms and append
+         * them to the BM25 (lexical) query, so vocabulary mismatch between the query
+         * wording and the code/doc terms still surfaces lexical hits. Orthogonal to
+         * HyDE (which bridges the vector side). Trades one LLM call per query.
+         * Off by default — enable only where the bench A/B shows a lift.
+         */
+        expand: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        limit: number;
+        rrfK: number;
+        rerank: boolean;
+        dedup: boolean;
+        hyde: boolean;
+        expand: boolean;
+    }, {
+        limit?: number | undefined;
+        rrfK?: number | undefined;
+        rerank?: boolean | undefined;
+        dedup?: boolean | undefined;
+        hyde?: boolean | undefined;
+        expand?: boolean | undefined;
+    }>>;
+    modes: z.ZodDefault<z.ZodObject<{
+        instant: z.ZodDefault<z.ZodObject<{
+            /** Max chunks fed into the answer stage. */
+            maxChunks: z.ZodNumber;
+            /** Max sub-queries from decomposition (0 = no decomposition). */
+            maxSubqueries: z.ZodNumber;
+            /** Completeness-check iterations. */
+            maxIterations: z.ZodNumber;
+            /** Whether the synthesize stage calls the LLM. */
+            useLLM: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        }, {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        }>>;
+        auto: z.ZodDefault<z.ZodObject<{
+            /** Max chunks fed into the answer stage. */
+            maxChunks: z.ZodNumber;
+            /** Max sub-queries from decomposition (0 = no decomposition). */
+            maxSubqueries: z.ZodNumber;
+            /** Completeness-check iterations. */
+            maxIterations: z.ZodNumber;
+            /** Whether the synthesize stage calls the LLM. */
+            useLLM: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        }, {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        }>>;
+        thinking: z.ZodDefault<z.ZodObject<{
+            /** Max chunks fed into the answer stage. */
+            maxChunks: z.ZodNumber;
+            /** Max sub-queries from decomposition (0 = no decomposition). */
+            maxSubqueries: z.ZodNumber;
+            /** Completeness-check iterations. */
+            maxIterations: z.ZodNumber;
+            /** Whether the synthesize stage calls the LLM. */
+            useLLM: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        }, {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        instant: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        };
+        auto: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        };
+        thinking: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        };
+    }, {
+        instant?: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        } | undefined;
+        auto?: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        } | undefined;
+        thinking?: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        } | undefined;
+    }>>;
+    confidence: z.ZodDefault<z.ZodObject<{
+        /** Below this, agent answers abstain in strict mode. */
+        floor: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        floor: number;
+    }, {
+        floor?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    chunk: {
+        maxTokens: number;
+        overlapTokens: number;
+        ast: boolean;
+    };
+    retrieval: {
+        limit: number;
+        rrfK: number;
+        rerank: boolean;
+        dedup: boolean;
+        hyde: boolean;
+        expand: boolean;
+    };
+    defaultIndex: string;
+    indexes: Record<string, {
+        scope?: string | {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        } | undefined;
+        label?: string | undefined;
+        chunk?: {
+            maxTokens?: number | undefined;
+            overlapTokens?: number | undefined;
+            ast?: boolean | undefined;
+        } | undefined;
+        retrieval?: {
+            limit?: number | undefined;
+            rrfK?: number | undefined;
+            rerank?: boolean | undefined;
+            dedup?: boolean | undefined;
+            hyde?: boolean | undefined;
+            expand?: boolean | undefined;
+        } | undefined;
+    }>;
+    modes: {
+        instant: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        };
+        auto: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        };
+        thinking: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        };
+    };
+    confidence: {
+        floor: number;
+    };
+}, {
+    chunk?: {
+        maxTokens?: number | undefined;
+        overlapTokens?: number | undefined;
+        ast?: boolean | undefined;
+    } | undefined;
+    retrieval?: {
+        limit?: number | undefined;
+        rrfK?: number | undefined;
+        rerank?: boolean | undefined;
+        dedup?: boolean | undefined;
+        hyde?: boolean | undefined;
+        expand?: boolean | undefined;
+    } | undefined;
+    defaultIndex?: string | undefined;
+    indexes?: Record<string, {
+        scope?: string | {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        } | undefined;
+        label?: string | undefined;
+        chunk?: {
+            maxTokens?: number | undefined;
+            overlapTokens?: number | undefined;
+            ast?: boolean | undefined;
+        } | undefined;
+        retrieval?: {
+            limit?: number | undefined;
+            rrfK?: number | undefined;
+            rerank?: boolean | undefined;
+            dedup?: boolean | undefined;
+            hyde?: boolean | undefined;
+            expand?: boolean | undefined;
+        } | undefined;
+    }> | undefined;
+    modes?: {
+        instant?: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        } | undefined;
+        auto?: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        } | undefined;
+        thinking?: {
+            maxChunks: number;
+            maxSubqueries: number;
+            maxIterations: number;
+            useLLM: boolean;
+        } | undefined;
+    } | undefined;
+    confidence?: {
+        floor?: number | undefined;
+    } | undefined;
+}>;
+type ChunkConfig = z.infer<typeof ChunkConfigSchema>;
+type RetrievalConfig = z.infer<typeof RetrievalConfigSchema>;
+type IndexConfig = z.infer<typeof IndexConfigSchema>;
+type MindConfig = z.infer<typeof MindConfigSchema>;
+type MindConfigInput = z.input<typeof MindConfigSchema>;
+type ModeBudget = z.infer<typeof ModeBudgetSchema>;
+/** Chunk + retrieval settings effective for a given index, overrides applied. */
+interface EffectiveIndexConfig {
+    /** Normalized include/exclude the engine discovers against. */
+    scope: ResolvedScope;
+    chunk: ChunkConfig;
+    retrieval: RetrievalConfig;
 }
 /**
- * Batch processing configuration for Mind sync
+ * Resolve the effective settings for an index: global config with the named
+ * index's overrides layered on top. Unknown index → global defaults.
  */
-interface MindSyncBatchConfig {
-    maxSize: number;
-}
+declare function effectiveIndexConfig(config: MindConfig, indexId: string): EffectiveIndexConfig;
 /**
- * Mind synchronization configuration
+ * Merge a partial file config onto schema defaults. Always returns a fully
+ * populated, validated config.
  */
-interface MindSyncConfig {
-    registry: MindSyncRegistryConfig;
-    softDelete: MindSyncSoftDeleteConfig;
-    partialUpdates: MindSyncPartialUpdatesConfig;
-    batch: MindSyncBatchConfig;
-}
+declare function resolveMindConfig(input: MindConfigInput | undefined): MindConfig;
+
 /**
- * Mind source configuration
+ * Pipeline trace types — emitted per stage for debugging and Studio
+ * visualization of how a query flowed through retrieve → fuse → … → synthesize.
  */
-interface MindSourceConfig {
-    id: string;
-    paths: string[];
-    exclude?: string[];
-}
+
+declare const StageTraceSchema: z.ZodObject<{
+    /** Stage name, e.g. 'retrieve', 'fuse', 'rerank', 'verify', 'synthesize'. */
+    stage: z.ZodString;
+    /** Wall-clock duration of the stage, in milliseconds. */
+    durationMs: z.ZodNumber;
+    /** Number of items the stage produced (chunks, candidates, …). */
+    outputCount: z.ZodOptional<z.ZodNumber>;
+    /** Free-form, stage-specific detail (scores, weights, decisions). */
+    detail: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    stage: string;
+    durationMs: number;
+    outputCount?: number | undefined;
+    detail?: Record<string, unknown> | undefined;
+}, {
+    stage: string;
+    durationMs: number;
+    outputCount?: number | undefined;
+    detail?: Record<string, unknown> | undefined;
+}>;
+type StageTrace = z.infer<typeof StageTraceSchema>;
+declare const TraceSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    mode: z.ZodString;
+    totalMs: z.ZodNumber;
+    stages: z.ZodArray<z.ZodObject<{
+        /** Stage name, e.g. 'retrieve', 'fuse', 'rerank', 'verify', 'synthesize'. */
+        stage: z.ZodString;
+        /** Wall-clock duration of the stage, in milliseconds. */
+        durationMs: z.ZodNumber;
+        /** Number of items the stage produced (chunks, candidates, …). */
+        outputCount: z.ZodOptional<z.ZodNumber>;
+        /** Free-form, stage-specific detail (scores, weights, decisions). */
+        detail: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        stage: string;
+        durationMs: number;
+        outputCount?: number | undefined;
+        detail?: Record<string, unknown> | undefined;
+    }, {
+        stage: string;
+        durationMs: number;
+        outputCount?: number | undefined;
+        detail?: Record<string, unknown> | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    requestId: string;
+    mode: string;
+    totalMs: number;
+    stages: {
+        stage: string;
+        durationMs: number;
+        outputCount?: number | undefined;
+        detail?: Record<string, unknown> | undefined;
+    }[];
+}, {
+    requestId: string;
+    mode: string;
+    totalMs: number;
+    stages: {
+        stage: string;
+        durationMs: number;
+        outputCount?: number | undefined;
+        detail?: Record<string, unknown> | undefined;
+    }[];
+}>;
+type Trace = z.infer<typeof TraceSchema>;
+
 /**
- * Mind engine configuration
+ * Declarative CLI flag definitions for Mind commands (`defineFlags` from
+ * `@kb-labs/sdk`). Shared between the manifest and command handlers.
  */
-interface MindEngineConfig {
-    id: string;
-    type: string;
-    options?: Record<string, unknown>;
-}
+declare const indexFlags: _kb_labs_shared_command_kit.FlagSchemaWithInfer<{
+    index: {
+        type: "string";
+        description: string;
+        examples: string[];
+    };
+    scope: {
+        type: "string";
+        description: string;
+        examples: string[];
+    };
+    root: {
+        type: "string";
+        description: string;
+        examples: string[];
+    };
+    full: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+declare const searchFlags: _kb_labs_shared_command_kit.FlagSchemaWithInfer<{
+    text: {
+        type: "string";
+        description: string;
+        required: true;
+    };
+    index: {
+        type: "string";
+        description: string;
+    };
+    intent: {
+        type: "string";
+        description: string;
+        examples: string[];
+    };
+    limit: {
+        type: "number";
+        description: string;
+    };
+    snippet: {
+        type: "string";
+        description: string;
+        examples: string[];
+    };
+    format: {
+        type: "string";
+        description: string;
+        examples: string[];
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+declare const askFlags: _kb_labs_shared_command_kit.FlagSchemaWithInfer<{
+    text: {
+        type: "string";
+        description: string;
+        required: true;
+    };
+    index: {
+        type: "string";
+        description: string;
+    };
+    mode: {
+        type: "string";
+        description: string;
+        examples: string[];
+    };
+    snippet: {
+        type: "string";
+        description: string;
+        examples: string[];
+    };
+    format: {
+        type: "string";
+        description: string;
+        examples: string[];
+    };
+    agent: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+declare const exploreFlags: _kb_labs_shared_command_kit.FlagSchemaWithInfer<{
+    task: {
+        type: "string";
+        description: string;
+        required: true;
+    };
+    index: {
+        type: "string";
+        description: string;
+    };
+    limit: {
+        type: "number";
+        description: string;
+    };
+    format: {
+        type: "string";
+        description: string;
+        examples: string[];
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+declare const syncPathsFlags: _kb_labs_shared_command_kit.FlagSchemaWithInfer<{
+    index: {
+        type: "string";
+        description: string;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+declare const syncDeleteFlags: _kb_labs_shared_command_kit.FlagSchemaWithInfer<{
+    index: {
+        type: "string";
+        description: string;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+declare const syncListFlags: _kb_labs_shared_command_kit.FlagSchemaWithInfer<{
+    index: {
+        type: "string";
+        description: string;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+declare const reindexFlags: _kb_labs_shared_command_kit.FlagSchemaWithInfer<{
+    index: {
+        type: "string";
+        description: string;
+    };
+    full: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+declare const statusFlags: _kb_labs_shared_command_kit.FlagSchemaWithInfer<{
+    index: {
+        type: "string";
+        description: string;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+declare const dropFlags: _kb_labs_shared_command_kit.FlagSchemaWithInfer<{
+    index: {
+        type: "string";
+        description: string;
+        required: true;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    json: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+type IndexFlags = typeof indexFlags.infer;
+type SearchFlags = typeof searchFlags.infer;
+type AskFlags = typeof askFlags.infer;
+type ExploreFlags = typeof exploreFlags.infer;
+type SyncPathsFlags = typeof syncPathsFlags.infer;
+type SyncDeleteFlags = typeof syncDeleteFlags.infer;
+type SyncListFlags = typeof syncListFlags.infer;
+type ReindexFlags = typeof reindexFlags.infer;
+type StatusFlags = typeof statusFlags.infer;
+type DropFlags = typeof dropFlags.infer;
+
 /**
- * Mind scope configuration
+ * Agent response contract — lean, pointers-not-payloads.
+ *
+ * Designed for an agent solving a task whose context must not be cluttered:
+ * answer + source POINTERS (file + line range the agent can open itself) +
+ * trust signals (confidence/abstained) + provenance (matchedBy) + freshness
+ * (stale). Telemetry lives in `meta`. A snapshot test gates this shape.
  */
-interface MindScopeConfig {
-    id: string;
-    sourceIds?: string[];
-    defaultEngine?: string;
-    include?: string[];
-    exclude?: string[];
-}
+
+declare const AgentQueryModeSchema: z.ZodEnum<["instant", "auto", "thinking"]>;
+type AgentQueryMode = z.infer<typeof AgentQueryModeSchema>;
+declare const AgentSourceKindSchema: z.ZodEnum<["file", "doc", "adr", "repo", "code", "config", "external"]>;
+type AgentSourceKind = z.infer<typeof AgentSourceKindSchema>;
+/** Which retrieval signal surfaced a result — the "why" + proof-of-value vs grep. */
+declare const MatchedBySchema: z.ZodEnum<["lexical", "semantic", "both"]>;
+type MatchedBy = z.infer<typeof MatchedBySchema>;
+declare const AgentWarningSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    details?: Record<string, unknown> | undefined;
+}, {
+    code: string;
+    message: string;
+    details?: Record<string, unknown> | undefined;
+}>;
+type AgentWarning = z.infer<typeof AgentWarningSchema>;
+/** A source pointer. `snippet` rides only when the caller asks (`--snippet`). */
+declare const AgentSourceSchema: z.ZodObject<{
+    file: z.ZodString;
+    lines: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    kind: z.ZodEnum<["file", "doc", "adr", "repo", "code", "config", "external"]>;
+    matchedBy: z.ZodEnum<["lexical", "semantic", "both"]>;
+    /** On-disk content drifted from the index → agent should re-read the live file. */
+    stale: z.ZodBoolean;
+    snippet: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    file: string;
+    lines: [number, number];
+    kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+    matchedBy: "lexical" | "semantic" | "both";
+    stale: boolean;
+    snippet?: string | undefined;
+}, {
+    file: string;
+    lines: [number, number];
+    kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+    matchedBy: "lexical" | "semantic" | "both";
+    stale: boolean;
+    snippet?: string | undefined;
+}>;
+type AgentSource = z.infer<typeof AgentSourceSchema>;
+/** Telemetry container — agents ignore it; humans/observability use it. */
+declare const AgentMetaSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    mode: z.ZodEnum<["instant", "auto", "thinking"]>;
+    timingMs: z.ZodNumber;
+    indexId: z.ZodString;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    requestId: z.ZodString;
+    mode: z.ZodEnum<["instant", "auto", "thinking"]>;
+    timingMs: z.ZodNumber;
+    indexId: z.ZodString;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    requestId: z.ZodString;
+    mode: z.ZodEnum<["instant", "auto", "thinking"]>;
+    timingMs: z.ZodNumber;
+    indexId: z.ZodString;
+}, z.ZodTypeAny, "passthrough">>;
+type AgentMeta = z.infer<typeof AgentMetaSchema>;
+declare const AgentResponseSchema: z.ZodObject<{
+    answer: z.ZodString;
+    confidence: z.ZodNumber;
+    /** True when confidence is below floor / no usable sources — do not trust the answer. */
+    abstained: z.ZodBoolean;
+    sources: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        lines: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        kind: z.ZodEnum<["file", "doc", "adr", "repo", "code", "config", "external"]>;
+        matchedBy: z.ZodEnum<["lexical", "semantic", "both"]>;
+        /** On-disk content drifted from the index → agent should re-read the live file. */
+        stale: z.ZodBoolean;
+        snippet: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        lines: [number, number];
+        kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        snippet?: string | undefined;
+    }, {
+        file: string;
+        lines: [number, number];
+        kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        snippet?: string | undefined;
+    }>, "many">;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }, {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        mode: z.ZodEnum<["instant", "auto", "thinking"]>;
+        timingMs: z.ZodNumber;
+        indexId: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        requestId: z.ZodString;
+        mode: z.ZodEnum<["instant", "auto", "thinking"]>;
+        timingMs: z.ZodNumber;
+        indexId: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        requestId: z.ZodString;
+        mode: z.ZodEnum<["instant", "auto", "thinking"]>;
+        timingMs: z.ZodNumber;
+        indexId: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    answer: string;
+    abstained: boolean;
+    sources: {
+        file: string;
+        lines: [number, number];
+        kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        snippet?: string | undefined;
+    }[];
+    meta: {
+        requestId: string;
+        mode: "instant" | "auto" | "thinking";
+        timingMs: number;
+        indexId: string;
+    } & {
+        [k: string]: unknown;
+    };
+    warnings?: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }[] | undefined;
+}, {
+    confidence: number;
+    answer: string;
+    abstained: boolean;
+    sources: {
+        file: string;
+        lines: [number, number];
+        kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        snippet?: string | undefined;
+    }[];
+    meta: {
+        requestId: string;
+        mode: "instant" | "auto" | "thinking";
+        timingMs: number;
+        indexId: string;
+    } & {
+        [k: string]: unknown;
+    };
+    warnings?: {
+        code: string;
+        message: string;
+        details?: Record<string, unknown> | undefined;
+    }[] | undefined;
+}>;
+type AgentResponse = z.infer<typeof AgentResponseSchema>;
+declare const AgentErrorResponseSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        recoverable: boolean;
+    }, {
+        code: string;
+        message: string;
+        recoverable: boolean;
+    }>;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        mode: z.ZodEnum<["instant", "auto", "thinking"]>;
+        timingMs: z.ZodNumber;
+        indexId: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        requestId: z.ZodString;
+        mode: z.ZodEnum<["instant", "auto", "thinking"]>;
+        timingMs: z.ZodNumber;
+        indexId: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        requestId: z.ZodString;
+        mode: z.ZodEnum<["instant", "auto", "thinking"]>;
+        timingMs: z.ZodNumber;
+        indexId: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+    meta: {
+        requestId: string;
+        mode: "instant" | "auto" | "thinking";
+        timingMs: number;
+        indexId: string;
+    } & {
+        [k: string]: unknown;
+    };
+    error: {
+        code: string;
+        message: string;
+        recoverable: boolean;
+    };
+}, {
+    meta: {
+        requestId: string;
+        mode: "instant" | "auto" | "thinking";
+        timingMs: number;
+        indexId: string;
+    } & {
+        [k: string]: unknown;
+    };
+    error: {
+        code: string;
+        message: string;
+        recoverable: boolean;
+    };
+}>;
+type AgentErrorResponse = z.infer<typeof AgentErrorResponseSchema>;
+/** Confidence bands (used by the task-rag skill to decide trust). */
+declare const CONFIDENCE_THRESHOLDS: {
+    readonly high: 0.8;
+    readonly medium: 0.6;
+    readonly low: 0.3;
+};
+
 /**
- * Mind defaults configuration
+ * `search` wire contract (CLI `mind search` / REST `POST /search`).
+ *
+ * Lean, sources-first: ordered pointers (no raw score — order is the rank),
+ * with provenance (`matchedBy`) and freshness (`stale`). Telemetry in `meta`.
  */
-interface MindDefaultsConfig {
-    fallbackEngineId?: string;
-}
+
+/** How much source text rides in the response (context-economy knob). */
+declare const SnippetModeSchema: z.ZodEnum<["none", "line", "full"]>;
+type SnippetMode = z.infer<typeof SnippetModeSchema>;
+declare const SearchRequestSchema: z.ZodObject<{
+    text: z.ZodString;
+    indexId: z.ZodOptional<z.ZodString>;
+    /** Optional query-intent hint for adaptive fusion weights. */
+    intent: z.ZodOptional<z.ZodEnum<["lookup", "concept", "architecture"]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    snippet: z.ZodOptional<z.ZodEnum<["none", "line", "full"]>>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    limit?: number | undefined;
+    intent?: "lookup" | "concept" | "architecture" | undefined;
+    snippet?: "full" | "none" | "line" | undefined;
+    indexId?: string | undefined;
+}, {
+    text: string;
+    limit?: number | undefined;
+    intent?: "lookup" | "concept" | "architecture" | undefined;
+    snippet?: "full" | "none" | "line" | undefined;
+    indexId?: string | undefined;
+}>;
+type SearchRequest = z.infer<typeof SearchRequestSchema>;
+declare const SearchResultSchema: z.ZodObject<{
+    file: z.ZodString;
+    lines: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    kind: z.ZodEnum<["file", "doc", "adr", "repo", "code", "config", "external"]>;
+    matchedBy: z.ZodEnum<["lexical", "semantic", "both"]>;
+    stale: z.ZodBoolean;
+    snippet: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    file: string;
+    lines: [number, number];
+    kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+    matchedBy: "lexical" | "semantic" | "both";
+    stale: boolean;
+    snippet?: string | undefined;
+}, {
+    file: string;
+    lines: [number, number];
+    kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+    matchedBy: "lexical" | "semantic" | "both";
+    stale: boolean;
+    snippet?: string | undefined;
+}>;
+type SearchResult = z.infer<typeof SearchResultSchema>;
+declare const SearchMetaSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    timingMs: z.ZodNumber;
+    /** Share of results found semantic-only (grep would miss) — proof of value. */
+    semanticWinRate: z.ZodNumber;
+    /** How many returned results have drifted on disk since indexing. */
+    staleCount: z.ZodNumber;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    requestId: z.ZodString;
+    timingMs: z.ZodNumber;
+    /** Share of results found semantic-only (grep would miss) — proof of value. */
+    semanticWinRate: z.ZodNumber;
+    /** How many returned results have drifted on disk since indexing. */
+    staleCount: z.ZodNumber;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    requestId: z.ZodString;
+    timingMs: z.ZodNumber;
+    /** Share of results found semantic-only (grep would miss) — proof of value. */
+    semanticWinRate: z.ZodNumber;
+    /** How many returned results have drifted on disk since indexing. */
+    staleCount: z.ZodNumber;
+}, z.ZodTypeAny, "passthrough">>;
+type SearchMeta = z.infer<typeof SearchMetaSchema>;
+declare const SearchResponseSchema: z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        lines: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        kind: z.ZodEnum<["file", "doc", "adr", "repo", "code", "config", "external"]>;
+        matchedBy: z.ZodEnum<["lexical", "semantic", "both"]>;
+        stale: z.ZodBoolean;
+        snippet: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        lines: [number, number];
+        kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        snippet?: string | undefined;
+    }, {
+        file: string;
+        lines: [number, number];
+        kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        snippet?: string | undefined;
+    }>, "many">;
+    /** Overall retrieval relevance (0..1) — "did this index have anything for me". */
+    confidence: z.ZodNumber;
+    indexId: z.ZodString;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        timingMs: z.ZodNumber;
+        /** Share of results found semantic-only (grep would miss) — proof of value. */
+        semanticWinRate: z.ZodNumber;
+        /** How many returned results have drifted on disk since indexing. */
+        staleCount: z.ZodNumber;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        requestId: z.ZodString;
+        timingMs: z.ZodNumber;
+        /** Share of results found semantic-only (grep would miss) — proof of value. */
+        semanticWinRate: z.ZodNumber;
+        /** How many returned results have drifted on disk since indexing. */
+        staleCount: z.ZodNumber;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        requestId: z.ZodString;
+        timingMs: z.ZodNumber;
+        /** Share of results found semantic-only (grep would miss) — proof of value. */
+        semanticWinRate: z.ZodNumber;
+        /** How many returned results have drifted on disk since indexing. */
+        staleCount: z.ZodNumber;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    indexId: string;
+    meta: {
+        requestId: string;
+        timingMs: number;
+        semanticWinRate: number;
+        staleCount: number;
+    } & {
+        [k: string]: unknown;
+    };
+    results: {
+        file: string;
+        lines: [number, number];
+        kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        snippet?: string | undefined;
+    }[];
+}, {
+    confidence: number;
+    indexId: string;
+    meta: {
+        requestId: string;
+        timingMs: number;
+        semanticWinRate: number;
+        staleCount: number;
+    } & {
+        [k: string]: unknown;
+    };
+    results: {
+        file: string;
+        lines: [number, number];
+        kind: "code" | "file" | "doc" | "adr" | "repo" | "config" | "external";
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        snippet?: string | undefined;
+    }[];
+}>;
+type SearchResponse = z.infer<typeof SearchResponseSchema>;
+
 /**
- * Canonical Mind configuration input
+ * `index` and `reindex` wire contracts.
  */
-interface MindConfigInput {
-    sources: MindSourceConfig[];
-    scopes: MindScopeConfig[];
-    engines: MindEngineConfig[];
-    defaults?: MindDefaultsConfig;
-}
+
+declare const IndexRequestSchema: z.ZodObject<{
+    /** Index/corpus id; defaults to config.defaultIndex. */
+    indexId: z.ZodOptional<z.ZodString>;
+    /** Glob/path scope to index; defaults to the whole workspace. */
+    scope: z.ZodOptional<z.ZodString>;
+    /** Full rebuild instead of incremental delta. */
+    full: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    scope?: string | undefined;
+    full?: boolean | undefined;
+    indexId?: string | undefined;
+}, {
+    scope?: string | undefined;
+    full?: boolean | undefined;
+    indexId?: string | undefined;
+}>;
+type IndexRequest = z.infer<typeof IndexRequestSchema>;
+declare const IndexResponseSchema: z.ZodObject<{
+    indexId: z.ZodString;
+    filesIndexed: z.ZodNumber;
+    chunks: z.ZodNumber;
+    durationMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    durationMs: number;
+    indexId: string;
+    filesIndexed: number;
+    chunks: number;
+}, {
+    durationMs: number;
+    indexId: string;
+    filesIndexed: number;
+    chunks: number;
+}>;
+type IndexResponse = z.infer<typeof IndexResponseSchema>;
+declare const ReindexRequestSchema: z.ZodObject<{
+    indexId: z.ZodOptional<z.ZodString>;
+    full: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    full?: boolean | undefined;
+    indexId?: string | undefined;
+}, {
+    full?: boolean | undefined;
+    indexId?: string | undefined;
+}>;
+type ReindexRequest = z.infer<typeof ReindexRequestSchema>;
+
 /**
- * Mind configuration with sync section
+ * `query` (agent) wire contract. Response is the frozen `AgentResponse`.
  */
-interface MindConfig extends MindConfigInput {
-    /**
-     * Synchronization settings for Mind
-     */
-    sync?: MindSyncConfig;
-}
+
+declare const QueryRequestSchema: z.ZodObject<{
+    text: z.ZodString;
+    indexId: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodEnum<["instant", "auto", "thinking"]>>;
+    snippet: z.ZodOptional<z.ZodEnum<["none", "line", "full"]>>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    mode?: "instant" | "auto" | "thinking" | undefined;
+    snippet?: "full" | "none" | "line" | undefined;
+    indexId?: string | undefined;
+}, {
+    text: string;
+    mode?: "instant" | "auto" | "thinking" | undefined;
+    snippet?: "full" | "none" | "line" | undefined;
+    indexId?: string | undefined;
+}>;
+type QueryRequest = z.infer<typeof QueryRequestSchema>;
+
+/**
+ * `explore` wire contract (CLI `mind explore` / REST `POST /explore`).
+ *
+ * Task-orientation: given a task, return the relevant files (ranked, grounded by
+ * retrieval) plus an LLM-synthesized orientation — "where to start / how
+ * involved this is". No hardcoded role heuristics: ranking comes from retrieval,
+ * the orientation comes from the model, structure (`spread`) from the paths.
+ */
+
+declare const ExploreRequestSchema: z.ZodObject<{
+    task: z.ZodString;
+    indexId: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    task: string;
+    limit?: number | undefined;
+    indexId?: string | undefined;
+}, {
+    task: string;
+    limit?: number | undefined;
+    indexId?: string | undefined;
+}>;
+type ExploreRequest = z.infer<typeof ExploreRequestSchema>;
+declare const ExploreEntrySchema: z.ZodObject<{
+    file: z.ZodString;
+    lines: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    /** What was matched here — the representative line (from retrieval, not rules). */
+    why: z.ZodString;
+    matchedBy: z.ZodEnum<["lexical", "semantic", "both"]>;
+    stale: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    file: string;
+    lines: [number, number];
+    matchedBy: "lexical" | "semantic" | "both";
+    stale: boolean;
+    why: string;
+}, {
+    file: string;
+    lines: [number, number];
+    matchedBy: "lexical" | "semantic" | "both";
+    stale: boolean;
+    why: string;
+}>;
+type ExploreEntry = z.infer<typeof ExploreEntrySchema>;
+declare const ExploreMetaSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    timingMs: z.ZodNumber;
+    /** Distinct files in the map. */
+    filesTouched: z.ZodNumber;
+    /** Distinct directories the files span — a structural "how spread out" hint. */
+    spread: z.ZodNumber;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    requestId: z.ZodString;
+    timingMs: z.ZodNumber;
+    /** Distinct files in the map. */
+    filesTouched: z.ZodNumber;
+    /** Distinct directories the files span — a structural "how spread out" hint. */
+    spread: z.ZodNumber;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    requestId: z.ZodString;
+    timingMs: z.ZodNumber;
+    /** Distinct files in the map. */
+    filesTouched: z.ZodNumber;
+    /** Distinct directories the files span — a structural "how spread out" hint. */
+    spread: z.ZodNumber;
+}, z.ZodTypeAny, "passthrough">>;
+type ExploreMeta = z.infer<typeof ExploreMetaSchema>;
+declare const ExploreResponseSchema: z.ZodObject<{
+    task: z.ZodString;
+    indexId: z.ZodString;
+    confidence: z.ZodNumber;
+    /** Model-synthesized orientation: where to start + how involved (empty if no LLM). */
+    summary: z.ZodString;
+    /** Relevant files, best-ranked first. */
+    files: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        lines: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        /** What was matched here — the representative line (from retrieval, not rules). */
+        why: z.ZodString;
+        matchedBy: z.ZodEnum<["lexical", "semantic", "both"]>;
+        stale: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        lines: [number, number];
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        why: string;
+    }, {
+        file: string;
+        lines: [number, number];
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        why: string;
+    }>, "many">;
+    meta: z.ZodObject<{
+        requestId: z.ZodString;
+        timingMs: z.ZodNumber;
+        /** Distinct files in the map. */
+        filesTouched: z.ZodNumber;
+        /** Distinct directories the files span — a structural "how spread out" hint. */
+        spread: z.ZodNumber;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        requestId: z.ZodString;
+        timingMs: z.ZodNumber;
+        /** Distinct files in the map. */
+        filesTouched: z.ZodNumber;
+        /** Distinct directories the files span — a structural "how spread out" hint. */
+        spread: z.ZodNumber;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        requestId: z.ZodString;
+        timingMs: z.ZodNumber;
+        /** Distinct files in the map. */
+        filesTouched: z.ZodNumber;
+        /** Distinct directories the files span — a structural "how spread out" hint. */
+        spread: z.ZodNumber;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    task: string;
+    indexId: string;
+    meta: {
+        requestId: string;
+        timingMs: number;
+        filesTouched: number;
+        spread: number;
+    } & {
+        [k: string]: unknown;
+    };
+    summary: string;
+    files: {
+        file: string;
+        lines: [number, number];
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        why: string;
+    }[];
+}, {
+    confidence: number;
+    task: string;
+    indexId: string;
+    meta: {
+        requestId: string;
+        timingMs: number;
+        filesTouched: number;
+        spread: number;
+    } & {
+        [k: string]: unknown;
+    };
+    summary: string;
+    files: {
+        file: string;
+        lines: [number, number];
+        matchedBy: "lexical" | "semantic" | "both";
+        stale: boolean;
+        why: string;
+    }[];
+}>;
+type ExploreResponse = z.infer<typeof ExploreResponseSchema>;
+
+/**
+ * `drop` wire contract (CLI `mind drop` / REST `DELETE /index`).
+ *
+ * Removes an entire index: all its vectors (by namespace=indexId) plus its
+ * manifest. Distinct from `sync delete` (which removes specific documents) and
+ * from `reindex --full` (which rebuilds in place).
+ */
+
+declare const DropRequestSchema: z.ZodObject<{
+    indexId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    indexId: string;
+}, {
+    indexId: string;
+}>;
+type DropRequest = z.infer<typeof DropRequestSchema>;
+declare const DropResponseSchema: z.ZodObject<{
+    indexId: z.ZodString;
+    /** Vectors removed from the store. */
+    droppedChunks: z.ZodNumber;
+    /** Documents that were in the manifest. */
+    droppedFiles: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    indexId: string;
+    droppedChunks: number;
+    droppedFiles: number;
+}, {
+    indexId: string;
+    droppedChunks: number;
+    droppedFiles: number;
+}>;
+type DropResponse = z.infer<typeof DropResponseSchema>;
+
 /**
- * Default sync configuration
+ * `sync` wire contracts (add / update / delete / list / status).
  */
-declare const defaultMindSyncConfig: MindSyncConfig;
 
-export { type MindConfig, type MindConfigInput, type MindDefaultsConfig, type MindEngineConfig, type MindScopeConfig, type MindSourceConfig, type MindSyncBatchConfig, type MindSyncConfig, type MindSyncPartialUpdatesConfig, type MindSyncRegistryConfig, type MindSyncSoftDeleteConfig, defaultMindSyncConfig };
+declare const SyncAddRequestSchema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString, "many">;
+    indexId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    paths: string[];
+    indexId?: string | undefined;
+}, {
+    paths: string[];
+    indexId?: string | undefined;
+}>;
+type SyncAddRequest = z.infer<typeof SyncAddRequestSchema>;
+declare const SyncUpdateRequestSchema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString, "many">;
+    indexId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    paths: string[];
+    indexId?: string | undefined;
+}, {
+    paths: string[];
+    indexId?: string | undefined;
+}>;
+type SyncUpdateRequest = z.infer<typeof SyncUpdateRequestSchema>;
+declare const SyncDeleteRequestSchema: z.ZodObject<{
+    paths: z.ZodArray<z.ZodString, "many">;
+    indexId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    paths: string[];
+    indexId?: string | undefined;
+}, {
+    paths: string[];
+    indexId?: string | undefined;
+}>;
+type SyncDeleteRequest = z.infer<typeof SyncDeleteRequestSchema>;
+declare const SyncResponseSchema: z.ZodObject<{
+    indexId: z.ZodString;
+    added: z.ZodNumber;
+    updated: z.ZodNumber;
+    deleted: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    indexId: string;
+    added: number;
+    updated: number;
+    deleted: number;
+}, {
+    indexId: string;
+    added: number;
+    updated: number;
+    deleted: number;
+}>;
+type SyncResponse = z.infer<typeof SyncResponseSchema>;
+declare const SyncedDocumentSchema: z.ZodObject<{
+    path: z.ZodString;
+    chunks: z.ZodNumber;
+    indexedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    chunks: number;
+    indexedAt: string;
+}, {
+    path: string;
+    chunks: number;
+    indexedAt: string;
+}>;
+type SyncedDocument = z.infer<typeof SyncedDocumentSchema>;
+declare const SyncListResponseSchema: z.ZodObject<{
+    indexId: z.ZodString;
+    documents: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        chunks: z.ZodNumber;
+        indexedAt: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        chunks: number;
+        indexedAt: string;
+    }, {
+        path: string;
+        chunks: number;
+        indexedAt: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    indexId: string;
+    documents: {
+        path: string;
+        chunks: number;
+        indexedAt: string;
+    }[];
+}, {
+    indexId: string;
+    documents: {
+        path: string;
+        chunks: number;
+        indexedAt: string;
+    }[];
+}>;
+type SyncListResponse = z.infer<typeof SyncListResponseSchema>;
+declare const SyncStatusResponseSchema: z.ZodObject<{
+    indexId: z.ZodString;
+    documents: z.ZodNumber;
+    chunks: z.ZodNumber;
+    lastIndexedAt: z.ZodNullable<z.ZodString>;
+    stale: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    stale: boolean;
+    indexId: string;
+    chunks: number;
+    documents: number;
+    lastIndexedAt: string | null;
+}, {
+    stale: boolean;
+    indexId: string;
+    chunks: number;
+    documents: number;
+    lastIndexedAt: string | null;
+}>;
+type SyncStatusResponse = z.infer<typeof SyncStatusResponseSchema>;
+
+/**
+ * `status` and `health` wire contracts.
+ */
+
+declare const IndexSummarySchema: z.ZodObject<{
+    indexId: z.ZodString;
+    /** Human label + what the index covers (scope) — lets an agent pick the right corpus. */
+    label: z.ZodOptional<z.ZodString>;
+    coverage: z.ZodOptional<z.ZodString>;
+    documents: z.ZodNumber;
+    chunks: z.ZodNumber;
+    lastIndexedAt: z.ZodNullable<z.ZodString>;
+    /** How many indexed files have drifted on disk since indexing. */
+    staleCount: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    indexId: string;
+    staleCount: number;
+    chunks: number;
+    documents: number;
+    lastIndexedAt: string | null;
+    label?: string | undefined;
+    coverage?: string | undefined;
+}, {
+    indexId: string;
+    staleCount: number;
+    chunks: number;
+    documents: number;
+    lastIndexedAt: string | null;
+    label?: string | undefined;
+    coverage?: string | undefined;
+}>;
+type IndexSummary = z.infer<typeof IndexSummarySchema>;
+declare const StatusResponseSchema: z.ZodObject<{
+    indexes: z.ZodArray<z.ZodObject<{
+        indexId: z.ZodString;
+        /** Human label + what the index covers (scope) — lets an agent pick the right corpus. */
+        label: z.ZodOptional<z.ZodString>;
+        coverage: z.ZodOptional<z.ZodString>;
+        documents: z.ZodNumber;
+        chunks: z.ZodNumber;
+        lastIndexedAt: z.ZodNullable<z.ZodString>;
+        /** How many indexed files have drifted on disk since indexing. */
+        staleCount: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        indexId: string;
+        staleCount: number;
+        chunks: number;
+        documents: number;
+        lastIndexedAt: string | null;
+        label?: string | undefined;
+        coverage?: string | undefined;
+    }, {
+        indexId: string;
+        staleCount: number;
+        chunks: number;
+        documents: number;
+        lastIndexedAt: string | null;
+        label?: string | undefined;
+        coverage?: string | undefined;
+    }>, "many">;
+    healthy: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    indexes: {
+        indexId: string;
+        staleCount: number;
+        chunks: number;
+        documents: number;
+        lastIndexedAt: string | null;
+        label?: string | undefined;
+        coverage?: string | undefined;
+    }[];
+    healthy: boolean;
+}, {
+    indexes: {
+        indexId: string;
+        staleCount: number;
+        chunks: number;
+        documents: number;
+        lastIndexedAt: string | null;
+        label?: string | undefined;
+        coverage?: string | undefined;
+    }[];
+    healthy: boolean;
+}>;
+type StatusResponse = z.infer<typeof StatusResponseSchema>;
+declare const HealthResponseSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    vectorStore: z.ZodBoolean;
+    embeddings: z.ZodBoolean;
+    llm: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    vectorStore: boolean;
+    embeddings: boolean;
+    llm: boolean;
+}, {
+    ok: boolean;
+    vectorStore: boolean;
+    embeddings: boolean;
+    llm: boolean;
+}>;
+type HealthResponse = z.infer<typeof HealthResponseSchema>;
+
+export { type AgentErrorResponse, AgentErrorResponseSchema, type AgentMeta, AgentMetaSchema, type AgentQueryMode, AgentQueryModeSchema, type AgentResponse, AgentResponseSchema, type AgentSource, type AgentSourceKind, AgentSourceKindSchema, AgentSourceSchema, type AgentWarning, AgentWarningSchema, type AskFlags, CONFIDENCE_THRESHOLDS, type ChunkConfig, ChunkConfigSchema, ConfidenceConfigSchema, type DropFlags, type DropRequest, DropRequestSchema, type DropResponse, DropResponseSchema, type EffectiveIndexConfig, type ExploreEntry, ExploreEntrySchema, type ExploreFlags, type ExploreMeta, ExploreMetaSchema, type ExploreRequest, ExploreRequestSchema, type ExploreResponse, ExploreResponseSchema, type HealthResponse, HealthResponseSchema, type IndexConfig, IndexConfigSchema, type IndexFlags, type IndexRequest, IndexRequestSchema, type IndexResponse, IndexResponseSchema, type IndexScope, IndexScopeSchema, type IndexSummary, IndexSummarySchema, MIND_BASE_PATH, MIND_FULL_ROUTES, MIND_NAMESPACE_PREFIX, MIND_ROUTES, type MatchedBy, MatchedBySchema, type MindConfig, type MindConfigInput, MindConfigSchema, type ModeBudget, ModeBudgetSchema, ModesConfigSchema, type QueryRequest, QueryRequestSchema, type ReindexFlags, type ReindexRequest, ReindexRequestSchema, type ResolvedScope, type RetrievalConfig, RetrievalConfigSchema, type SearchFlags, type SearchMeta, SearchMetaSchema, type SearchRequest, SearchRequestSchema, type SearchResponse, SearchResponseSchema, type SearchResult, SearchResultSchema, type SnippetMode, SnippetModeSchema, type StageTrace, StageTraceSchema, type StatusFlags, type StatusResponse, StatusResponseSchema, type SyncAddRequest, SyncAddRequestSchema, type SyncDeleteFlags, type SyncDeleteRequest, SyncDeleteRequestSchema, type SyncListFlags, type SyncListResponse, SyncListResponseSchema, type SyncPathsFlags, type SyncResponse, SyncResponseSchema, type SyncStatusResponse, SyncStatusResponseSchema, type SyncUpdateRequest, SyncUpdateRequestSchema, type SyncedDocument, SyncedDocumentSchema, type Trace, TraceSchema, askFlags, dropFlags, effectiveIndexConfig, exploreFlags, indexFlags, reindexFlags, resolveMindConfig, resolveScope, searchFlags, statusFlags, syncDeleteFlags, syncListFlags, syncPathsFlags };