@usewhisper/mcp-server 2.8.0 → 2.10.0

package/dist/server.js

@@ -6,7 +6,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 import { execSync, spawnSync } from "child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, appendFileSync } from "fs";
-import { join, relative, extname } from "path";
+import { join, relative, extname, normalize as normalizePath, resolve as resolvePath } from "path";
 import { homedir } from "os";
 import { createHash, randomUUID } from "crypto";
 
@@ -2089,9 +2089,33 @@ ${lines.join("\n")}`;
       }
     });
   }
+  async resolveLearningScope(overrides) {
+    const merged = {
+      ...this.baseContext,
+      ...overrides
+    };
+    const { scope } = await this.resolveScope(overrides);
+    return {
+      project: scope.project,
+      sessionId: merged.sessionId || scope.sessionId,
+      userId: merged.userId
+    };
+  }
   async afterTurn(input, context = {}) {
     this.pushTouchedFiles(input.touchedFiles);
-    const { scope } = await this.resolveScope(context);
+    if (input.auto_learn === false) {
+      return {
+        success: true,
+        sessionIngested: false,
+        memoriesCreated: 0,
+        relationsCreated: 0,
+        invalidatedCount: 0,
+        mergedCount: 0,
+        droppedCount: 0,
+        warnings: []
+      };
+    }
+    const scope = await this.resolveLearningScope(context);
     const result = await this.args.adapter.ingestSession({
       project: scope.project,
       session_id: scope.sessionId,
@@ -2474,6 +2498,19 @@ var WhisperClient = class _WhisperClient {
     });
     return response.data;
   }
+  async learn(params) {
+    const project = (await this.resolveProject(params.project)).id;
+    const response = await this.runtimeClient.request({
+      endpoint: "/v1/learn",
+      method: "POST",
+      operation: params.mode === "conversation" ? "session" : "bulk",
+      body: {
+        ...params,
+        project
+      }
+    });
+    return response.data;
+  }
   createAgentRuntime(options = {}) {
     const baseContext = {
       workspacePath: options.workspacePath,
@@ -2522,6 +2559,14 @@ var WhisperClient = class _WhisperClient {
           sessionId: params.sessionId || context.sessionId || ""
         })
       },
+      learn: (params) => base.learn({
+        ...params,
+        project: params.project || context.project || base.config.project,
+        ...params.mode === "conversation" ? {
+          user_id: params.user_id ?? context.userId,
+          session_id: params.session_id || context.sessionId || ""
+        } : {}
+      }),
       queue: base.queue,
       diagnostics: base.diagnostics
     };
@@ -2983,91 +3028,125 @@ var WhisperContext = class _WhisperContext {
     return this.request(`/v1/sources/${sourceId}/sync`, { method: "POST" });
   }
   async addSourceByType(projectId, params) {
-    return this.withProjectPathFallback(
-      this.getRequiredProject(projectId),
-      (projectPathRef) => this.request(`/v1/projects/${encodeURIComponent(projectPathRef)}/add_source`, {
-        method: "POST",
-        body: JSON.stringify(params)
-      })
-    );
+    const result = await this.learn({
+      mode: "source",
+      project: projectId,
+      type: "video",
+      name: params.name,
+      url: params.url,
+      platform: params.platform,
+      language: params.language,
+      options: {
+        async: true,
+        auto_index: params.auto_sync ?? true,
+        ingestion_profile: params.ingestion_profile,
+        strategy_override: params.strategy_override,
+        profile_config: params.profile_config,
+        allow_stt_fallback: params.allow_stt_fallback,
+        max_duration_minutes: params.max_duration_minutes
+      }
+    });
+    return {
+      source_id: result.source_id,
+      sync_job_id: result.job_id ?? null,
+      status: result.status === "processing" || result.status === "queued" ? result.status : "created"
+    };
   }
   async getSourceStatus(sourceId) {
     return this.request(`/v1/sources/${sourceId}/status`, { method: "GET" });
   }
   async createCanonicalSource(project, params) {
-    const connector_type = params.type === "github" ? "github" : params.type === "web" ? "website" : params.type === "pdf" ? "pdf" : params.type === "local" ? "local-folder" : "slack";
-    const config = {};
-    if (params.type === "github") {
-      if (!params.owner || !params.repo) throw new WhisperError({ code: "REQUEST_FAILED", message: "github source requires owner and repo" });
-      config.owner = params.owner;
-      config.repo = params.repo;
-      if (params.branch) config.branch = params.branch;
-      if (params.paths) config.paths = params.paths;
-    } else if (params.type === "web") {
-      if (!params.url) throw new WhisperError({ code: "REQUEST_FAILED", message: "web source requires url" });
-      config.url = params.url;
-      if (params.crawl_depth !== void 0) config.crawl_depth = params.crawl_depth;
-      if (params.include_paths) config.include_paths = params.include_paths;
-      if (params.exclude_paths) config.exclude_paths = params.exclude_paths;
-    } else if (params.type === "pdf") {
-      if (!params.url && !params.file_path) throw new WhisperError({ code: "REQUEST_FAILED", message: "pdf source requires url or file_path" });
-      if (params.url) config.url = params.url;
-      if (params.file_path) config.file_path = params.file_path;
-    } else if (params.type === "local") {
-      if (!params.path) throw new WhisperError({ code: "REQUEST_FAILED", message: "local source requires path" });
-      config.path = params.path;
-      if (params.glob) config.glob = params.glob;
-      if (params.max_files !== void 0) config.max_files = params.max_files;
-    } else {
-      config.channel_ids = params.channel_ids || [];
-      if (params.since) config.since = params.since;
-      if (params.workspace_id) config.workspace_id = params.workspace_id;
-      if (params.token) config.token = params.token;
-      if (params.auth_ref) config.auth_ref = params.auth_ref;
-    }
-    if (params.metadata) config.metadata = params.metadata;
-    if (params.ingestion_profile) config.ingestion_profile = params.ingestion_profile;
-    if (params.strategy_override) config.strategy_override = params.strategy_override;
-    if (params.profile_config) config.profile_config = params.profile_config;
-    config.auto_index = params.auto_index ?? true;
-    const created = await this.addSource(project, {
-      name: params.name || `${params.type}-source-${Date.now()}`,
-      connector_type,
-      config
+    const result = await this.learn({
+      mode: "source",
+      project,
+      type: params.type,
+      name: params.name,
+      metadata: params.metadata,
+      owner: params.owner,
+      repo: params.repo,
+      branch: params.branch,
+      paths: params.paths,
+      url: params.url,
+      file_path: params.file_path,
+      path: params.path,
+      channel_ids: params.channel_ids,
+      since: params.since,
+      token: params.token,
+      auth_ref: params.auth_ref,
+      platform: params.platform,
+      language: params.language,
+      options: {
+        async: true,
+        auto_index: params.auto_index ?? true,
+        ingestion_profile: params.ingestion_profile,
+        strategy_override: params.strategy_override,
+        profile_config: params.profile_config,
+        crawl_depth: params.crawl_depth,
+        include_paths: params.include_paths,
+        exclude_paths: params.exclude_paths,
+        glob: params.glob,
+        max_files: params.max_files,
+        max_pages: params.max_pages,
+        extract_mode: params.extract_mode,
+        workspace_id: params.workspace_id,
+        allow_stt_fallback: params.allow_stt_fallback,
+        max_duration_minutes: params.max_duration_minutes,
+        max_chunks: params.max_chunks
+      }
     });
-    let status = "queued";
-    let jobId = null;
-    if (params.auto_index ?? true) {
-      const syncRes = await this.syncSource(created.id);
-      status = "indexing";
-      jobId = String(syncRes?.id || syncRes?.job_id || "");
-    }
     return {
-      source_id: created.id,
-      status,
-      job_id: jobId,
-      index_started: params.auto_index ?? true,
+      source_id: result.source_id,
+      status: result.status === "processing" ? "indexing" : result.status === "created" ? "queued" : result.status,
+      job_id: result.job_id ?? null,
+      index_started: result.index_started,
       warnings: []
     };
   }
   async ingest(projectId, documents) {
-    return this.withProjectPathFallback(
-      this.getRequiredProject(projectId),
-      (projectPathRef) => this.request(`/v1/projects/${encodeURIComponent(projectPathRef)}/ingest`, {
-        method: "POST",
-        body: JSON.stringify({ documents })
-      })
+    await Promise.all(
+      documents.map(
+        (doc) => this.learn({
+          mode: "text",
+          project: projectId,
+          title: doc.title,
+          content: doc.content,
+          metadata: {
+            ...doc.metadata || {},
+            ...doc.file_path ? { file_path: doc.file_path } : {}
+          },
+          options: {
+            async: true,
+            ingestion_profile: doc.ingestion_profile,
+            strategy_override: doc.strategy_override,
+            profile_config: doc.profile_config
+          }
+        })
+      )
     );
+    return { ingested: documents.length };
   }
   async addContext(params) {
-    const projectId = (await this.resolveProject(this.getRequiredProject(params.project))).id;
-    return this.ingest(projectId, [
-      {
-        title: params.title || "Context",
-        content: params.content,
-        metadata: params.metadata || { source: "addContext" }
+    await this.learn({
+      mode: "text",
+      project: this.getRequiredProject(params.project),
+      title: params.title || "Context",
+      content: params.content,
+      metadata: params.metadata || { source: "addContext" },
+      options: {
+        async: true
       }
-    ]);
+    });
+    return { ingested: 1 };
+  }
+  async learn(params) {
+    const projectRef = this.getRequiredProject(params.project);
+    return this.withProjectRefFallback(projectRef, (project) => this.request("/v1/learn", {
+      method: "POST",
+      body: JSON.stringify({
+        ...params,
+        project
+      })
+    }));
   }
   async listMemories(params) {
     const projectRef = this.getRequiredProject(params.project);
@@ -3800,15 +3879,50 @@ function ensureStateDir() {
     mkdirSync(STATE_DIR, { recursive: true });
   }
 }
+function canonicalizeWorkspacePath(path, cwd = process.cwd()) {
+  const basePath = path?.trim() ? path.trim() : cwd;
+  const absolute = resolvePath(cwd, basePath);
+  const normalized = normalizePath(absolute).replace(/\\/g, "/");
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function chooseWorkspaceProjectSource(args) {
+  const explicitProject = args.explicitProject?.trim();
+  if (explicitProject) {
+    return { project_ref: explicitProject, resolved_by: "explicit_project" };
+  }
+  const workspaceProjectRef = args.workspaceProjectRef?.trim();
+  if (workspaceProjectRef) {
+    return { project_ref: workspaceProjectRef, resolved_by: "workspace_binding" };
+  }
+  const defaultProject = args.defaultProject?.trim();
+  if (defaultProject) {
+    return { project_ref: defaultProject, resolved_by: "env_default" };
+  }
+  return { project_ref: null, resolved_by: "unresolved" };
+}
+function classifyWorkspaceHealth(args) {
+  if (!args.project_ref) return "unbound";
+  if (!args.last_indexed_at || (args.coverage ?? 0) <= 0) return "unindexed";
+  const nowMs = args.now_ms ?? Date.now();
+  const lastIndexedMs = new Date(args.last_indexed_at).getTime();
+  const ageHours = Number.isFinite(lastIndexedMs) ? (nowMs - lastIndexedMs) / (60 * 60 * 1e3) : Number.POSITIVE_INFINITY;
+  const pendingChanges = args.pending_changes ?? 0;
+  const drifted = pendingChanges > 0 || Boolean(
+    args.last_indexed_commit && args.current_commit && args.last_indexed_commit !== args.current_commit
+  );
+  if (drifted) return "drifted";
+  if (ageHours > (args.max_staleness_hours ?? 168)) return "stale";
+  return "healthy";
+}
 function getWorkspaceId(workspaceId) {
   if (workspaceId?.trim()) return workspaceId.trim();
-  const seed = `${process.cwd()}|${DEFAULT_PROJECT || "default"}|${API_KEY.slice(0, 12)}`;
+  const seed = `${canonicalizeWorkspacePath(process.cwd())}|${API_KEY.slice(0, 12) || "anon"}`;
   return createHash("sha256").update(seed).digest("hex").slice(0, 20);
 }
 function getWorkspaceIdForPath(path, workspaceId) {
   if (workspaceId?.trim()) return workspaceId.trim();
   if (!path) return getWorkspaceId(void 0);
-  const seed = `${path}|${DEFAULT_PROJECT || "default"}|${API_KEY.slice(0, 12)}`;
+  const seed = `${canonicalizeWorkspacePath(path)}|${API_KEY.slice(0, 12) || "anon"}`;
   return createHash("sha256").update(seed).digest("hex").slice(0, 20);
 }
 function clamp012(value) {
@@ -3899,7 +4013,10 @@ function getWorkspaceState(state, workspaceId) {
       annotations: [],
       session_summaries: [],
       events: [],
-      index_metadata: {}
+      index_metadata: {},
+      root_path: void 0,
+      project_ref: void 0,
+      project_id: void 0
     };
   }
   return state.workspaces[workspaceId];
@@ -3909,17 +4026,124 @@ function computeChecksum(value) {
 }
 var cachedProjectRef = DEFAULT_PROJECT || void 0;
 var cachedMcpSessionId = process.env.WHISPER_SESSION_ID || `mcp_${randomUUID().slice(0, 12)}`;
+async function resolveProjectDescriptor(projectRef) {
+  try {
+    const resolved = await whisper.resolveProject(projectRef);
+    const resolvedRef = resolved.slug || resolved.name || resolved.id || projectRef;
+    cachedProjectRef = resolvedRef;
+    return { project_ref: resolvedRef, project_id: resolved.id || null };
+  } catch {
+    cachedProjectRef = projectRef;
+    return { project_ref: projectRef, project_id: null };
+  }
+}
+function getWorkspaceRecommendedNextCalls(health) {
+  if (health === "unbound") return ["index.workspace_resolve", "context.list_projects", "index.workspace_status"];
+  if (health === "unindexed") return ["index.workspace_status", "index.workspace_run", "search_code", "grep"];
+  if (health === "stale" || health === "drifted") return ["index.workspace_status", "index.workspace_run", "grep", "search_code"];
+  return [];
+}
+function getWorkspaceWarnings(args) {
+  if (args.health === "unbound") {
+    return [`Workspace ${args.rootPath} is not bound to a Whisper project.`];
+  }
+  if (args.health === "unindexed") {
+    return [`Workspace ${args.rootPath} is bound to ${args.projectRef}, but no usable local index metadata exists yet.`];
+  }
+  if (args.health === "stale") {
+    const age = args.freshness.age_hours == null ? "unknown" : `${Math.round(args.freshness.age_hours)}h`;
+    return [`Workspace index for ${args.projectRef} is stale (${age} old).`];
+  }
+  if (args.health === "drifted") {
+    const reasons = [];
+    if (args.pendingChanges && args.pendingChanges > 0) reasons.push(`${args.pendingChanges} pending local changes`);
+    if (args.lastIndexedCommit && args.currentCommit && args.lastIndexedCommit !== args.currentCommit) {
+      reasons.push(`indexed commit ${args.lastIndexedCommit.slice(0, 12)} differs from current ${args.currentCommit.slice(0, 12)}`);
+    }
+    const suffix = reasons.length ? `: ${reasons.join("; ")}` : "";
+    return [`Workspace state drifted since the last index${suffix}.`];
+  }
+  return [];
+}
+async function resolveWorkspaceTrust(args) {
+  const rootPath = canonicalizeWorkspacePath(args.path);
+  const workspaceId = getWorkspaceIdForPath(rootPath, args.workspace_id);
+  const state = loadState();
+  const workspace = getWorkspaceState(state, workspaceId);
+  let mutated = false;
+  if (workspace.root_path !== rootPath) {
+    workspace.root_path = rootPath;
+    mutated = true;
+  }
+  const selected = chooseWorkspaceProjectSource({
+    explicitProject: args.project,
+    workspaceProjectRef: workspace.project_ref,
+    defaultProject: DEFAULT_PROJECT || null
+  });
+  let projectRef = null;
+  let projectId = workspace.project_id || null;
+  if (selected.project_ref) {
+    const resolved = await resolveProjectDescriptor(selected.project_ref);
+    projectRef = resolved.project_ref;
+    projectId = resolved.project_id;
+    if (workspace.project_ref !== projectRef || (workspace.project_id || null) !== projectId) {
+      workspace.project_ref = projectRef;
+      workspace.project_id = projectId || void 0;
+      mutated = true;
+    }
+  }
+  if (mutated) saveState(state);
+  const lastIndexedAt = workspace.index_metadata?.last_indexed_at || null;
+  const ageHours = lastIndexedAt ? (Date.now() - new Date(lastIndexedAt).getTime()) / (60 * 60 * 1e3) : null;
+  const currentCommit = getGitHead(rootPath) || null;
+  const pendingChanges = getGitPendingCount(rootPath);
+  const lastIndexedCommit = workspace.index_metadata?.last_indexed_commit || null;
+  const coverage = workspace.index_metadata?.coverage ?? 0;
+  const health = classifyWorkspaceHealth({
+    project_ref: projectRef,
+    coverage,
+    last_indexed_at: lastIndexedAt,
+    last_indexed_commit: lastIndexedCommit,
+    current_commit: currentCommit,
+    pending_changes: pendingChanges ?? null,
+    max_staleness_hours: args.max_staleness_hours ?? 168
+  });
+  const freshness = {
+    stale: health === "stale",
+    age_hours: ageHours,
+    last_indexed_at: lastIndexedAt
+  };
+  const warnings = getWorkspaceWarnings({
+    health,
+    rootPath,
+    projectRef,
+    currentCommit,
+    lastIndexedCommit,
+    pendingChanges: pendingChanges ?? null,
+    freshness
+  });
+  return {
+    workspace_id: workspaceId,
+    root_path: rootPath,
+    project_ref: projectRef,
+    project_id: projectId,
+    resolved_by: selected.resolved_by,
+    health,
+    warnings,
+    recommended_next_calls: getWorkspaceRecommendedNextCalls(health),
+    freshness,
+    coverage,
+    last_indexed_commit: lastIndexedCommit,
+    current_commit: currentCommit,
+    pending_changes: pendingChanges ?? null,
+    grounded_to_workspace: health === "healthy"
+  };
+}
 async function resolveProjectRef(explicit) {
   if (explicit?.trim()) {
     const requestedRef = explicit.trim();
-    try {
-      const resolved = await whisper.resolveProject(requestedRef);
-      cachedProjectRef = resolved.slug || resolved.name || resolved.id;
-      return cachedProjectRef;
-    } catch {
-      cachedProjectRef = requestedRef;
-      return requestedRef;
-    }
+    const resolved = await resolveProjectDescriptor(requestedRef);
+    return resolved.project_ref;
   }
   if (cachedProjectRef) return cachedProjectRef;
   try {
@@ -4022,7 +4246,9 @@ function buildAbstain(args) {
     reason: args.reason,
     message: args.message,
     closest_evidence: args.closest_evidence,
-    recommended_next_calls: ["index.workspace_status", "index.workspace_run", "symbol_search", "context.get_relevant"],
+    warnings: args.warnings || [],
+    trust_state: args.trust_state,
+    recommended_next_calls: args.recommended_next_calls || ["index.workspace_status", "index.workspace_run", "grep", "context.get_relevant"],
     diagnostics: {
       claims_evaluated: args.claims_evaluated,
       evidence_items_found: args.evidence_items_found,
@@ -4098,6 +4324,86 @@ function formatCanonicalMemoryResults(rawResults) {
     };
   });
 }
+function normalizeLooseText(value) {
+  return String(value || "").trim().toLowerCase().replace(/\s+/g, " ");
+}
+function resolveForgetQueryCandidates(rawResults, query) {
+  const normalizedQuery = normalizeLooseText(query);
+  const candidates = normalizeCanonicalResults(rawResults).map((result) => {
+    const memory = result?.memory || result;
+    const metadata = memory?.metadata || {};
+    return {
+      id: String(memory?.id || "").trim(),
+      content: normalizeLooseText(memory?.content),
+      normalized_content: normalizeLooseText(metadata?.normalized_content),
+      canonical_content: normalizeLooseText(metadata?.canonical_content),
+      similarity: typeof result?.similarity === "number" ? result.similarity : typeof result?.score === "number" ? result.score : 0
+    };
+  }).filter((candidate) => candidate.id);
+  const exactMatches = candidates.filter(
+    (candidate) => candidate.id.toLowerCase() === normalizedQuery || candidate.content === normalizedQuery || candidate.normalized_content === normalizedQuery || candidate.canonical_content === normalizedQuery
+  );
+  if (exactMatches.length > 0) {
+    return { memory_ids: [...new Set(exactMatches.map((candidate) => candidate.id))], resolved_by: "exact" };
+  }
+  const substringMatches = candidates.filter((candidate) => {
+    const haystacks = [candidate.content, candidate.normalized_content, candidate.canonical_content].filter(Boolean);
+    return haystacks.some(
+      (value) => value.includes(normalizedQuery) || normalizedQuery.length >= 12 && normalizedQuery.includes(value)
+    );
+  });
+  if (substringMatches.length === 1) {
+    return { memory_ids: [substringMatches[0].id], resolved_by: "substring" };
+  }
+  if (substringMatches.length > 1) {
+    return {
+      memory_ids: [],
+      resolved_by: "ambiguous",
+      warning: "Query matched multiple memories by recognizable text. Use memory_id or a more specific query."
+    };
+  }
+  const ranked = [...candidates].sort((a, b) => b.similarity - a.similarity);
+  if (ranked[0] && ranked[0].similarity >= 0.9 && (!ranked[1] || ranked[0].similarity - ranked[1].similarity >= 0.08)) {
+    return { memory_ids: [ranked[0].id], resolved_by: "high_confidence" };
+  }
+  return { memory_ids: [], resolved_by: "none", warning: "Query did not resolve to a reliable memory match. No memories were changed." };
+}
+async function searchMemoriesForContextQuery(args) {
+  return whisper.searchMemoriesSOTA({
+    project: args.project,
+    query: args.query,
+    user_id: args.user_id,
+    session_id: args.session_id,
+    top_k: args.top_k ?? 5,
+    include_relations: false,
+    include_pending: true
+  });
+}
+async function runContextQueryMemoryRescue(args) {
+  const scoped = await searchMemoriesForContextQuery(args);
+  const scopedResults = formatCanonicalMemoryResults(scoped);
+  if (scopedResults.length > 0) {
+    return { results: scopedResults, rescue_mode: "scoped" };
+  }
+  if (args.user_id || args.session_id) {
+    return { results: [], rescue_mode: null };
+  }
+  const broad = await searchMemoriesForContextQuery({
+    project: args.project,
+    query: args.query,
+    top_k: args.top_k
+  });
+  return { results: formatCanonicalMemoryResults(broad), rescue_mode: formatCanonicalMemoryResults(broad).length > 0 ? "project_broad" : null };
+}
+function renderContextQueryMemoryRescue(args) {
+  const lines = args.results.map(
+    (result, index) => `${index + 1}. [${result.memory_type || "memory"}, score: ${result.similarity ?? "n/a"}] ${result.content}`
+  );
+  const scopeLabel = args.rescue_mode === "project_broad" ? `project=${args.project}, project_broad_memory_rescue=true` : `project=${args.project}, user=${args.scope.userId}, session=${args.scope.sessionId}, scoped_memory_rescue=true`;
+  return `Found ${args.results.length} memory result(s) (${scopeLabel}):
+
+${lines.join("\n\n")}`;
+}
 function likelyEmbeddingFailure(error) {
   const message = String(error?.message || error || "").toLowerCase();
   return message.includes("embedding") || message.includes("vector") || message.includes("timeout") || message.includes("timed out") || message.includes("temporarily unavailable");
@@ -4139,6 +4445,186 @@ async function queryWithDegradedFallback(params) {
     };
   }
 }
+function collectCodeFiles(rootPath, allowedExts, maxFiles) {
+  const files = [];
+  function collect(dir) {
+    if (files.length >= maxFiles) return;
+    let entries;
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (files.length >= maxFiles) break;
+      if (SKIP_DIRS.has(entry.name)) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) collect(full);
+      else if (entry.isFile()) {
+        const ext = extname(entry.name).replace(".", "");
+        if (allowedExts.has(ext)) files.push(full);
+      }
+    }
+  }
+  collect(rootPath);
+  return files;
+}
+function tokenizeQueryForLexicalRescue(query) {
+  const stopWords = /* @__PURE__ */ new Set(["where", "what", "show", "find", "logic", "code", "file", "files", "handled", "handling"]);
+  return Array.from(new Set(
+    query.toLowerCase().split(/[^a-z0-9/_-]+/).map((token) => token.trim()).filter((token) => token.length >= 3 && !stopWords.has(token))
+  ));
+}
+function buildLexicalRescueResults(args) {
+  const tokens = tokenizeQueryForLexicalRescue(args.query);
+  if (tokens.length === 0) return [];
+  const scored = args.documents.map((doc) => {
+    const haystack = `${doc.id}
+${doc.content}
+${doc.raw_content}`.toLowerCase();
+    const tokenHits = tokens.filter((token) => haystack.includes(token));
+    const uniqueHits = tokenHits.length;
+    const exactPhraseBonus = haystack.includes(args.query.toLowerCase()) ? 0.25 : 0;
+    const score = uniqueHits === 0 ? 0 : Math.min(0.95, uniqueHits / tokens.length + exactPhraseBonus);
+    return {
+      id: doc.id,
+      score,
+      content: doc.content,
+      snippet: doc.content.split("\n").find((line) => line.trim().length > 10)?.slice(0, 200) || doc.id,
+      search_mode: "lexical_rescue"
+    };
+  });
+  return scored.filter((result) => result.score > 0).sort((a, b) => b.score - a.score).slice(0, args.top_k);
+}
+async function runSearchCodeSearch(args) {
+  const topK = args.top_k ?? 10;
+  const requestedThreshold = args.threshold ?? 0.2;
+  const semanticDocuments = args.documents.map((doc) => ({ id: doc.id, content: doc.content }));
+  const defaultResponse = await args.semantic_search({
+    query: args.query,
+    documents: semanticDocuments,
+    top_k: topK,
+    threshold: requestedThreshold
+  });
+  if (defaultResponse.results?.length) {
+    return {
+      results: defaultResponse.results.map((result) => ({ ...result, search_mode: "semantic" })),
+      mode: "semantic",
+      threshold_used: requestedThreshold,
+      fallback_used: false,
+      fallback_reason: null
+    };
+  }
+  const adaptiveThreshold = Math.max(0.05, Math.min(requestedThreshold, requestedThreshold / 2));
+  if (adaptiveThreshold < requestedThreshold) {
+    const adaptiveResponse = await args.semantic_search({
+      query: args.query,
+      documents: semanticDocuments,
+      top_k: topK,
+      threshold: adaptiveThreshold
+    });
+    if (adaptiveResponse.results?.length) {
+      return {
+        results: adaptiveResponse.results.map((result) => ({ ...result, search_mode: "adaptive_semantic" })),
+        mode: "adaptive_semantic",
+        threshold_used: adaptiveThreshold,
+        fallback_used: true,
+        fallback_reason: `No results at threshold ${requestedThreshold}; lowered to ${adaptiveThreshold}.`
+      };
+    }
+  }
+  const lexicalResults = buildLexicalRescueResults({
+    query: args.query,
+    documents: args.documents,
+    top_k: topK
+  });
+  return {
+    results: lexicalResults,
+    mode: "lexical_rescue",
+    threshold_used: null,
+    fallback_used: true,
+    fallback_reason: lexicalResults.length ? "Semantic ranking returned no matches; lexical rescue over local file paths and content was used." : "Semantic ranking returned no matches and lexical rescue found no strong candidates."
+  };
+}
+async function runSearchCodeTool(args) {
+  const rootPath = canonicalizeWorkspacePath(args.path);
+  const workspace = await resolveWorkspaceTrust({ path: rootPath });
+  const allowedExts = args.file_types ? new Set(args.file_types) : CODE_EXTENSIONS;
+  const files = collectCodeFiles(rootPath, allowedExts, args.max_files ?? 150);
+  const sharedWarnings = [...workspace.warnings];
+  if (files.length === 0) {
+    return {
+      tool: "search_code",
+      query: args.query,
+      path: rootPath,
+      results: [],
+      count: 0,
+      warnings: sharedWarnings,
+      diagnostics: {
+        workspace_id: workspace.workspace_id,
+        root_path: workspace.root_path,
+        project_ref: workspace.project_ref,
+        project_id: workspace.project_id,
+        index_health: workspace.health,
+        grounded_to_workspace: workspace.grounded_to_workspace,
+        threshold_requested: args.threshold ?? 0.2,
+        threshold_used: null,
+        fallback_used: false,
+        fallback_reason: null,
+        search_mode: "semantic",
+        warnings: sharedWarnings
+      }
+    };
+  }
+  const documents = [];
+  for (const filePath of files) {
+    try {
+      const stat = statSync(filePath);
+      if (stat.size > 500 * 1024) continue;
+      const content = readFileSync(filePath, "utf-8");
+      const relPath = relative(rootPath, filePath).replace(/\\/g, "/");
+      documents.push({ id: relPath, content: extractSignature(relPath, content), raw_content: content });
+    } catch {
+    }
+  }
+  const searchResult = await runSearchCodeSearch({
+    query: args.query,
+    documents,
+    top_k: args.top_k,
+    threshold: args.threshold,
+    semantic_search: (params) => whisper.semanticSearch(params)
+  });
+  if (searchResult.mode === "lexical_rescue") {
+    sharedWarnings.push("Local lexical rescue was used because semantic search returned no matches.");
+  } else if (searchResult.mode === "adaptive_semantic") {
+    sharedWarnings.push(searchResult.fallback_reason || "Adaptive semantic thresholding was used.");
+  }
+  if (!workspace.grounded_to_workspace && workspace.health !== "unbound" && workspace.health !== "unindexed") {
+    sharedWarnings.push("Local code search is live, but project-backed retrieval may disagree until the workspace is re-indexed.");
+  }
+  return {
+    tool: "search_code",
+    query: args.query,
+    path: rootPath,
+    results: searchResult.results,
+    count: searchResult.results.length,
+    warnings: sharedWarnings,
+    diagnostics: {
+      workspace_id: workspace.workspace_id,
+      root_path: workspace.root_path,
+      project_ref: workspace.project_ref,
+      project_id: workspace.project_id,
+      index_health: workspace.health,
+      grounded_to_workspace: workspace.grounded_to_workspace,
+      threshold_requested: args.threshold ?? 0.2,
+      threshold_used: searchResult.threshold_used,
+      fallback_used: searchResult.fallback_used,
+      fallback_reason: searchResult.fallback_reason,
+      search_mode: searchResult.mode,
+      warnings: sharedWarnings
+    }
+  };
+}
 function getLocalAllowlistRoots() {
   const fromEnv = (process.env.WHISPER_LOCAL_ALLOWLIST || "").split(",").map((v) => v.trim()).filter(Boolean);
   if (fromEnv.length > 0) return fromEnv;
@@ -4218,7 +4704,8 @@ async function ingestLocalPath(params) {
   }
   collect(rootPath);
   const manifest = loadIngestManifest();
-  const workspaceId = getWorkspaceIdForPath(rootPath);
+  const canonicalRootPath = canonicalizeWorkspacePath(rootPath);
+  const workspaceId = getWorkspaceIdForPath(canonicalRootPath);
   if (!manifest[workspaceId]) manifest[workspaceId] = { last_run_at: (/* @__PURE__ */ new Date(0)).toISOString(), files: {} };
   const docs = [];
   const skipped = [];
@@ -4254,6 +4741,10 @@ async function ingestLocalPath(params) {
   }
   manifest[workspaceId].last_run_at = (/* @__PURE__ */ new Date()).toISOString();
   saveIngestManifest(manifest);
+  const state = loadState();
+  const workspace = getWorkspaceState(state, workspaceId);
+  workspace.root_path = canonicalRootPath;
+  saveState(state);
   appendFileSync(
     AUDIT_LOG_PATH,
     `${(/* @__PURE__ */ new Date()).toISOString()} local_ingest workspace=${workspaceId} root_hash=${createHash("sha256").update(rootPath).digest("hex").slice(0, 16)} files=${docs.length}
@@ -4262,79 +4753,40 @@ async function ingestLocalPath(params) {
   return { ingested, scanned: files.length, queued: docs.length, skipped, workspace_id: workspaceId };
 }
 async function createSourceByType(params) {
-  const connector_type = params.type === "github" ? "github" : params.type === "web" ? "website" : params.type === "pdf" ? "pdf" : params.type === "local" ? "local-folder" : params.type === "slack" ? "slack" : "video";
-  const config = {};
-  if (params.type === "github") {
-    if (!params.owner || !params.repo) throw new Error("github source requires owner and repo");
-    config.owner = params.owner;
-    config.repo = params.repo;
-    if (params.branch) config.branch = params.branch;
-    if (params.paths) config.paths = params.paths;
-  } else if (params.type === "web") {
-    if (!params.url) throw new Error("web source requires url");
-    config.url = params.url;
-    if (params.crawl_depth !== void 0) config.crawl_depth = params.crawl_depth;
-    if (params.include_paths) config.include_paths = params.include_paths;
-    if (params.exclude_paths) config.exclude_paths = params.exclude_paths;
-  } else if (params.type === "pdf") {
-    if (!params.url && !params.file_path) throw new Error("pdf source requires url or file_path");
-    if (params.url) config.url = params.url;
-    if (params.file_path) config.file_path = params.file_path;
-  } else if (params.type === "local") {
-    if (!params.path) throw new Error("local source requires path");
-    const ingest = await ingestLocalPath({
-      project: params.project,
-      path: params.path,
-      glob: params.glob,
-      max_files: params.max_files
-    });
-    return {
-      source_id: `local_${ingest.workspace_id}`,
-      status: "ready",
-      job_id: `local_ingest_${Date.now()}`,
-      index_started: true,
-      warnings: ingest.skipped.slice(0, 20),
-      details: ingest
-    };
-  } else if (params.type === "slack") {
-    config.channel_ids = params.channel_ids || [];
-    if (params.since) config.since = params.since;
-    if (params.workspace_id) config.workspace_id = params.workspace_id;
-    if (params.token) config.token = params.token;
-    if (params.auth_ref) config.auth_ref = params.auth_ref;
-  } else if (params.type === "video") {
-    if (!params.url) throw new Error("video source requires url");
-    config.url = params.url;
-    if (params.platform) config.platform = params.platform;
-    if (params.language) config.language = params.language;
-    if (params.allow_stt_fallback !== void 0) config.allow_stt_fallback = params.allow_stt_fallback;
-    if (params.max_duration_minutes !== void 0) config.max_duration_minutes = params.max_duration_minutes;
-    if (params.max_chunks !== void 0) config.max_chunks = params.max_chunks;
-  }
-  if (params.metadata) config.metadata = params.metadata;
-  if (params.ingestion_profile) config.ingestion_profile = params.ingestion_profile;
-  if (params.strategy_override) config.strategy_override = params.strategy_override;
-  if (params.profile_config) config.profile_config = params.profile_config;
-  config.auto_index = params.auto_index ?? true;
-  const created = await whisper.addSource(params.project, {
-    name: params.name || `${params.type}-source-${Date.now()}`,
-    connector_type,
-    config
+  const result = await whisper.createCanonicalSource(params.project, {
+    type: params.type,
+    name: params.name,
+    auto_index: params.auto_index,
+    metadata: params.metadata,
+    ingestion_profile: params.ingestion_profile,
+    strategy_override: params.strategy_override,
+    profile_config: params.profile_config,
+    owner: params.owner,
+    repo: params.repo,
+    branch: params.branch,
+    paths: params.paths,
+    url: params.url,
+    crawl_depth: params.crawl_depth,
+    include_paths: params.include_paths,
+    exclude_paths: params.exclude_paths,
+    file_path: params.file_path,
+    path: params.path,
+    glob: params.glob,
+    max_files: params.max_files,
+    max_pages: params.max_pages,
+    extract_mode: params.extract_mode,
+    workspace_id: params.workspace_id,
+    channel_ids: params.channel_ids,
+    since: params.since,
+    token: params.token,
+    auth_ref: params.auth_ref,
+    platform: params.platform,
+    language: params.language,
+    allow_stt_fallback: params.allow_stt_fallback,
+    max_duration_minutes: params.max_duration_minutes,
+    max_chunks: params.max_chunks
   });
-  let jobId;
-  let status = "queued";
-  if (params.auto_index ?? true) {
-    const syncRes = await whisper.syncSource(created.id);
-    jobId = String(syncRes?.id || syncRes?.job_id || "");
-    status = "indexing";
-  }
-  return {
-    source_id: created.id,
-    status,
-    job_id: jobId || null,
-    index_started: params.auto_index ?? true,
-    warnings: []
-  };
+  return result;
 }
 function normalizeRecordMessages(input) {
   if (Array.isArray(input.messages) && input.messages.length > 0) {
@@ -4358,85 +4810,60 @@ async function learnFromInput(input) {
   if (!resolvedProject) {
     throw new Error("No project resolved. Set WHISPER_PROJECT or provide project.");
   }
-  if (input.content) {
-    const mergedMetadata = {
-      ...input.metadata || {},
-      ...input.ingestion_profile ? { ingestion_profile: input.ingestion_profile } : {},
-      ...input.strategy_override ? { strategy_override: input.strategy_override } : {},
-      ...input.profile_config ? { profile_config: input.profile_config } : {}
-    };
-    const result = await whisper.addContext({
-      project: resolvedProject,
-      content: input.content,
-      title: input.title || "Learned Context",
-      metadata: mergedMetadata
-    });
-    return {
-      mode: "text",
-      project: resolvedProject,
-      ingested: result.ingested
-    };
-  }
-  if (input.owner && input.repo) {
-    return createSourceByType({
-      project: resolvedProject,
-      type: "github",
-      owner: input.owner,
-      repo: input.repo,
-      branch: input.branch,
-      name: input.name,
-      auto_index: true,
-      metadata: input.metadata,
-      ingestion_profile: input.ingestion_profile,
-      strategy_override: input.strategy_override,
-      profile_config: input.profile_config
-    });
-  }
-  if (input.path) {
-    return createSourceByType({
-      project: resolvedProject,
-      type: "local",
-      path: input.path,
-      glob: input.glob,
-      max_files: input.max_files,
-      name: input.name,
-      metadata: input.metadata,
-      ingestion_profile: input.ingestion_profile,
-      strategy_override: input.strategy_override,
-      profile_config: input.profile_config
-    });
-  }
-  if (input.file_path) {
-    return createSourceByType({
+  if (input.mode === "conversation") {
+    if (!input.session_id || !input.messages || input.messages.length === 0) {
+      throw new Error("conversation learn requires session_id and messages[]");
+    }
+    return whisper.learn({
+      mode: "conversation",
       project: resolvedProject,
-      type: "pdf",
-      file_path: input.file_path,
-      name: input.name,
-      metadata: input.metadata,
-      ingestion_profile: input.ingestion_profile,
-      strategy_override: input.strategy_override,
-      profile_config: input.profile_config
+      user_id: input.user_id,
+      session_id: input.session_id,
+      messages: input.messages.map((message) => ({
+        ...message,
+        timestamp: message.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+      }))
     });
   }
-  if (input.url) {
-    return createSourceByType({
+  if (input.mode === "text") {
+    if (!input.title || !input.content) {
+      throw new Error("text learn requires title and content");
+    }
+    return whisper.learn({
+      mode: "text",
       project: resolvedProject,
-      type: input.url.endsWith(".pdf") ? "pdf" : "web",
-      url: input.url,
-      name: input.name,
+      title: input.title,
+      content: input.content,
       metadata: input.metadata,
-      ingestion_profile: input.ingestion_profile,
-      strategy_override: input.strategy_override,
-      profile_config: input.profile_config,
-      crawl_depth: input.crawl_depth,
-      channel_ids: input.channel_ids,
-      token: input.token,
-      workspace_id: input.workspace_id,
-      since: input.since,
-      auth_ref: input.auth_ref
+      tags: input.tags,
+      namespace: input.namespace,
+      options: input.options
     });
   }
-  throw new Error("Provide content, owner+repo, path, file_path, or url.");
+  if (!input.type) {
+    throw new Error("source learn requires type");
+  }
+  return whisper.learn({
+    mode: "source",
+    project: resolvedProject,
+    type: input.type,
+    name: input.name,
+    metadata: input.metadata,
+    owner: input.owner,
+    repo: input.repo,
+    branch: input.branch,
+    paths: input.paths,
+    url: input.url,
+    file_path: input.file_path,
+    path: input.path,
+    channel_ids: input.channel_ids,
+    since: input.since,
+    token: input.token,
+    auth_ref: input.auth_ref,
+    platform: input.platform,
+    language: input.language,
+    options: input.options
+  });
 }
 function renderScopedMcpConfig(project, source, client) {
   const serverDef = {
@@ -4473,22 +4900,25 @@ server.tool(
   },
   async ({ path, workspace_id, project }) => {
     try {
-      const workspaceId = getWorkspaceIdForPath(path, workspace_id);
+      const rootPath = canonicalizeWorkspacePath(path);
+      const workspaceId = getWorkspaceIdForPath(rootPath, workspace_id);
       const state = loadState();
       const existed = Boolean(state.workspaces[workspaceId]);
-      const workspace = getWorkspaceState(state, workspaceId);
-      const resolvedProject = await resolveProjectRef(project);
-      const resolvedBy = project?.trim() ? "explicit_project" : DEFAULT_PROJECT ? "env_default" : resolvedProject ? "auto_first_project" : "unresolved";
-      saveState(state);
+      const trust = await resolveWorkspaceTrust({ path: rootPath, workspace_id, project });
       const payload = {
         workspace_id: workspaceId,
-        project_id: resolvedProject || null,
+        root_path: trust.root_path,
+        project_ref: trust.project_ref,
+        project_id: trust.project_id,
         created: !existed,
-        resolved_by: resolvedBy,
+        resolved_by: trust.resolved_by,
+        health: trust.health,
+        warnings: trust.warnings,
+        recommended_next_calls: trust.recommended_next_calls,
         index_state: {
-          last_indexed_at: workspace.index_metadata?.last_indexed_at || null,
-          last_indexed_commit: workspace.index_metadata?.last_indexed_commit || null,
-          coverage: workspace.index_metadata?.coverage ?? 0
+          last_indexed_at: trust.freshness.last_indexed_at,
+          last_indexed_commit: trust.last_indexed_commit,
+          coverage: trust.coverage
         }
       };
       return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
@@ -4506,24 +4936,22 @@ server.tool(
   },
   async ({ workspace_id, path }) => {
     try {
-      const rootPath = path || process.cwd();
-      const workspaceId = getWorkspaceIdForPath(rootPath, workspace_id);
-      const state = loadState();
-      const workspace = getWorkspaceState(state, workspaceId);
-      const lastIndexedAt = workspace.index_metadata?.last_indexed_at;
-      const ageHours = lastIndexedAt ? (Date.now() - new Date(lastIndexedAt).getTime()) / (60 * 60 * 1e3) : null;
-      const stale = ageHours === null ? true : ageHours > 168;
+      const trust = await resolveWorkspaceTrust({ path, workspace_id });
       const payload = {
-        workspace_id: workspaceId,
-        freshness: {
-          stale,
-          age_hours: ageHours,
-          last_indexed_at: lastIndexedAt || null
-        },
-        coverage: workspace.index_metadata?.coverage ?? 0,
-        last_indexed_commit: workspace.index_metadata?.last_indexed_commit || null,
-        current_commit: getGitHead(rootPath) || null,
-        pending_changes: getGitPendingCount(rootPath)
+        workspace_id: trust.workspace_id,
+        root_path: trust.root_path,
+        project_ref: trust.project_ref,
+        project_id: trust.project_id,
+        resolved_by: trust.resolved_by,
+        health: trust.health,
+        warnings: trust.warnings,
+        recommended_next_calls: trust.recommended_next_calls,
+        freshness: trust.freshness,
+        coverage: trust.coverage,
+        last_indexed_commit: trust.last_indexed_commit,
+        current_commit: trust.current_commit,
+        pending_changes: trust.pending_changes,
+        grounded_to_workspace: trust.grounded_to_workspace
       };
       return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
     } catch (error) {
@@ -4542,13 +4970,14 @@ server.tool(
   },
   async ({ workspace_id, path, mode, max_files }) => {
     try {
-      const rootPath = path || process.cwd();
+      const rootPath = canonicalizeWorkspacePath(path);
       const workspaceId = getWorkspaceIdForPath(rootPath, workspace_id);
       const state = loadState();
       const workspace = getWorkspaceState(state, workspaceId);
       const fileStats = countCodeFiles(rootPath, max_files);
       const coverage = Math.max(0, Math.min(1, fileStats.total / Math.max(1, max_files)));
       const now = (/* @__PURE__ */ new Date()).toISOString();
+      workspace.root_path = rootPath;
       workspace.index_metadata = {
         last_indexed_at: now,
         last_indexed_commit: getGitHead(rootPath),
@@ -4557,6 +4986,7 @@ server.tool(
       saveState(state);
       const payload = {
         workspace_id: workspaceId,
+        root_path: rootPath,
         mode,
         indexed_files: fileStats.total,
         skipped_files: fileStats.skipped,
@@ -4621,23 +5051,25 @@ server.tool(
   },
   async ({ question, workspace_id, project, top_k, include_memories, include_graph, session_id, user_id }) => {
     try {
-      const workspaceId = getWorkspaceId(workspace_id);
-      const resolvedProject = await resolveProjectRef(project);
-      if (!resolvedProject) {
+      const trust = await resolveWorkspaceTrust({ workspace_id, project });
+      if (trust.health === "unbound" || trust.health === "unindexed" || !trust.project_ref) {
         const payload2 = {
           question,
-          workspace_id: workspaceId,
+          workspace_id: trust.workspace_id,
+          trust_state: trust,
+          grounded_to_workspace: false,
           total_results: 0,
           context: "",
           evidence: [],
           used_context_ids: [],
           latency_ms: 0,
-          warning: "No project resolved. Set WHISPER_PROJECT or create one in your account."
+          warnings: trust.warnings,
+          recommended_next_calls: trust.recommended_next_calls
         };
         return { content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }] };
       }
       const queryResult = await queryWithDegradedFallback({
-        project: resolvedProject,
+        project: trust.project_ref,
         query: question,
         top_k,
         include_memories,
@@ -4646,10 +5078,12 @@ server.tool(
         user_id
       });
       const response = queryResult.response;
-      const evidence = (response.results || []).map((r) => toEvidenceRef(r, workspaceId, "semantic"));
+      const evidence = (response.results || []).map((r) => toEvidenceRef(r, trust.workspace_id, "semantic"));
       const payload = {
         question,
-        workspace_id: workspaceId,
+        workspace_id: trust.workspace_id,
+        trust_state: trust,
+        grounded_to_workspace: trust.grounded_to_workspace,
         total_results: response.meta?.total || evidence.length,
         context: response.context || "",
         evidence,
@@ -4657,7 +5091,9 @@ server.tool(
         latency_ms: response.meta?.latency_ms || 0,
         degraded_mode: queryResult.degraded_mode,
         degraded_reason: queryResult.degraded_reason,
-        recommendation: queryResult.recommendation
+        recommendation: queryResult.recommendation,
+        warnings: trust.warnings,
+        recommended_next_calls: trust.recommended_next_calls
       };
       return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
     } catch (error) {
@@ -4677,20 +5113,22 @@ server.tool(
   },
   async ({ claim, workspace_id, project, context_ids, strict }) => {
     try {
-      const workspaceId = getWorkspaceId(workspace_id);
-      const resolvedProject = await resolveProjectRef(project);
-      if (!resolvedProject) {
+      const trust = await resolveWorkspaceTrust({ workspace_id, project });
+      if (trust.health !== "healthy" || !trust.project_ref) {
         const payload2 = {
           verdict: "unsupported",
           confidence: 0,
           evidence: [],
-          missing_requirements: ["No project resolved. Set WHISPER_PROJECT or create one in your account."],
-          explanation: "Verifier could not run because no project is configured."
+          trust_state: trust,
+          warnings: trust.warnings,
+          recommended_next_calls: trust.recommended_next_calls,
+          missing_requirements: trust.warnings.length ? trust.warnings : ["Workspace trust requirements were not met."],
+          explanation: "Verifier did not run because workspace grounding is insufficient."
         };
         return { content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }] };
       }
       const response = await whisper.query({
-        project: resolvedProject,
+        project: trust.project_ref,
         query: claim,
         top_k: strict ? 8 : 12,
         include_memories: true,
@@ -4699,7 +5137,7 @@ server.tool(
       const filtered = (response.results || []).filter(
         (r) => !context_ids || context_ids.length === 0 || context_ids.includes(String(r.id))
       );
-      const evidence = filtered.map((r) => toEvidenceRef(r, workspaceId, "semantic"));
+      const evidence = filtered.map((r) => toEvidenceRef(r, trust.workspace_id, "semantic"));
       const directEvidence = evidence.filter((e) => e.score >= (strict ? 0.7 : 0.6));
       const weakEvidence = evidence.filter((e) => e.score >= (strict ? 0.45 : 0.35));
       let verdict = "unsupported";
@@ -4709,6 +5147,9 @@ server.tool(
         verdict,
         confidence: evidence.length ? Math.max(...evidence.map((e) => e.score)) : 0,
         evidence: verdict === "supported" ? directEvidence : weakEvidence,
+        trust_state: trust,
+        warnings: trust.warnings,
+        recommended_next_calls: trust.recommended_next_calls,
         missing_requirements: verdict === "supported" ? [] : verdict === "partial" ? ["No direct evidence spans met strict threshold."] : ["No sufficient supporting evidence found for the claim."],
         explanation: verdict === "supported" ? "At least one direct evidence span supports the claim." : verdict === "partial" ? "Some related evidence exists, but direct support is incomplete." : "Retrieved context did not contain sufficient support."
       };
@@ -4739,39 +5180,38 @@ server.tool(
   },
   async ({ question, workspace_id, project, constraints, retrieval }) => {
     try {
-      const workspaceId = getWorkspaceId(workspace_id);
       const requireCitations = constraints?.require_citations ?? true;
       const minEvidenceItems = constraints?.min_evidence_items ?? 2;
       const minConfidence = constraints?.min_confidence ?? 0.65;
       const maxStalenessHours = constraints?.max_staleness_hours ?? 168;
       const topK = retrieval?.top_k ?? 12;
-      const resolvedProject = await resolveProjectRef(project);
-      if (!resolvedProject) {
+      const trust = await resolveWorkspaceTrust({ workspace_id, project, max_staleness_hours: maxStalenessHours });
+      if (trust.health !== "healthy" || !trust.project_ref) {
+        const reason = trust.health === "stale" || trust.health === "drifted" ? "stale_index" : "no_retrieval_hits";
         const abstain = buildAbstain({
-          reason: "no_retrieval_hits",
-          message: "No project resolved. Set WHISPER_PROJECT or create one in your account.",
+          reason,
+          message: trust.warnings[0] || "Workspace trust requirements were not met.",
           closest_evidence: [],
           claims_evaluated: 1,
           evidence_items_found: 0,
           min_required: minEvidenceItems,
-          index_fresh: true
+          index_fresh: trust.health === "healthy",
+          warnings: trust.warnings,
+          trust_state: trust,
+          recommended_next_calls: trust.recommended_next_calls
         });
         return { content: [{ type: "text", text: JSON.stringify(abstain, null, 2) }] };
       }
       const response = await whisper.query({
-        project: resolvedProject,
+        project: trust.project_ref,
         query: question,
         top_k: topK,
         include_memories: true,
         include_graph: true
       });
-      const evidence = (response.results || []).map((r) => toEvidenceRef(r, workspaceId, "semantic"));
+      const evidence = (response.results || []).map((r) => toEvidenceRef(r, trust.workspace_id, "semantic"));
       const sorted = evidence.sort((a, b) => b.score - a.score);
       const confidence = sorted.length ? sorted[0].score : 0;
-      const state = loadState();
-      const workspace = getWorkspaceState(state, workspaceId);
-      const lastIndexedAt = workspace.index_metadata?.last_indexed_at;
-      const indexFresh = !lastIndexedAt || Date.now() - new Date(lastIndexedAt).getTime() <= maxStalenessHours * 60 * 60 * 1e3;
       if (sorted.length === 0) {
         const abstain = buildAbstain({
           reason: "no_retrieval_hits",
@@ -4780,24 +5220,15 @@ server.tool(
           claims_evaluated: 1,
           evidence_items_found: 0,
           min_required: minEvidenceItems,
-          index_fresh: indexFresh
+          index_fresh: trust.health === "healthy",
+          warnings: trust.warnings,
+          trust_state: trust,
+          recommended_next_calls: trust.recommended_next_calls
         });
         return { content: [{ type: "text", text: JSON.stringify(abstain, null, 2) }] };
       }
       const supportedEvidence = sorted.filter((e) => e.score >= minConfidence);
       const verdict = supportedEvidence.length >= 1 ? "supported" : "partial";
-      if (!indexFresh) {
-        const abstain = buildAbstain({
-          reason: "stale_index",
-          message: "Index freshness requirement not met. Re-index before answering.",
-          closest_evidence: sorted.slice(0, 3),
-          claims_evaluated: 1,
-          evidence_items_found: supportedEvidence.length,
-          min_required: minEvidenceItems,
-          index_fresh: false
-        });
-        return { content: [{ type: "text", text: JSON.stringify(abstain, null, 2) }] };
-      }
       if (requireCitations && (verdict !== "supported" || supportedEvidence.length < minEvidenceItems)) {
         const abstain = buildAbstain({
           reason: "insufficient_evidence",
@@ -4806,7 +5237,10 @@ server.tool(
           claims_evaluated: 1,
           evidence_items_found: supportedEvidence.length,
           min_required: minEvidenceItems,
-          index_fresh: true
+          index_fresh: true,
+          warnings: trust.warnings,
+          trust_state: trust,
+          recommended_next_calls: trust.recommended_next_calls
         });
         return { content: [{ type: "text", text: JSON.stringify(abstain, null, 2) }] };
       }
@@ -4819,6 +5253,9 @@ server.tool(
         answer: answerLines.join("\n"),
         citations,
         confidence,
+        trust_state: trust,
+        warnings: trust.warnings,
+        recommended_next_calls: trust.recommended_next_calls,
         verification: {
           verdict,
           supported_claims: verdict === "supported" ? 1 : 0,
@@ -4852,6 +5289,7 @@ server.tool(
       if (!resolvedProject) {
         return { content: [{ type: "text", text: "Error: No project resolved. Set WHISPER_PROJECT or pass project." }] };
       }
+      const scope = resolveMcpScope({ project: resolvedProject, user_id, session_id });
       const automaticMode = include_memories !== false && include_graph !== true && !(chunk_types && chunk_types.length > 0) && max_tokens === void 0 && runtimeClient;
       if (automaticMode) {
         try {
@@ -4863,6 +5301,27 @@ server.tool(
             session_id
           });
           if (!prepared.items.length) {
+            const memoryRescue = include_memories !== false ? await runContextQueryMemoryRescue({
+              project: resolvedProject,
+              query,
+              user_id: user_id ? scope2.userId : void 0,
+              session_id: session_id ? scope2.sessionId : void 0,
+              top_k
+            }) : { results: [], rescue_mode: null };
+            if (memoryRescue.results.length && memoryRescue.rescue_mode) {
+              return {
+                content: [{
+                  type: "text",
+                  text: renderContextQueryMemoryRescue({
+                    project: resolvedProject,
+                    query,
+                    scope: scope2,
+                    results: memoryRescue.results,
+                    rescue_mode: memoryRescue.rescue_mode
+                  })
+                }]
+              };
+            }
             return { content: [{ type: "text", text: "No relevant context found." }] };
           }
           const warnings = prepared.retrieval.warnings.length ? `
@@ -4897,13 +5356,36 @@ ${prepared.context}${warnings}`
           });
           const response2 = queryResult2.response;
           if (response2.results.length === 0) {
+            const memoryRescue = include_memories !== false ? await runContextQueryMemoryRescue({
+              project: resolvedProject,
+              query,
+              user_id: user_id ? scope.userId : void 0,
+              session_id: session_id ? scope.sessionId : void 0,
+              top_k
+            }) : { results: [], rescue_mode: null };
+            if (memoryRescue.results.length && memoryRescue.rescue_mode) {
+              return {
+                content: [{
+                  type: "text",
+                  text: `${renderContextQueryMemoryRescue({
+                    project: resolvedProject,
+                    query,
+                    scope,
+                    results: memoryRescue.results,
+                    rescue_mode: memoryRescue.rescue_mode
+                  })}
+
+[automatic_runtime]
+${automaticWarning}`
+                }]
+              };
+            }
             return { content: [{ type: "text", text: `No relevant context found.
 
 [automatic_runtime]
 ${automaticWarning}` }] };
           }
-          const scope2 = resolveMcpScope({ user_id, session_id });
-          const header2 = `Found ${response2.meta.total} results (${response2.meta.latency_ms}ms${response2.meta.cache_hit ? ", cached" : ""}, project=${resolvedProject}, user=${scope2.userId}, session=${scope2.sessionId}):
+          const header2 = `Found ${response2.meta.total} results (${response2.meta.latency_ms}ms${response2.meta.cache_hit ? ", cached" : ""}, project=${resolvedProject}, user=${scope.userId}, session=${scope.sessionId}):
 
 `;
           const suffix2 = queryResult2.degraded_mode ? `
@@ -4927,9 +5409,29 @@ ${automaticWarning}${suffix2}` }] };
       });
       const response = queryResult.response;
       if (response.results.length === 0) {
+        const memoryRescue = include_memories !== false ? await runContextQueryMemoryRescue({
+          project: resolvedProject,
+          query,
+          user_id: user_id ? scope.userId : void 0,
+          session_id: session_id ? scope.sessionId : void 0,
+          top_k
+        }) : { results: [], rescue_mode: null };
+        if (memoryRescue.results.length && memoryRescue.rescue_mode) {
+          return {
+            content: [{
+              type: "text",
+              text: renderContextQueryMemoryRescue({
+                project: resolvedProject,
+                query,
+                scope,
+                results: memoryRescue.results,
+                rescue_mode: memoryRescue.rescue_mode
+              })
+            }]
+          };
+        }
         return { content: [{ type: "text", text: "No relevant context found." }] };
       }
-      const scope = resolveMcpScope({ user_id, session_id });
       const header = `Found ${response.meta.total} results (${response.meta.latency_ms}ms${response.meta.cache_hit ? ", cached" : ""}, project=${resolvedProject}, user=${scope.userId}, session=${scope.sessionId}):
 
 `;
@@ -5067,10 +5569,10 @@ server.tool(
 );
 server.tool(
   "context.add_source",
-  "Add a source to a project with normalized source contract and auto-index by default.",
+  "Compatibility learning tool. Add a source to a project with normalized source contract and auto-index by default. Prefer `learn` for new integrations.",
   {
     project: z.string().optional().describe("Project name or slug"),
-    type: z.enum(["github", "web", "pdf", "local", "slack", "video"]).default("github"),
+    type: z.enum(["github", "web", "playwright", "pdf", "local", "slack", "video"]).default("github"),
     name: z.string().optional(),
     auto_index: z.boolean().optional().default(true),
     metadata: z.record(z.string()).optional(),
@@ -5089,6 +5591,8 @@ server.tool(
     path: z.string().optional(),
     glob: z.string().optional(),
     max_files: z.number().optional(),
+    max_pages: z.number().optional(),
+    extract_mode: z.enum(["text", "structured", "markdown"]).optional(),
     workspace_id: z.string().optional(),
     channel_ids: z.array(z.string()).optional(),
     since: z.string().optional(),
@@ -5127,6 +5631,8 @@ server.tool(
         path: input.path,
         glob: input.glob,
         max_files: input.max_files,
+        max_pages: input.max_pages,
+        extract_mode: input.extract_mode,
         workspace_id: input.workspace_id,
         channel_ids: input.channel_ids,
         since: input.since,
@@ -5165,7 +5671,7 @@ server.tool(
 );
 server.tool(
   "context.add_text",
-  "Add text content to a project's knowledge base.",
+  "Compatibility learning tool. Add text content to a project's knowledge base. Prefer `learn` for new integrations.",
   {
     project: z.string().optional().describe("Project name or slug"),
     title: z.string().describe("Title for this content"),
@@ -5198,7 +5704,7 @@ server.tool(
 );
 server.tool(
   "context.add_document",
-  "Ingest a document into project knowledge. Supports plain text and video URLs.",
+  "Compatibility learning tool. Ingest a document into project knowledge. Supports plain text and video URLs. Prefer `learn` for new integrations.",
   {
     project: z.string().optional().describe("Project name or slug"),
     source_type: z.enum(["text", "video"]).default("text"),
@@ -5303,7 +5809,7 @@ server.tool(
 );
 server.tool(
   "memory.ingest_conversation",
-  "Extract memories from a conversation session. Automatically handles disambiguation, temporal grounding, and relation detection.",
+  "Compatibility learning tool. Extract memories from a conversation session. Prefer `learn` for new integrations.",
   {
     project: z.string().optional().describe("Project name or slug"),
     session_id: z.string().describe("Session identifier"),
@@ -5568,6 +6074,7 @@ server.tool(
         return { content: [{ type: "text", text: "Error: target.memory_id or target.query is required." }] };
       }
       const affectedIds = [];
+      let queryResolution = null;
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const actor = process.env.WHISPER_AGENT_ID || process.env.USERNAME || "api_key_principal";
       const resolvedProject = await resolveProjectRef(project);
@@ -5626,24 +6133,18 @@ server.tool(
           project: resolvedProject,
           query: target.query || "",
           top_k: 25,
-          include_relations: false
-        });
-        const normalizedQuery = String(target.query || "").trim().toLowerCase();
-        const exactMatches = (search.results || []).filter((r) => {
-          const memory = r?.memory || r;
-          const content = String(memory?.content || "").trim().toLowerCase();
-          const memoryId = String(memory?.id || "").trim().toLowerCase();
-          const metadata = memory?.metadata || {};
-          const normalizedContent = String(metadata?.normalized_content || "").trim().toLowerCase();
-          const canonicalContent = String(metadata?.canonical_content || "").trim().toLowerCase();
-          return memoryId === normalizedQuery || content === normalizedQuery || normalizedContent === normalizedQuery || canonicalContent === normalizedQuery;
+          include_relations: false,
+          include_pending: true
         });
-        const memoryIds = exactMatches.map((r) => String(r?.memory?.id || "")).filter(Boolean);
+        const resolved = resolveForgetQueryCandidates(search, target.query || "");
+        queryResolution = resolved.resolved_by;
+        const memoryIds = resolved.memory_ids;
         if (memoryIds.length === 0) {
           const payload2 = {
             status: "completed",
             affected_ids: affectedIds,
-            warning: "Query did not resolve to an exact memory match. No memories were changed."
+            warning: resolved.warning || "Query did not resolve to a reliable memory match. No memories were changed.",
+            resolved_by: resolved.resolved_by
           };
           return { content: [{ type: "text", text: JSON.stringify(payload2, null, 2) }] };
         }
@@ -5665,6 +6166,7 @@ server.tool(
       const payload = {
         status: "completed",
         affected_ids: affectedIds,
+        ...queryResolution ? { resolved_by: queryResolution } : {},
         audit: {
           audit_id: audit.audit_id,
           actor: audit.actor,
@@ -5959,30 +6461,45 @@ var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", ".next"
 var CODE_EXTENSIONS = /* @__PURE__ */ new Set(["ts", "tsx", "js", "jsx", "py", "go", "rs", "java", "cpp", "c", "cs", "rb", "php", "swift", "kt", "sql", "prisma", "graphql", "json", "yaml", "yml", "toml", "env"]);
 function extractSignature(filePath, content) {
   const lines = content.split("\n");
-  const signature = [`// File: ${filePath}`];
+  const signature = /* @__PURE__ */ new Set([`// File: ${filePath}`]);
+  for (const segment of filePath.split(/[\\/._-]+/).filter(Boolean)) {
+    signature.add(`path:${segment}`);
+  }
   const head = lines.slice(0, 60);
   for (const line of head) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+    const urlMatches = trimmed.match(/https?:\/\/[^\s"'`]+/g);
+    if (urlMatches) {
+      for (const match of urlMatches.slice(0, 2)) signature.add(`url:${match.slice(0, 120)}`);
+    }
+    const routeMatches = trimmed.match(/\/[A-Za-z0-9._~!$&'()*+,;=:@%/-]{2,}/g);
+    if (routeMatches) {
+      for (const match of routeMatches.slice(0, 3)) signature.add(`route:${match.slice(0, 120)}`);
+    }
     if (/^(import|from|require|use |pub use )/.test(trimmed)) {
-      signature.push(trimmed.slice(0, 120));
+      signature.add(trimmed.slice(0, 120));
       continue;
     }
     if (/^(export|async function|function|class|interface|type |const |let |def |pub fn |fn |struct |impl |enum )/.test(trimmed)) {
-      signature.push(trimmed.slice(0, 120));
+      signature.add(trimmed.slice(0, 120));
       continue;
     }
     if (trimmed.startsWith("@") || trimmed.startsWith("#[")) {
-      signature.push(trimmed.slice(0, 80));
+      signature.add(trimmed.slice(0, 80));
     }
   }
   for (const line of lines.slice(60)) {
     const trimmed = line.trim();
     if (/^(export (default |async )?function|export (default )?class|export const|export type|export interface|async function|function |class |def |pub fn |fn )/.test(trimmed)) {
-      signature.push(trimmed.slice(0, 120));
+      signature.add(trimmed.slice(0, 120));
+      continue;
+    }
+    if (/^[A-Za-z0-9_$]+\s*[:=]\s*["'`][^"'`]{3,}["'`]/.test(trimmed)) {
+      signature.add(trimmed.slice(0, 120));
     }
   }
-  return signature.join("\n").slice(0, 2e3);
+  return Array.from(signature).join("\n").slice(0, 2500);
 }
 server.tool(
   "code.search_semantic",
@@ -5996,91 +6513,21 @@ server.tool(
     max_files: z.number().optional().default(150).describe("Max files to scan. For large codebases, narrow with file_types instead of raising this.")
   },
   async ({ query, path: searchPath, file_types, top_k, threshold, max_files }) => {
-    const rootPath = searchPath || process.cwd();
-    const allowedExts = file_types ? new Set(file_types) : CODE_EXTENSIONS;
-    const files = [];
-    function collect(dir) {
-      if (files.length >= (max_files ?? 300)) return;
-      let entries;
-      try {
-        entries = readdirSync(dir, { withFileTypes: true });
-      } catch {
-        return;
-      }
-      for (const entry of entries) {
-        if (files.length >= (max_files ?? 300)) break;
-        if (SKIP_DIRS.has(entry.name)) continue;
-        const full = join(dir, entry.name);
-        if (entry.isDirectory()) {
-          collect(full);
-        } else if (entry.isFile()) {
-          const ext = extname(entry.name).replace(".", "");
-          if (allowedExts.has(ext)) files.push(full);
-        }
-      }
-    }
-    collect(rootPath);
-    if (files.length === 0) {
-      return { content: [{ type: "text", text: `No code files found in ${rootPath}` }] };
-    }
-    const documents = [];
-    for (const filePath of files) {
-      try {
-        const stat = statSync(filePath);
-        if (stat.size > 500 * 1024) continue;
-        const content = readFileSync(filePath, "utf-8");
-        const relPath = relative(rootPath, filePath);
-        const signature = extractSignature(relPath, content);
-        documents.push({ id: relPath, content: signature });
-      } catch {
-      }
-    }
-    if (documents.length === 0) {
-      return { content: [{ type: "text", text: "Could not read any files." }] };
-    }
-    let response;
     try {
-      response = await whisper.semanticSearch({
-        query,
-        documents,
-        top_k: top_k ?? 10,
-        threshold: threshold ?? 0.2
+      return primaryToolSuccess({
+        ...await runSearchCodeTool({
+          query,
+          path: searchPath,
+          file_types,
+          top_k,
+          threshold,
+          max_files
+        }),
+        tool: "code.search_semantic"
       });
     } catch (error) {
-      return { content: [{ type: "text", text: `Semantic search failed: ${error.message}` }] };
-    }
-    if (!response.results || response.results.length === 0) {
-      return { content: [{ type: "text", text: `No semantically relevant files found for: "${query}"
-
-Searched ${documents.length} files in ${rootPath}.
-
-Try lowering the threshold or rephrasing your query.` }] };
-    }
-    const lines = [
-      `Semantic search: "${query}"`,
-      `Searched ${documents.length} files \u2192 ${response.results.length} relevant (${response.latency_ms}ms)
-`
-    ];
-    for (const result of response.results) {
-      lines.push(`\u{1F4C4} ${result.id}  (score: ${result.score})`);
-      if (result.snippet) {
-        lines.push(`   ${result.snippet}`);
-      }
-      if (result.score > 0.5) {
-        try {
-          const fullPath = join(rootPath, result.id);
-          const content = readFileSync(fullPath, "utf-8");
-          const excerpt = content.split("\n").slice(0, 30).join("\n");
-          lines.push(`
-\`\`\`
-${excerpt}
-\`\`\``);
-        } catch {
-        }
-      }
-      lines.push("");
+      return primaryToolError(`Semantic search failed: ${error.message}`);
     }
-    return { content: [{ type: "text", text: lines.join("\n") }] };
   }
 );
 function* walkDir(dir, fileTypes) {
@@ -6397,72 +6844,15 @@ server.tool(
     max_files: z.number().optional().default(150)
   },
   async ({ query, path, file_types, top_k, threshold, max_files }) => {
-    const rootPath = path || process.cwd();
-    const allowedExts = file_types ? new Set(file_types) : CODE_EXTENSIONS;
-    const files = [];
-    function collect(dir) {
-      if (files.length >= (max_files ?? 150)) return;
-      let entries;
-      try {
-        entries = readdirSync(dir, { withFileTypes: true });
-      } catch {
-        return;
-      }
-      for (const entry of entries) {
-        if (files.length >= (max_files ?? 150)) break;
-        if (SKIP_DIRS.has(entry.name)) continue;
-        const full = join(dir, entry.name);
-        if (entry.isDirectory()) collect(full);
-        else if (entry.isFile()) {
-          const ext = extname(entry.name).replace(".", "");
-          if (allowedExts.has(ext)) files.push(full);
-        }
-      }
-    }
-    collect(rootPath);
-    if (files.length === 0) {
-      return primaryToolSuccess({
-        tool: "search_code",
-        query,
-        path: rootPath,
-        results: [],
-        count: 0
-      });
-    }
-    const documents = [];
-    for (const filePath of files) {
-      try {
-        const stat = statSync(filePath);
-        if (stat.size > 500 * 1024) continue;
-        const content = readFileSync(filePath, "utf-8");
-        const relPath = relative(rootPath, filePath);
-        documents.push({ id: relPath, content: extractSignature(relPath, content) });
-      } catch {
-      }
-    }
     try {
-      const response = await whisper.semanticSearch({
+      return primaryToolSuccess(await runSearchCodeTool({
         query,
-        documents,
-        top_k: top_k ?? 10,
-        threshold: threshold ?? 0.2
-      });
-      if (!response.results?.length) {
-        return primaryToolSuccess({
-          tool: "search_code",
-          query,
-          path: rootPath,
-          results: [],
-          count: 0
-        });
-      }
-      return primaryToolSuccess({
-        tool: "search_code",
-        query,
-        path: rootPath,
-        results: response.results,
-        count: response.results.length
-      });
+        path,
+        file_types,
+        top_k,
+        threshold,
+        max_files
+      }));
     } catch (error) {
       return primaryToolError(`Semantic search failed: ${error.message}`);
     }
@@ -6610,7 +7000,7 @@ server.tool(
   {
     action: z.enum(["source", "workspace"]).default("source"),
     project: z.string().optional(),
-    type: z.enum(["github", "web", "pdf", "local", "slack", "video"]).optional(),
+    type: z.enum(["github", "web", "playwright", "pdf", "local", "slack", "video"]).optional(),
     name: z.string().optional(),
     owner: z.string().optional(),
     repo: z.string().optional(),
@@ -6766,25 +7156,55 @@ server.tool(
 );
 server.tool(
   "learn",
-  "Learn content or connect a source so it becomes retrievable later. Use this for docs, URLs, repos, files, or local paths.",
+  "Unified learning tool for conversation memory, text ingestion, and source indexing. Prefer this over the older learning-adjacent compatibility tools.",
   {
+    mode: z.enum(["conversation", "text", "source"]).describe("What kind of learning to perform"),
     project: z.string().optional(),
+    user_id: z.string().optional().describe("Optional end-user identity for conversation learning"),
+    session_id: z.string().optional().describe("Session identifier for conversation learning"),
+    messages: z.array(z.object({
+      role: z.string(),
+      content: z.string(),
+      timestamp: z.string().optional()
+    })).optional().describe("Conversation messages to learn from"),
+    title: z.string().optional().describe("Title for text learning"),
     content: z.string().optional().describe("Inline text content to ingest"),
-    title: z.string().optional().describe("Title for inline content"),
+    metadata: z.record(z.any()).optional(),
+    tags: z.array(z.string()).optional(),
+    namespace: z.string().optional(),
+    type: z.enum(["github", "web", "playwright", "pdf", "local", "slack", "video"]).optional().describe("Source type when mode=source"),
     url: z.string().optional().describe("URL to learn from"),
     owner: z.string().optional().describe("GitHub owner"),
     repo: z.string().optional().describe("GitHub repository"),
     branch: z.string().optional(),
+    paths: z.array(z.string()).optional(),
     path: z.string().optional().describe("Local path to learn from"),
     file_path: z.string().optional().describe("Single file path to learn from"),
     name: z.string().optional().describe("Optional source name"),
-    metadata: z.record(z.string()).optional(),
-    ingestion_profile: z.enum(["auto", "repo", "web_docs", "pdf_layout", "video_transcript", "plain_text"]).optional(),
-    strategy_override: z.enum(["fixed", "recursive", "semantic", "hierarchical", "adaptive"]).optional(),
-    profile_config: z.record(z.any()).optional(),
-    max_files: z.number().optional(),
-    glob: z.string().optional(),
-    crawl_depth: z.number().optional()
+    channel_ids: z.array(z.string()).optional(),
+    since: z.string().optional(),
+    token: z.string().optional(),
+    auth_ref: z.string().optional(),
+    platform: z.enum(["youtube", "loom", "generic"]).optional(),
+    language: z.string().optional(),
+    options: z.object({
+      async: z.boolean().optional(),
+      auto_index: z.boolean().optional(),
+      ingestion_profile: z.enum(["auto", "repo", "web_docs", "pdf_layout", "video_transcript", "plain_text"]).optional(),
+      strategy_override: z.enum(["fixed", "recursive", "semantic", "hierarchical", "adaptive"]).optional(),
+      profile_config: z.record(z.any()).optional(),
+      crawl_depth: z.number().optional(),
+      include_paths: z.array(z.string()).optional(),
+      exclude_paths: z.array(z.string()).optional(),
+      glob: z.string().optional(),
+      max_files: z.number().optional(),
+      max_pages: z.number().optional(),
+      extract_mode: z.enum(["text", "structured", "markdown"]).optional(),
+      workspace_id: z.string().optional(),
+      allow_stt_fallback: z.boolean().optional(),
+      max_duration_minutes: z.number().optional(),
+      max_chunks: z.number().optional()
+    }).optional()
   },
   async (input) => {
     try {
@@ -6867,8 +7287,14 @@ if (process.argv[1] && /server\.(mjs|cjs|js|ts)$/.test(process.argv[1])) {
   main().catch(console.error);
 }
 export {
+  canonicalizeWorkspacePath,
+  chooseWorkspaceProjectSource,
+  classifyWorkspaceHealth,
   createMcpServer,
   createWhisperMcpClient,
   createWhisperMcpRuntimeClient,
-  renderScopedMcpConfig
+  extractSignature,
+  renderScopedMcpConfig,
+  resolveForgetQueryCandidates,
+  runSearchCodeSearch
 };