@usewhisper/mcp-server 2.9.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";
 
@@ -3879,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) {
@@ -3978,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];
@@ -3988,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 {
@@ -4101,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,
@@ -4177,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");
@@ -4218,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;
@@ -4297,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 = [];
@@ -4333,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}
@@ -4488,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) }] };
@@ -4521,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) {
@@ -4557,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),
@@ -4572,6 +4986,7 @@ server.tool(
       saveState(state);
       const payload = {
         workspace_id: workspaceId,
+        root_path: rootPath,
         mode,
         indexed_files: fileStats.total,
         skipped_files: fileStats.skipped,
@@ -4636,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,
@@ -4661,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,
@@ -4672,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) {
@@ -4692,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,
@@ -4714,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";
@@ -4724,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."
       };
@@ -4754,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",
@@ -4795,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",
@@ -4821,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) }] };
       }
@@ -4834,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,
@@ -4867,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 {
@@ -4878,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 ? `
@@ -4912,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 ? `
@@ -4942,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}):
 
 `;
@@ -5587,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);
@@ -5645,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) }] };
         }
@@ -5684,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,
@@ -5978,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",
@@ -6015,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) {
@@ -6416,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}`);
     }
@@ -6916,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
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usewhisper/mcp-server",
-  "version": "2.9.0",
+  "version": "2.10.0",
   "whisperContractVersion": "2026.03.10",
   "scripts": {
     "build": "tsup ../src/mcp/server.ts --format esm --out-dir dist",