@kb-labs/mind-contracts 2.93.0 → 2.96.0

package/dist/index.js

@@ -1,359 +1,428 @@
-// src/version.ts
-var contractsVersion = "1.0.0";
-var contractsSchemaId = "@kb-labs/mind-contracts/schema";
+import { z } from 'zod';
+import { defineFlags } from '@kb-labs/sdk';
 
-// src/contract.ts
-var pluginContractsManifest = {
-  schema: contractsSchemaId,
-  pluginId: "@kb-labs/mind",
-  contractsVersion,
-  artifacts: {},
-  commands: {
-    "mind:init": {
-      id: "mind:init",
-      description: "Initialise the Mind workspace structure.",
-      input: {
-        ref: "@kb-labs/mind-contracts/schema#MindInitCommandInputSchema",
-        format: "zod"
-      },
-      examples: ["kb mind init --force", "kb mind init --json"]
-    },
-    "mind:verify": {
-      id: "mind:verify",
-      description: "Validate Mind indexes and surface inconsistencies.",
-      input: {
-        ref: "@kb-labs/mind-contracts/schema#MindVerifyCommandInputSchema",
-        format: "zod"
-      },
-      output: {
-        ref: "@kb-labs/mind-contracts/schema#MindVerifyCommandOutputSchema",
-        format: "zod"
-      },
-      examples: ["kb mind verify", "kb mind verify --json"]
-    }
-  },
-  workflows: {},
-  api: {
-    rest: {
-      basePath: "/v1/plugins/mind",
-      routes: {
-        "mind.rest.verify": {
-          id: "mind.rest.verify",
-          method: "GET",
-          path: "/verify",
-          description: "Summarise index verification status for Studio dashboards.",
-          response: {
-            ref: "@kb-labs/mind-contracts/schema#MindVerifyResponseSchema",
-            format: "zod"
-          }
-        }
-      }
-    }
-  }
+// src/routes.ts
+var MIND_BASE_PATH = "/v1/plugins/mind";
+var MIND_ROUTES = {
+  INDEX: "/index",
+  SEARCH: "/search",
+  QUERY: "/query",
+  EXPLORE: "/explore",
+  DROP: "/index",
+  SYNC_ADD: "/sync/add",
+  SYNC_UPDATE: "/sync/update",
+  SYNC_DELETE: "/sync/delete",
+  SYNC_LIST: "/sync/list",
+  SYNC_STATUS: "/sync/status",
+  STATUS: "/status",
+  HEALTH: "/health",
+  REINDEX: "/reindex"
 };
-
-// src/types/config.ts
-var defaultMindSyncConfig = {
-  registry: {
-    type: "filesystem",
-    path: ".kb/mind/sync/registry.json"
-  },
-  softDelete: {
-    enabled: true,
-    ttlDays: 30
-  },
-  partialUpdates: {
-    enabled: true
-  },
-  batch: {
-    maxSize: 100
-  }
+var MIND_FULL_ROUTES = {
+  INDEX: `${MIND_BASE_PATH}${MIND_ROUTES.INDEX}`,
+  SEARCH: `${MIND_BASE_PATH}${MIND_ROUTES.SEARCH}`,
+  QUERY: `${MIND_BASE_PATH}${MIND_ROUTES.QUERY}`,
+  EXPLORE: `${MIND_BASE_PATH}${MIND_ROUTES.EXPLORE}`,
+  DROP: `${MIND_BASE_PATH}${MIND_ROUTES.DROP}`,
+  SYNC_ADD: `${MIND_BASE_PATH}${MIND_ROUTES.SYNC_ADD}`,
+  SYNC_UPDATE: `${MIND_BASE_PATH}${MIND_ROUTES.SYNC_UPDATE}`,
+  SYNC_DELETE: `${MIND_BASE_PATH}${MIND_ROUTES.SYNC_DELETE}`,
+  SYNC_LIST: `${MIND_BASE_PATH}${MIND_ROUTES.SYNC_LIST}`,
+  SYNC_STATUS: `${MIND_BASE_PATH}${MIND_ROUTES.SYNC_STATUS}`,
+  STATUS: `${MIND_BASE_PATH}${MIND_ROUTES.STATUS}`,
+  HEALTH: `${MIND_BASE_PATH}${MIND_ROUTES.HEALTH}`,
+  REINDEX: `${MIND_BASE_PATH}${MIND_ROUTES.REINDEX}`
 };
-
-// src/schema/contract.schema.ts
-import { z as z5 } from "zod";
-
-// src/schema/api.schema.ts
-import { z } from "zod";
-var schemaReferenceSchema = z.object({
-  ref: z.string().min(1),
-  format: z.enum(["zod", "json-schema", "openapi"]).optional(),
-  description: z.string().optional()
-});
-var restRouteContractSchema = z.object({
-  id: z.string().min(1),
-  method: z.string().min(1),
-  path: z.string().min(1),
-  description: z.string().optional(),
-  request: schemaReferenceSchema.optional(),
-  response: schemaReferenceSchema.optional(),
-  produces: z.array(z.string().min(1)).optional(),
-  consumes: z.array(z.string().min(1)).optional()
-});
-var restApiContractSchema = z.object({
-  basePath: z.string().min(1),
-  routes: z.record(restRouteContractSchema)
-});
-var apiContractSchema = z.object({
-  rest: restApiContractSchema.optional()
+var MIND_NAMESPACE_PREFIX = "mind:";
+var ChunkConfigSchema = z.object({
+  /** Target chunk size in tokens. */
+  maxTokens: z.number().int().positive().default(400),
+  /** Overlap between adjacent chunks, in tokens. */
+  overlapTokens: z.number().int().nonnegative().default(50),
+  /** Use AST-aware chunking where a parser exists (falls back to sliding window). */
+  ast: z.boolean().default(true)
 });
-
-// src/schema/artifacts.schema.ts
-import { z as z2 } from "zod";
-var artifactExampleSchema = z2.object({
-  summary: z2.string().optional(),
-  payload: z2.unknown().optional()
-});
-var artifactContractSchema = z2.object({
-  id: z2.string().min(1),
-  kind: z2.enum(["file", "json", "markdown", "binary", "dir", "log"]),
-  description: z2.string().optional(),
-  pathPattern: z2.string().min(1).optional(),
-  mediaType: z2.string().min(1).optional(),
-  schemaRef: z2.string().min(1).optional(),
-  example: artifactExampleSchema.optional()
-});
-var artifactsContractMapSchema = z2.record(artifactContractSchema);
-
-// src/schema/commands.schema.ts
-import { z as z3 } from "zod";
-var commandContractSchema = z3.object({
-  id: z3.string().min(1),
-  description: z3.string().optional(),
-  input: schemaReferenceSchema.optional(),
-  output: schemaReferenceSchema.optional(),
-  produces: z3.array(z3.string().min(1)).optional(),
-  consumes: z3.array(z3.string().min(1)).optional(),
-  examples: z3.array(z3.string().min(1)).optional()
-});
-var commandContractMapSchema = z3.record(commandContractSchema);
-
-// src/schema/workflows.schema.ts
-import { z as z4 } from "zod";
-var workflowStepSchema = z4.object({
-  id: z4.string().min(1),
-  description: z4.string().optional(),
-  commandId: z4.string().min(1).optional(),
-  consumes: z4.array(z4.string().min(1)).optional(),
-  produces: z4.array(z4.string().min(1)).optional()
-});
-var workflowContractSchema = z4.object({
-  id: z4.string().min(1),
-  description: z4.string().optional(),
-  consumes: z4.array(z4.string().min(1)).optional(),
-  produces: z4.array(z4.string().min(1)).optional(),
-  steps: z4.array(workflowStepSchema).optional()
-});
-var workflowContractMapSchema = z4.record(workflowContractSchema);
-
-// src/schema/contract.schema.ts
-var pluginContractsSchema = z5.object({
-  schema: z5.literal(contractsSchemaId),
-  pluginId: z5.string().min(1),
-  contractsVersion: z5.string().min(1),
-  artifacts: artifactsContractMapSchema,
-  commands: commandContractMapSchema.optional(),
-  workflows: workflowContractMapSchema.optional(),
-  api: apiContractSchema.optional()
-}).strict();
-function parsePluginContracts(input) {
-  return pluginContractsSchema.parse(input);
+var ModeBudgetSchema = z.object({
+  /** Max chunks fed into the answer stage. */
+  maxChunks: z.number().int().positive(),
+  /** Max sub-queries from decomposition (0 = no decomposition). */
+  maxSubqueries: z.number().int().nonnegative(),
+  /** Completeness-check iterations. */
+  maxIterations: z.number().int().nonnegative(),
+  /** Whether the synthesize stage calls the LLM. */
+  useLLM: z.boolean()
+});
+var ModesConfigSchema = z.object({
+  instant: ModeBudgetSchema.default({
+    maxChunks: 5,
+    maxSubqueries: 0,
+    maxIterations: 0,
+    useLLM: false
+  }),
+  auto: ModeBudgetSchema.default({
+    maxChunks: 8,
+    maxSubqueries: 3,
+    maxIterations: 1,
+    useLLM: true
+  }),
+  thinking: ModeBudgetSchema.default({
+    maxChunks: 12,
+    maxSubqueries: 5,
+    maxIterations: 3,
+    useLLM: true
+  })
+});
+var RetrievalConfigSchema = z.object({
+  /** Default number of results returned by `search`. */
+  limit: z.number().int().positive().default(10),
+  /** Reciprocal-rank-fusion constant. */
+  rrfK: z.number().int().positive().default(60),
+  /** Enable heuristic reranking of fused candidates. */
+  rerank: z.boolean().default(true),
+  /** Enable semantic dedup of retrieved chunks. */
+  dedup: z.boolean().default(true),
+  /**
+   * 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.boolean().default(false),
+  /**
+   * 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.boolean().default(false)
+});
+var ConfidenceConfigSchema = z.object({
+  /** Below this, agent answers abstain in strict mode. */
+  floor: z.number().min(0).max(1).default(0.3)
+});
+var IndexScopeSchema = z.union([
+  z.string(),
+  z.object({
+    include: z.array(z.string()).optional(),
+    exclude: z.array(z.string()).optional()
+  }).strict()
+]);
+function resolveScope(scope) {
+  if (scope === void 0) {
+    return { include: ["."], exclude: [] };
+  }
+  if (typeof scope === "string") {
+    return { include: [scope], exclude: [] };
+  }
+  return {
+    include: scope.include && scope.include.length > 0 ? scope.include : ["."],
+    exclude: scope.exclude ?? []
+  };
 }
+var IndexConfigSchema = z.object({
+  /** Path/glob or include/exclude set indexed into this index (CLI `--scope` overrides). */
+  scope: IndexScopeSchema.optional(),
+  /** Human label (optional, for status/UX). */
+  label: z.string().optional(),
+  /** Per-index chunk overrides; unset fields fall back to the global `chunk`. */
+  chunk: ChunkConfigSchema.partial().optional(),
+  /** Per-index retrieval overrides; unset fields fall back to global `retrieval`. */
+  retrieval: RetrievalConfigSchema.partial().optional()
+});
+var MindConfigSchema = z.object({
+  /** Default index used when a command omits `--index`. */
+  defaultIndex: z.string().default("default"),
+  /** Named indexes with per-index scope + overrides. */
+  indexes: z.record(z.string(), IndexConfigSchema).default({}),
+  chunk: ChunkConfigSchema.default({}),
+  retrieval: RetrievalConfigSchema.default({}),
+  modes: ModesConfigSchema.default({}),
+  confidence: ConfidenceConfigSchema.default({})
+});
+function effectiveIndexConfig(config, indexId) {
+  const idx = config.indexes[indexId];
+  return {
+    scope: resolveScope(idx?.scope),
+    chunk: { ...config.chunk, ...idx?.chunk },
+    retrieval: { ...config.retrieval, ...idx?.retrieval }
+  };
+}
+function resolveMindConfig(input) {
+  return MindConfigSchema.parse(input ?? {});
+}
+var StageTraceSchema = z.object({
+  /** Stage name, e.g. 'retrieve', 'fuse', 'rerank', 'verify', 'synthesize'. */
+  stage: z.string(),
+  /** Wall-clock duration of the stage, in milliseconds. */
+  durationMs: z.number(),
+  /** Number of items the stage produced (chunks, candidates, …). */
+  outputCount: z.number().optional(),
+  /** Free-form, stage-specific detail (scores, weights, decisions). */
+  detail: z.record(z.unknown()).optional()
+});
+var TraceSchema = z.object({
+  requestId: z.string(),
+  mode: z.string(),
+  totalMs: z.number(),
+  stages: z.array(StageTraceSchema)
+});
+var JSON_DESC = "Output JSON";
+var INDEX_DESC = "Index/corpus id";
+var FORMAT_DESC = "Output format";
+var SNIPPET_DESC = "How much source text per result";
+var indexFlags = defineFlags({
+  index: { type: "string", description: INDEX_DESC, examples: ["code", "docs"] },
+  scope: { type: "string", description: "Glob/path scope to index", examples: ["src/**", "docs/**"] },
+  root: { type: "string", description: "Project root to index (default: cwd)", examples: ["/path/to/repo"] },
+  full: { type: "boolean", description: "Full rebuild instead of incremental delta", default: false },
+  json: { type: "boolean", description: JSON_DESC, default: false }
+});
+var searchFlags = defineFlags({
+  text: { type: "string", description: "Query text", required: true },
+  index: { type: "string", description: `${INDEX_DESC} to search` },
+  intent: { type: "string", description: "Query intent hint", examples: ["lookup", "concept", "architecture"] },
+  limit: { type: "number", description: "Max results" },
+  snippet: { type: "string", description: SNIPPET_DESC, examples: ["none", "line", "full"] },
+  format: { type: "string", description: FORMAT_DESC, examples: ["text", "json"] },
+  json: { type: "boolean", description: `${JSON_DESC} (alias for --format json)`, default: false }
+});
+var askFlags = defineFlags({
+  text: { type: "string", description: "Question to answer", required: true },
+  index: { type: "string", description: `${INDEX_DESC} to query` },
+  mode: { type: "string", description: "Answer depth", examples: ["instant", "auto", "thinking"] },
+  snippet: { type: "string", description: SNIPPET_DESC, examples: ["none", "line", "full"] },
+  format: { type: "string", description: FORMAT_DESC, examples: ["text", "json"] },
+  agent: { type: "boolean", description: "Emit machine-readable agent JSON (alias for --format json)", default: false },
+  json: { type: "boolean", description: JSON_DESC, default: false }
+});
+var exploreFlags = defineFlags({
+  task: { type: "string", description: "The task to orient around", required: true },
+  index: { type: "string", description: `${INDEX_DESC} to explore` },
+  limit: { type: "number", description: "Max files in the map" },
+  format: { type: "string", description: FORMAT_DESC, examples: ["text", "json"] },
+  json: { type: "boolean", description: `${JSON_DESC} (alias for --format json)`, default: false }
+});
+var syncPathsFlags = defineFlags({
+  index: { type: "string", description: INDEX_DESC },
+  json: { type: "boolean", description: JSON_DESC, default: false }
+});
+var syncDeleteFlags = defineFlags({
+  index: { type: "string", description: INDEX_DESC },
+  yes: { type: "boolean", description: "Confirm deletion (recoverable via `kb mind sync add`)", default: false },
+  json: { type: "boolean", description: JSON_DESC, default: false }
+});
+var syncListFlags = defineFlags({
+  index: { type: "string", description: INDEX_DESC },
+  json: { type: "boolean", description: JSON_DESC, default: false }
+});
+var reindexFlags = defineFlags({
+  index: { type: "string", description: INDEX_DESC },
+  full: { type: "boolean", description: "Full rebuild", default: false },
+  json: { type: "boolean", description: JSON_DESC, default: false }
+});
+var statusFlags = defineFlags({
+  index: { type: "string", description: "Limit to a single index" },
+  json: { type: "boolean", description: JSON_DESC, default: false }
+});
+var dropFlags = defineFlags({
+  index: { type: "string", description: "Index to drop (vectors + manifest)", required: true },
+  yes: { type: "boolean", description: "Skip the confirmation prompt", default: false },
+  json: { type: "boolean", description: JSON_DESC, default: false }
+});
+var AgentQueryModeSchema = z.enum(["instant", "auto", "thinking"]);
+var AgentSourceKindSchema = z.enum(["file", "doc", "adr", "repo", "code", "config", "external"]);
+var MatchedBySchema = z.enum(["lexical", "semantic", "both"]);
+var AgentWarningSchema = z.object({
+  code: z.string(),
+  message: z.string(),
+  details: z.record(z.unknown()).optional()
+});
+var AgentSourceSchema = z.object({
+  file: z.string(),
+  lines: z.tuple([z.number(), z.number()]),
+  kind: AgentSourceKindSchema,
+  matchedBy: MatchedBySchema,
+  /** On-disk content drifted from the index → agent should re-read the live file. */
+  stale: z.boolean(),
+  snippet: z.string().optional()
+});
+var AgentMetaSchema = z.object({
+  requestId: z.string(),
+  mode: AgentQueryModeSchema,
+  timingMs: z.number(),
+  indexId: z.string()
+}).passthrough();
+var AgentResponseSchema = z.object({
+  answer: z.string(),
+  confidence: z.number(),
+  /** True when confidence is below floor / no usable sources — do not trust the answer. */
+  abstained: z.boolean(),
+  sources: z.array(AgentSourceSchema),
+  warnings: z.array(AgentWarningSchema).optional(),
+  meta: AgentMetaSchema
+});
+var AgentErrorResponseSchema = z.object({
+  error: z.object({ code: z.string(), message: z.string(), recoverable: z.boolean() }),
+  meta: AgentMetaSchema
+});
+var CONFIDENCE_THRESHOLDS = { high: 0.8, medium: 0.6, low: 0.3 };
+var SnippetModeSchema = z.enum(["none", "line", "full"]);
+var SearchRequestSchema = z.object({
+  text: z.string().min(1),
+  indexId: z.string().optional(),
+  /** Optional query-intent hint for adaptive fusion weights. */
+  intent: z.enum(["lookup", "concept", "architecture"]).optional(),
+  limit: z.coerce.number().int().positive().optional(),
+  // CLI passes strings; REST passes numbers
+  snippet: SnippetModeSchema.optional()
+});
+var SearchResultSchema = z.object({
+  file: z.string(),
+  lines: z.tuple([z.number(), z.number()]),
+  kind: AgentSourceKindSchema,
+  matchedBy: MatchedBySchema,
+  stale: z.boolean(),
+  snippet: z.string().optional()
+});
+var SearchMetaSchema = z.object({
+  requestId: z.string(),
+  timingMs: z.number(),
+  /** Share of results found semantic-only (grep would miss) — proof of value. */
+  semanticWinRate: z.number(),
+  /** How many returned results have drifted on disk since indexing. */
+  staleCount: z.number()
+}).passthrough();
+var SearchResponseSchema = z.object({
+  results: z.array(SearchResultSchema),
+  // ordered by rank
+  /** Overall retrieval relevance (0..1) — "did this index have anything for me". */
+  confidence: z.number(),
+  indexId: z.string(),
+  meta: SearchMetaSchema
+});
+var IndexRequestSchema = z.object({
+  /** Index/corpus id; defaults to config.defaultIndex. */
+  indexId: z.string().optional(),
+  /** Glob/path scope to index; defaults to the whole workspace. */
+  scope: z.string().optional(),
+  /** Full rebuild instead of incremental delta. */
+  full: z.boolean().optional()
+});
+var IndexResponseSchema = z.object({
+  indexId: z.string(),
+  filesIndexed: z.number(),
+  chunks: z.number(),
+  durationMs: z.number()
+});
+var ReindexRequestSchema = z.object({
+  indexId: z.string().optional(),
+  full: z.boolean().optional()
+});
+var QueryRequestSchema = z.object({
+  text: z.string().min(1),
+  indexId: z.string().optional(),
+  mode: AgentQueryModeSchema.optional(),
+  snippet: SnippetModeSchema.optional()
+});
+var ExploreRequestSchema = z.object({
+  task: z.string().min(1),
+  indexId: z.string().optional(),
+  limit: z.coerce.number().int().positive().optional()
+});
+var ExploreEntrySchema = z.object({
+  file: z.string(),
+  lines: z.tuple([z.number(), z.number()]),
+  /** What was matched here — the representative line (from retrieval, not rules). */
+  why: z.string(),
+  matchedBy: MatchedBySchema,
+  stale: z.boolean()
+});
+var ExploreMetaSchema = z.object({
+  requestId: z.string(),
+  timingMs: z.number(),
+  /** Distinct files in the map. */
+  filesTouched: z.number(),
+  /** Distinct directories the files span — a structural "how spread out" hint. */
+  spread: z.number()
+}).passthrough();
+var ExploreResponseSchema = z.object({
+  task: z.string(),
+  indexId: z.string(),
+  confidence: z.number(),
+  /** Model-synthesized orientation: where to start + how involved (empty if no LLM). */
+  summary: z.string(),
+  /** Relevant files, best-ranked first. */
+  files: z.array(ExploreEntrySchema),
+  meta: ExploreMetaSchema
+});
+var DropRequestSchema = z.object({
+  indexId: z.string().min(1)
+});
+var DropResponseSchema = z.object({
+  indexId: z.string(),
+  /** Vectors removed from the store. */
+  droppedChunks: z.number(),
+  /** Documents that were in the manifest. */
+  droppedFiles: z.number()
+});
+var indexIdField = z.string().optional();
+var SyncAddRequestSchema = z.object({
+  paths: z.array(z.string()).min(1),
+  indexId: indexIdField
+});
+var SyncUpdateRequestSchema = z.object({
+  paths: z.array(z.string()).min(1),
+  indexId: indexIdField
+});
+var SyncDeleteRequestSchema = z.object({
+  paths: z.array(z.string()).min(1),
+  indexId: indexIdField
+});
+var SyncResponseSchema = z.object({
+  indexId: z.string(),
+  added: z.number(),
+  updated: z.number(),
+  deleted: z.number()
+});
+var SyncedDocumentSchema = z.object({
+  path: z.string(),
+  chunks: z.number(),
+  indexedAt: z.string()
+});
+var SyncListResponseSchema = z.object({
+  indexId: z.string(),
+  documents: z.array(SyncedDocumentSchema)
+});
+var SyncStatusResponseSchema = z.object({
+  indexId: z.string(),
+  documents: z.number(),
+  chunks: z.number(),
+  lastIndexedAt: z.string().nullable(),
+  stale: z.boolean()
+});
+var IndexSummarySchema = z.object({
+  indexId: z.string(),
+  /** Human label + what the index covers (scope) — lets an agent pick the right corpus. */
+  label: z.string().optional(),
+  coverage: z.string().optional(),
+  documents: z.number(),
+  chunks: z.number(),
+  lastIndexedAt: z.string().nullable(),
+  /** How many indexed files have drifted on disk since indexing. */
+  staleCount: z.number()
+});
+var StatusResponseSchema = z.object({
+  indexes: z.array(IndexSummarySchema),
+  healthy: z.boolean()
+});
+var HealthResponseSchema = z.object({
+  ok: z.boolean(),
+  vectorStore: z.boolean(),
+  embeddings: z.boolean(),
+  llm: z.boolean()
+});
 
-// src/schema/mind.contracts.schema.ts
-import { z as z6 } from "zod";
-var commandCommonFlags = z6.object({
-  cwd: z6.string().min(1).optional(),
-  json: z6.boolean().optional(),
-  quiet: z6.boolean().optional(),
-  verbose: z6.boolean().optional()
-});
-var budgetEnvelopeSchema = z6.object({
-  usedMs: z6.number().nonnegative().optional(),
-  limitMs: z6.number().nonnegative().optional()
-});
-var MindInitCommandInputSchema = commandCommonFlags.extend({
-  force: z6.boolean().optional()
-});
-var MindUpdateCommandInputSchema = commandCommonFlags.extend({
-  since: z6.string().optional(),
-  "time-budget": z6.number().int().positive().optional(),
-  "no-cache": z6.boolean().optional()
-});
-var MindUpdateCommandOutputSchema = z6.object({
-  ok: z6.boolean(),
-  delta: z6.unknown().optional(),
-  budget: budgetEnvelopeSchema.optional(),
-  timing: z6.number().nonnegative().optional(),
-  code: z6.string().optional(),
-  message: z6.string().optional(),
-  hint: z6.string().optional()
-});
-var packIntentSchema = z6.object({
-  intent: z6.string().min(1),
-  product: z6.string().optional(),
-  preset: z6.string().optional(),
-  budget: z6.number().int().positive().optional(),
-  "with-bundle": z6.boolean().optional(),
-  out: z6.string().optional(),
-  seed: z6.number().int().optional()
-});
-var MindPackCommandInputSchema = commandCommonFlags.merge(packIntentSchema);
-var MindPackCommandOutputSchema = z6.object({
-  ok: z6.boolean(),
-  intent: z6.string().optional(),
-  product: z6.string().nullable().optional(),
-  tokensEstimate: z6.number().optional(),
-  sectionUsage: z6.record(z6.unknown()).optional(),
-  "with-bundle": z6.boolean().optional(),
-  seed: z6.number().optional(),
-  deterministic: z6.boolean().optional(),
-  timing: z6.number().nonnegative().optional(),
-  "pack-output": z6.string().optional(),
-  code: z6.string().optional(),
-  message: z6.string().optional(),
-  hint: z6.string().optional()
-});
-var MindFeedCommandInputSchema = commandCommonFlags.merge(packIntentSchema).extend({
-  "no-update": z6.boolean().optional(),
-  since: z6.string().optional(),
-  "time-budget": z6.number().int().positive().optional()
-});
-var MindFeedCommandOutputSchema = z6.object({
-  ok: z6.boolean(),
-  mode: z6.enum(["update-and-pack", "pack-only"]).optional(),
-  intent: z6.string().optional(),
-  product: z6.string().nullable().optional(),
-  tokensEstimate: z6.number().optional(),
-  out: z6.string().nullable().optional(),
-  update: z6.object({
-    delta: z6.unknown().optional(),
-    budget: budgetEnvelopeSchema.optional()
-  }).nullable().optional(),
-  pack: z6.object({
-    sectionUsage: z6.record(z6.unknown()).optional(),
-    deterministic: z6.boolean().optional()
-  }).optional(),
-  ignoredFlags: z6.array(z6.string()).optional(),
-  timing: z6.number().nonnegative().optional(),
-  "pack-output": z6.string().optional(),
-  code: z6.string().optional(),
-  message: z6.string().optional(),
-  hint: z6.string().optional()
-});
-var MindQueryCommandInputSchema = commandCommonFlags.extend({
-  query: z6.enum(["impact", "scope", "exports", "externals", "chain", "meta", "docs"]),
-  file: z6.string().optional(),
-  path: z6.string().optional(),
-  scope: z6.string().optional(),
-  limit: z6.number().int().positive().optional(),
-  depth: z6.number().int().positive().optional(),
-  "cache-ttl": z6.number().int().nonnegative().optional(),
-  "cache-mode": z6.enum(["ci", "local"]).optional(),
-  "no-cache": z6.boolean().optional(),
-  paths: z6.enum(["id", "absolute"]).optional(),
-  compact: z6.boolean().optional(),
-  "ai-mode": z6.boolean().optional(),
-  toon: z6.boolean().optional(),
-  "toon-sidecar": z6.boolean().optional(),
-  product: z6.string().optional(),
-  tag: z6.string().optional(),
-  type: z6.string().optional(),
-  filter: z6.string().optional()
-});
-var MindQueryCommandOutputSchema = z6.object({
-  ok: z6.boolean().optional(),
-  format: z6.enum(["json", "toon"]).optional(),
-  content: z6.union([z6.string(), z6.record(z6.unknown())]).optional(),
-  error: z6.string().optional()
-});
-var MindVerifyCommandInputSchema = commandCommonFlags.extend({
-  cwd: z6.string().optional()
-});
-var MindVerifyCommandOutputSchema = z6.object({
-  ok: z6.boolean(),
-  code: z6.string().nullable().optional(),
-  inconsistencies: z6.array(
-    z6.object({
-      file: z6.string().optional(),
-      expected: z6.string().optional(),
-      actual: z6.string().optional(),
-      type: z6.string().optional()
-    })
-  ).optional(),
-  hint: z6.string().optional(),
-  schemaVersion: z6.string().optional(),
-  meta: z6.object({
-    cwd: z6.string().optional(),
-    filesChecked: z6.number().optional(),
-    timingMs: z6.number().optional()
-  }).optional()
-});
-var MindQueryRequestSchema = z6.object({
-  query: z6.string().min(1),
-  params: z6.record(z6.unknown()).optional().default({}),
-  options: z6.object({
-    cwd: z6.string().optional(),
-    limit: z6.number().optional(),
-    depth: z6.number().optional(),
-    cacheTtl: z6.number().optional(),
-    cacheMode: z6.enum(["local", "ci"]).optional(),
-    noCache: z6.boolean().optional(),
-    pathMode: z6.enum(["id", "absolute"]).optional(),
-    aiMode: z6.boolean().optional()
-  }).optional()
-});
-var MindQueryResponseSchema = z6.object({
-  sections: z6.array(
-    z6.object({
-      title: z6.string(),
-      format: z6.string().optional(),
-      data: z6.unknown(),
-      collapsible: z6.boolean().optional()
-    })
-  )
-});
-var MindVerifyResponseSchema = z6.object({
-  cards: z6.array(
-    z6.object({
-      title: z6.string(),
-      content: z6.string(),
-      status: z6.string().optional()
-    })
-  )
-});
-export {
-  MindFeedCommandInputSchema,
-  MindFeedCommandOutputSchema,
-  MindInitCommandInputSchema,
-  MindPackCommandInputSchema,
-  MindPackCommandOutputSchema,
-  MindQueryCommandInputSchema,
-  MindQueryCommandOutputSchema,
-  MindQueryRequestSchema,
-  MindQueryResponseSchema,
-  MindUpdateCommandInputSchema,
-  MindUpdateCommandOutputSchema,
-  MindVerifyCommandInputSchema,
-  MindVerifyCommandOutputSchema,
-  MindVerifyResponseSchema,
-  apiContractSchema,
-  artifactContractSchema,
-  artifactExampleSchema,
-  artifactsContractMapSchema,
-  commandContractMapSchema,
-  commandContractSchema,
-  contractsSchemaId,
-  contractsVersion,
-  defaultMindSyncConfig,
-  parsePluginContracts,
-  pluginContractsManifest,
-  pluginContractsSchema,
-  restApiContractSchema,
-  restRouteContractSchema,
-  schemaReferenceSchema,
-  workflowContractMapSchema,
-  workflowContractSchema,
-  workflowStepSchema
-};
+export { AgentErrorResponseSchema, AgentMetaSchema, AgentQueryModeSchema, AgentResponseSchema, AgentSourceKindSchema, AgentSourceSchema, AgentWarningSchema, CONFIDENCE_THRESHOLDS, ChunkConfigSchema, ConfidenceConfigSchema, DropRequestSchema, DropResponseSchema, ExploreEntrySchema, ExploreMetaSchema, ExploreRequestSchema, ExploreResponseSchema, HealthResponseSchema, IndexConfigSchema, IndexRequestSchema, IndexResponseSchema, IndexScopeSchema, IndexSummarySchema, MIND_BASE_PATH, MIND_FULL_ROUTES, MIND_NAMESPACE_PREFIX, MIND_ROUTES, MatchedBySchema, MindConfigSchema, ModeBudgetSchema, ModesConfigSchema, QueryRequestSchema, ReindexRequestSchema, RetrievalConfigSchema, SearchMetaSchema, SearchRequestSchema, SearchResponseSchema, SearchResultSchema, SnippetModeSchema, StageTraceSchema, StatusResponseSchema, SyncAddRequestSchema, SyncDeleteRequestSchema, SyncListResponseSchema, SyncResponseSchema, SyncStatusResponseSchema, SyncUpdateRequestSchema, SyncedDocumentSchema, TraceSchema, askFlags, dropFlags, effectiveIndexConfig, exploreFlags, indexFlags, reindexFlags, resolveMindConfig, resolveScope, searchFlags, statusFlags, syncDeleteFlags, syncListFlags, syncPathsFlags };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map