@context-engine-bridge/context-engine-mcp-bridge 0.0.83 → 0.0.85

package/AGENTS.md

@@ -0,0 +1,69 @@
+<!-- Parent: ../AGENTS.md -->
+<!-- Generated: 2026-02-19 | Updated: 2026-02-19 -->
+
+# ctx-mcp-bridge
+
+## Purpose
+
+The MCP bridge (`ctxce` CLI) is a Model Context Protocol server that aggregates the Context Engine indexer and memory servers into a single unified MCP server. It supports both stdio and HTTP transport modes, making it compatible with MCP clients like Claude Code, Windsurf, Augment, and others. The bridge is primarily launched by the VS Code extension but can run standalone.
+
+## Key Files
+
+| File | Description |
+|------|-------------|
+| `bin/ctxce.js` | CLI entry point and executable (chmod +x 755) |
+| `src/cli.js` | Command routing and argument parsing for `mcp-serve`, `mcp-http-serve`, `auth`, `connect` |
+| `src/mcpServer.js` | MCP server implementation with stdio/HTTP transport, tool deduping, and auth handling |
+| `src/authCli.js` | Auth command handlers: `login`, `logout`, `status` with token and password flows |
+| `src/authConfig.js` | Session storage and management in `~/.ctxce/auth.json` |
+| `src/oauthHandler.js` | OAuth protocol support for remote deployments |
+| `src/uploader.js` | Standalone code uploader integration |
+| `src/connectCli.js` | Connection validation and setup helpers |
+| `src/resultPathMapping.js` | Path remapping for tool results (container/host paths) |
+| `package.json` | Node.js package manifest (requires Node >= 18) |
+
+## Subdirectories
+
+| Directory | Purpose |
+|-----------|---------|
+| `bin/` | Executable CLI entry point |
+| `docs/` | Debugging guides and documentation |
+| `src/` | Core MCP server and auth logic (see `src/AGENTS.md`) |
+
+## For AI Agents
+
+### Working In This Directory
+
+This is a Node.js MCP bridge package. Changes to MCP routing, tool forwarding, or auth handling require updates to `src/cli.js` and `src/mcpServer.js`. The bridge proxies requests between MCP clients and remote indexer/memory HTTP servers, so test both stdio and HTTP modes.
+
+### Testing Requirements
+
+- Run with `npm start` or `node bin/ctxce.js --help`
+- Test MCP stdio mode: `ctxce mcp-serve --workspace /tmp/test`
+- Test MCP HTTP mode: `ctxce mcp-http-serve --workspace /tmp/test --port 30810`
+- Test auth commands: `ctxce auth login --backend-url http://localhost:8004 --token TEST_TOKEN`
+- Verify auth state: `ctxce auth status --backend-url http://localhost:8004 --json`
+- E2E tests: `npm run test:e2e`
+
+### Common Patterns
+
+- Environment variables: `CTXCE_INDEXER_URL`, `CTXCE_MEMORY_URL`, `CTXCE_HTTP_PORT`, `CTXCE_AUTH_*`
+- Auth sessions stored in `~/.ctxce/auth.json` keyed by backend URL
+- MCP tools are deduplicated and forwarded from indexer and memory servers
+- Path remapping (host paths <-> container paths) handled transparently
+- All MCP requests are logged to stderr or `CTXCE_DEBUG_LOG` if set
+
+## Dependencies
+
+### Internal
+- Context Engine indexer (HTTP endpoint at `CTXCE_INDEXER_URL` or `http://localhost:8003/mcp`)
+- Context Engine memory server (HTTP endpoint at `CTXCE_MEMORY_URL` or `http://localhost:8002/mcp`)
+- Auth backend (optional, at `CTXCE_AUTH_BACKEND_URL` or `http://localhost:8004`)
+
+### External
+- `@modelcontextprotocol/sdk` (^1.24.3) – MCP protocol implementation
+- `zod` (^3.25.0) – Runtime type validation
+- `tar` (^7.5.9) – Archive support for uploads
+- `ignore` (^7.0.5) – .gitignore-style file filtering
+
+<!-- MANUAL: Any manually added notes below this line are preserved on regeneration -->

package/bin/AGENTS.md

@@ -0,0 +1,34 @@
+<!-- Parent: ../AGENTS.md -->
+<!-- Generated: 2026-02-19 | Updated: 2026-02-19 -->
+
+# bin
+
+## Purpose
+
+Executable CLI entry point for the `ctxce` command (also aliased as `ctxce-bridge`). This directory contains the shebang-wrapped Node.js script that is installed globally or via npm when the package is installed.
+
+## Key Files
+
+| File | Description |
+|------|-------------|
+| `ctxce.js` | CLI executable entry point (Node.js script, chmod +x 755) |
+
+## For AI Agents
+
+### Working In This Directory
+
+Do not modify `ctxce.js` directly unless changing the CLI bootstrap. The actual CLI logic is in `src/cli.js`. The executable must have a shebang (`#!/usr/bin/env node`) and be marked executable on Unix systems.
+
+### Testing Requirements
+
+- Verify executable permission: `ls -l bin/ctxce.js` should show `-rwxr-xr-x`
+- Test global install: `npm install -g` and run `ctxce --help`
+- Test npx mode: `npx @context-engine-bridge/context-engine-mcp-bridge ctxce --help`
+- Postinstall script auto-fixes permissions on non-Windows systems
+
+## Dependencies
+
+### Internal
+- `src/cli.js` – Main CLI router and handler
+
+<!-- MANUAL: Any manually added notes below this line are preserved on regeneration -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.83",
+  "version": "0.0.85",
   "description": "Context Engine MCP bridge (http/stdio proxy combining indexer + memory servers)",
   "bin": {
     "ctxce": "bin/ctxce.js",

package/src/AGENTS.md

@@ -0,0 +1,59 @@
+<!-- Parent: ../AGENTS.md -->
+<!-- Generated: 2026-02-19 | Updated: 2026-02-19 -->
+
+# src
+
+## Purpose
+
+Core MCP server implementation, auth handling, and CLI routing for the `ctxce` bridge. This module aggregates the Context Engine indexer and memory servers, manages authentication sessions, and handles both stdio and HTTP transport modes.
+
+## Key Files
+
+| File | Description |
+|------|-------------|
+| `cli.js` | Main command router for `mcp-serve`, `mcp-http-serve`, `auth`, `connect` subcommands; parses CLI flags and environment variables |
+| `mcpServer.js` | MCP server implementation; proxies requests to indexer/memory servers, dedupes tools, handles auth, supports stdio and HTTP transports |
+| `authCli.js` | Auth command handlers for `login`, `logout`, `status` with token and password flows; manages session lifecycle |
+| `authConfig.js` | Persistent auth state in `~/.ctxce/auth.json`; session loading, saving, TTL handling, OAuth support |
+| `oauthHandler.js` | OAuth protocol implementation for token refresh and remote auth flows |
+| `uploader.js` | Integration with the standalone code uploader (tar archive support, progress tracking) |
+| `connectCli.js` | Connection validation, workspace discovery, and setup helpers |
+| `resultPathMapping.js` | Path remapping for tool results (host paths <-> container paths); handles path translation for Docker environments |
+
+## For AI Agents
+
+### Working In This Directory
+
+This is the core business logic. Changes to MCP command handling, tool routing, or auth flows affect both the CLI and the VS Code extension. The server proxies all tool requests to remote indexer/memory servers and dedupes tool lists to prevent duplicates. Auth is optional but handles session TTL, token refresh, and fallback to dev tokens.
+
+### Testing Requirements
+
+- Test MCP stdio transport: `node src/cli.js mcp-serve --workspace /tmp/test`
+- Test MCP HTTP transport: `node src/cli.js mcp-http-serve --workspace /tmp/test --port 30810`
+- Test auth login: `node src/cli.js auth login --backend-url http://localhost:8004 --token TOKEN`
+- Test auth status: `node src/cli.js auth status --backend-url http://localhost:8004 --json`
+- Verify tool deduping: Check that tools from indexer and memory are merged without duplicates
+- Test path remapping: Verify that container paths are correctly mapped for Docker environments
+- Run E2E tests: `npm run test:e2e`, `npm run test:e2e:auth`, `npm run test:e2e:happy`, `npm run test:e2e:edge`
+
+### Common Patterns
+
+- Environment variables guide server initialization: `CTXCE_INDEXER_URL`, `CTXCE_MEMORY_URL`, `CTXCE_HTTP_PORT`, `CTXCE_AUTH_BACKEND_URL`, `CTXCE_AUTH_ENABLED`, `CTXCE_DEBUG_LOG`
+- Sessions are stored per backend URL in `~/.ctxce/auth.json` with TTL tracking
+- All MCP tools from indexer and memory are merged and deduplicated before listing
+- Path remapping is applied to tool arguments and results for Docker host/container path translation
+- Debug logging goes to stderr and optionally to a file (set `CTXCE_DEBUG_LOG` env var)
+- HTTP transport uses Node.js `createServer` with MCP's `StreamableHTTPServerTransport`
+
+## Dependencies
+
+### Internal
+- `bin/ctxce.js` – CLI entry point that imports and runs these modules
+
+### External
+- `@modelcontextprotocol/sdk` – MCP protocol (Server, StdioServerTransport, StreamableHTTPServerTransport, Client, StreamableHTTPClientTransport)
+- `zod` – Runtime type validation (used in config parsing)
+- `tar` – Archive handling for uploader
+- `ignore` – File filtering for .gitignore patterns
+
+<!-- MANUAL: Any manually added notes below this line are preserved on regeneration -->

package/src/authConfig.js

@@ -152,3 +152,26 @@ export function saveResolvedCollection(backendUrl, scope, collection) {
   };
   writeConfig(all);
 }
+
+export function clearResolvedCollection(backendUrl, scope) {
+  if (!backendUrl) {
+    return;
+  }
+  const scopeKey = buildResolvedCollectionScopeKey(scope);
+  if (!scopeKey) {
+    return;
+  }
+  const all = readConfig();
+  const key = String(backendUrl);
+  const existingEntry = all[key] && typeof all[key] === "object" ? all[key] : {};
+  const resolvedCollections = { ...getResolvedCollections(existingEntry) };
+  if (!Object.prototype.hasOwnProperty.call(resolvedCollections, scopeKey)) {
+    return;
+  }
+  delete resolvedCollections[scopeKey];
+  all[key] = {
+    ...existingEntry,
+    [RESOLVED_COLLECTIONS_KEY]: resolvedCollections,
+  };
+  writeConfig(all);
+}

package/src/mcpServer.js

@@ -12,6 +12,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import {
+  clearResolvedCollection,
   loadAnyAuthEntry,
   loadAuthEntry,
   loadResolvedCollection,
@@ -264,7 +265,7 @@ async function sendSessionDefaults(client, payload, label) {
   try {
     await client.callTool({
       name: "set_session_defaults",
-      arguments: payload,
+      arguments: { ...payload },
     });
   } catch (err) {
     // eslint-disable-next-line no-console
@@ -522,6 +523,70 @@ function isConnectionDeadError(error) {
   }
 }
 
+/**
+ * Detect a strong signal that the active collection has been deleted on the server.
+ * Only triggers on unambiguous signals to avoid false positives on transient errors.
+ *
+ * Signals recognized:
+ *   - HTTP 404 error whose message contains a collection-related keyword
+ *   - Error code "COLLECTION_DELETED"
+ *   - Error message containing "collection_deleted", "collection not found",
+ *     "collection doesn't exist", or "collection does not exist"
+ */
+function isCollectionDeletedSignal(error) {
+  try {
+    if (!error) return false;
+    // Explicit error code
+    if (
+      typeof error.code === "string" &&
+      error.code.toUpperCase() === "COLLECTION_DELETED"
+    ) {
+      return true;
+    }
+    const msg = _errorMessage(error);
+    if (!msg) return false;
+    const lower = msg.toLowerCase();
+    // 404 with a collection-related keyword is a strong signal
+    if (
+      (lower.includes("404") || lower.includes("not found")) &&
+      lower.includes("collection")
+    ) {
+      return true;
+    }
+    // Explicit deletion phrases
+    if (
+      lower.includes("collection_deleted") ||
+      lower.includes("collection not found") ||
+      lower.includes("collection doesn't exist") ||
+      lower.includes("collection does not exist")
+    ) {
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Inspect a successful tool call result for an explicit collection_deleted flag.
+ * Returns true only when the response payload contains `collection_deleted: true`.
+ */
+function resultIndicatesCollectionDeleted(result) {
+  try {
+    if (!result || !Array.isArray(result.content)) return false;
+    const textBlock = result.content.find((c) => c && c.type === "text");
+    if (!textBlock || typeof textBlock.text !== "string") return false;
+    const parsed = JSON.parse(textBlock.text);
+    if (parsed && parsed.collection_deleted === true) return true;
+    // Also check nested result envelope
+    if (parsed && parsed.result && parsed.result.collection_deleted === true) return true;
+    return false;
+  } catch {
+    return false;
+  }
+}
+
 // MCP stdio server implemented using the official MCP TypeScript SDK.
 // Acts as a low-level proxy for tools, forwarding tools/list and tools/call
 // to the remote qdrant-indexer MCP server while adding a local `ping` tool.
@@ -647,6 +712,12 @@ async function fetchBridgeCollectionState({
         );
         return null;
       }
+      if (resp.status === 404) {
+        // Server is reachable but has no workspace state — do NOT fall back to local caches.
+        // This can happen when workspace state was cleaned up during collection deletion.
+        debugLog("[ctxce] /bridge/state responded 404; server has no state for this workspace");
+        return { _server_reachable: true };
+      }
       throw new Error(`bridge/state responded ${resp.status}`);
     }
     debugLog(`[ctxce] bridge/state responded ${resp.status}`);
@@ -711,26 +782,11 @@ export async function buildDefaultsPayload({
     logicalRepoId = "";
   }
 
-  const exactWorkspaceCollection = !pinnedCollection
-    ? _readExactWorkspaceCachedCollection(workspace)
-    : null;
-
-  if (!defaultsPayload.collection && exactWorkspaceCollection) {
-    defaultsPayload.collection = exactWorkspaceCollection;
-    log(`[ctxce] Using exact workspace cached collection: ${exactWorkspaceCollection}`);
-  }
-
-  if (!defaultsPayload.collection && backendHint && logicalRepoId) {
-    const cachedCollection = loadResolvedCollectionHint(backendHint, {
-      orgId: resolvedAuthEntry?.org_id,
-      orgSlug: resolvedAuthEntry?.org_slug,
-      logicalRepoId,
-    });
-    if (cachedCollection) {
-      defaultsPayload.collection = cachedCollection;
-      log(`[ctxce] Using cached resolved collection from auth store: ${cachedCollection}`);
-    }
-  }
+  // --- Server-first collection resolution ---
+  // Priority: pinned > server /bridge/state > local caches (fallback only).
+  // This prevents stale local caches from winning over server truth
+  // after a collection is deleted.
+  let serverResolved = false;
 
   if (!pinnedCollection) {
     try {
@@ -745,31 +801,87 @@ export async function buildDefaultsPayload({
         uploadServiceUrl,
       });
       if (state) {
-        const servingCollection = typeof state.serving_collection === "string"
-          ? state.serving_collection.trim()
-          : "";
-        const activeCollection = typeof state.active_collection === "string"
-          ? state.active_collection.trim()
-          : "";
-        if (servingCollection) {
-          defaultsPayload.collection = servingCollection;
-          if (!configuredCollection || configuredCollection !== servingCollection) {
-            log(`[ctxce] Using serving collection from /bridge/state: ${servingCollection}`);
+        // Server responded 404 — reachable but no workspace state.
+        // Mark serverResolved to prevent falling back to stale local caches.
+        if (state._server_reachable && !state.collection_deleted && !state.serving_collection && !state.active_collection) {
+          serverResolved = true;
+          log("[ctxce] Server reachable but no workspace state found, skipping local cache fallback");
+        }
+        // Handle explicit collection_deleted signal from the server
+        if (state.collection_deleted === true) {
+          log("[ctxce] Server reports collection deleted, clearing all local caches");
+          defaultsPayload.collection = "";
+          serverResolved = true;
+          try {
+            _clearExactWorkspaceCachedCollection(workspace);
+          } catch (wsErr) {
+            log("[ctxce] Failed to clear workspace ctx_config.json default_collection: " + String(wsErr));
+          }
+          // Clear the auth.json resolved collection cache
+          try {
+            if (backendHint && logicalRepoId) {
+              clearResolvedCollection(backendHint, {
+                orgId: resolvedAuthEntry?.org_id,
+                orgSlug: resolvedAuthEntry?.org_slug,
+                logicalRepoId,
+              });
+            }
+          } catch (authErr) {
+            log("[ctxce] Failed to clear auth.json resolved collection: " + String(authErr));
           }
-          if (backendHint && logicalRepoId) {
-            saveResolvedCollectionHint(backendHint, {
-              orgId: resolvedAuthEntry?.org_id,
-              orgSlug: resolvedAuthEntry?.org_slug,
-              logicalRepoId,
-            }, servingCollection);
+        } else {
+          const servingCollection = typeof state.serving_collection === "string"
+            ? state.serving_collection.trim()
+            : "";
+          const activeCollection = typeof state.active_collection === "string"
+            ? state.active_collection.trim()
+            : "";
+          if (servingCollection) {
+            defaultsPayload.collection = servingCollection;
+            serverResolved = true;
+            if (!configuredCollection || configuredCollection !== servingCollection) {
+              log(`[ctxce] Using serving collection from /bridge/state: ${servingCollection}`);
+            }
+            // Update local caches to match server truth
+            if (backendHint && logicalRepoId) {
+              saveResolvedCollectionHint(backendHint, {
+                orgId: resolvedAuthEntry?.org_id,
+                orgSlug: resolvedAuthEntry?.org_slug,
+                logicalRepoId,
+              }, servingCollection);
+            }
+            _writeExactWorkspaceCachedCollection(workspace, servingCollection);
+          } else if (activeCollection) {
+            defaultsPayload.collection = activeCollection;
+            serverResolved = true;
+            log(`[ctxce] Using active collection from /bridge/state: ${activeCollection}`);
           }
-        } else if (!defaultsPayload.collection && activeCollection) {
-          defaultsPayload.collection = activeCollection;
-          log(`[ctxce] Using active collection from /bridge/state fallback: ${activeCollection}`);
         }
       }
     } catch (err) {
-      log("[ctxce] bridge/state lookup failed: " + String(err));
+      log("[ctxce] bridge/state lookup failed, falling back to local caches: " + String(err));
+    }
+  }
+
+  // Fallback to local caches ONLY when server is unreachable
+  if (!serverResolved && !pinnedCollection) {
+    const exactWorkspaceCollection = _readExactWorkspaceCachedCollection(workspace);
+
+    if (!defaultsPayload.collection && exactWorkspaceCollection) {
+      defaultsPayload.collection = exactWorkspaceCollection;
+      log(`[ctxce] WARNING: Using cached collection ${exactWorkspaceCollection} (server unavailable — may be stale)`);
+    }
+
+    if (!defaultsPayload.collection && backendHint && logicalRepoId) {
+      const cachedCollection = loadResolvedCollectionHint(backendHint, {
+        orgId: resolvedAuthEntry?.org_id,
+        orgSlug: resolvedAuthEntry?.org_slug,
+        logicalRepoId,
+      });
+      if (cachedCollection) {
+        defaultsPayload.collection = cachedCollection;
+        log(`[ctxce] WARNING: Using cached collection ${cachedCollection} from auth store (server unavailable — may be stale)`);
+      }
     }
   }
 
@@ -832,6 +944,74 @@ function _readExactWorkspaceCachedCollection(workspacePath) {
   }
 }
 
+function _writeExactWorkspaceCachedCollection(workspacePath, collection) {
+  try {
+    const resolvedWorkspace = _validateWorkspacePath(workspacePath);
+    if (!resolvedWorkspace) return;
+    const wsDir = _computeWorkspaceDir(resolvedWorkspace);
+    const configPath = path.join(wsDir, "ctx_config.json");
+    if (!fs.existsSync(configPath)) return;
+    const existing = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    if (existing && typeof existing === "object") {
+      existing.default_collection = collection;
+      fs.writeFileSync(configPath, JSON.stringify(existing, null, 2), "utf8");
+    }
+  } catch (_) {}
+}
+
+function _clearExactWorkspaceCachedCollection(workspacePath) {
+  try {
+    const resolvedWorkspace = _validateWorkspacePath(workspacePath);
+    if (!resolvedWorkspace) return;
+    const wsDir = _computeWorkspaceDir(resolvedWorkspace);
+    // Clear default_collection from ctx_config.json
+    const configPath = path.join(wsDir, "ctx_config.json");
+    if (fs.existsSync(configPath)) {
+      try {
+        const existing = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        if (existing && existing.default_collection) {
+          existing.default_collection = "";
+          fs.writeFileSync(configPath, JSON.stringify(existing, null, 2), "utf8");
+        }
+      } catch (_) {}
+    }
+    // Clear session_collections.json (may reference the deleted collection)
+    const sessionCollPath = path.join(wsDir, "session_collections.json");
+    try {
+      if (fs.existsSync(sessionCollPath)) {
+        fs.unlinkSync(sessionCollPath);
+        debugLog("[ctxce] Cleared session_collections.json after collection deletion");
+      }
+    } catch (_) {}
+    // Clear workspace hints (PID-keyed hint files in ~/.ctxce/workspace-hints/)
+    try {
+      const hintsDir = path.join(os.homedir(), ".ctxce", "workspace-hints");
+      if (fs.existsSync(hintsDir)) {
+        // Clear hint for current process tree (ppid is the VS Code process)
+        const currentPpid = process.ppid;
+        if (currentPpid && currentPpid > 1) {
+          const currentHint = path.join(hintsDir, `${currentPpid}.json`);
+          try {
+            if (fs.existsSync(currentHint)) {
+              fs.unlinkSync(currentHint);
+              debugLog(`[ctxce] Cleared workspace hint for current VS Code process (PID ${currentPpid})`);
+            }
+          } catch (_) {}
+        }
+        // Also clean up stale hints for dead PIDs
+        for (const name of fs.readdirSync(hintsDir)) {
+          if (!name.endsWith(".json")) continue;
+          const pid = parseInt(name.replace(".json", ""), 10);
+          if (!pid || pid <= 1) continue;
+          try { process.kill(pid, 0); } catch (_) {
+            try { fs.unlinkSync(path.join(hintsDir, name)); } catch (_) {}
+          }
+        }
+      }
+    } catch (_) {}
+  } catch (_) {}
+}
+
 const MAX_WS_SCAN = 50;
 
 function _resolveWorkspace(providedWorkspace) {
@@ -1062,6 +1242,62 @@ async function createBridgeServer(options) {
     uploadServiceUrl,
   });
 
+  async function recoverDeletedCollection(reason) {
+    debugLog(`[ctxce] Collection appears deleted (${reason}), clearing cache and re-resolving`);
+    defaultsPayload.collection = "";
+    try {
+      _clearExactWorkspaceCachedCollection(workspace);
+    } catch (wsErr) {
+      debugLog("[ctxce] Failed to clear workspace collection cache: " + String(wsErr));
+    }
+    try {
+      if (backendHint) {
+        const authEntry = loadAuthEntry(backendHint);
+        let repoId = "";
+        try { repoId = computeLogicalRepoIdentity(workspace)?.id || ""; } catch { repoId = ""; }
+        clearResolvedCollection(backendHint, {
+          orgId: authEntry?.org_id,
+          orgSlug: authEntry?.org_slug,
+          logicalRepoId: repoId,
+        });
+      }
+    } catch (clearErr) {
+      debugLog("[ctxce] Failed to clear resolved collection cache: " + String(clearErr));
+    }
+    try {
+      const freshPayload = await buildDefaultsPayload({
+        workspace,
+        sessionId,
+        explicitCollection: "",
+        defaultCollection: "",
+        defaultMode,
+        defaultUnder,
+        config,
+        backendHint,
+        uploadServiceUrl,
+      });
+      if (Object.hasOwn(freshPayload, "collection")) {
+        defaultsPayload.collection = freshPayload.collection;
+      }
+      if (freshPayload.collection) {
+        debugLog("[ctxce] Re-resolved collection after deletion: " + freshPayload.collection);
+      }
+    } catch (reResolveErr) {
+      debugLog("[ctxce] Failed to re-resolve collection after deletion: " + String(reResolveErr));
+    }
+    try {
+      if (indexerClient) {
+        await sendSessionDefaults(indexerClient, defaultsPayload, "indexer");
+      }
+      if (memoryClient) {
+        await sendSessionDefaults(memoryClient, defaultsPayload, "memory");
+      }
+      debugLog(`[ctxce] Re-sent session defaults after collection deletion detection (${reason})`);
+    } catch (sdErr) {
+      debugLog("[ctxce] Failed to re-send session defaults after deletion: " + String(sdErr));
+    }
+  }
+
   async function initializeRemoteClients(forceRecreate = false) {
     if (!forceRecreate && indexerClient) {
       return;
@@ -1523,10 +1759,20 @@ async function createBridgeServer(options) {
             }
           } catch (e) { debugLog("[ctxce] LSP not_available inject failed: " + String(e)); }
         }
+        // Detect explicit collection_deleted flag in a successful response
+        if (resultIndicatesCollectionDeleted(result)) {
+          await recoverDeletedCollection("result path");
+        }
+
         return maybeRemapToolResult(name, result, workspace);
       } catch (err) {
         lastError = err;
 
+        // Detect collection deletion from error signals
+        if (isCollectionDeletedSignal(err)) {
+          await recoverDeletedCollection("error path");
+        }
+
         if (isConnectionDeadError(err) && !connectionRetried) {
           debugLog(
             "[ctxce] tools/call: connection dead (server may have restarted); recreating clients and retrying: " +