@context-engine-bridge/context-engine-mcp-bridge 0.0.78 → 0.0.82

package/package.json

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

package/src/authCli.js

@@ -154,11 +154,19 @@ async function doLogin(args) {
   const sessionId = data.session_id || data.sessionId || null;
   const userId = data.user_id || data.userId || null;
   const expiresAt = data.expires_at || data.expiresAt || null;
+  const orgId = data.org_id || data.orgId || null;
+  const orgSlug = data.org_slug || data.orgSlug || null;
   if (!sessionId) {
     console.error("[ctxce] Auth login response missing session id.");
     process.exit(1);
   }
-  saveAuthEntry(url, { sessionId, userId, expiresAt });
+  saveAuthEntry(url, {
+    sessionId,
+    userId,
+    expiresAt,
+    org_id: orgId,
+    org_slug: orgSlug,
+  });
   console.error("[ctxce] Auth login successful for", url);
 }
 

package/src/authConfig.js

@@ -4,6 +4,7 @@ import path from "node:path";
 
 const CONFIG_DIR_NAME = ".ctxce";
 const CONFIG_BASENAME = "auth.json";
+const RESOLVED_COLLECTIONS_KEY = "resolved_collections_v1";
 
 function getConfigPath() {
   const home = os.homedir() || process.cwd();
@@ -36,6 +37,38 @@ function writeConfig(data) {
   }
 }
 
+function normalizeScopeValue(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function buildResolvedCollectionScopeKey({ orgId, orgSlug, logicalRepoId } = {}) {
+  const repo = normalizeScopeValue(logicalRepoId);
+  if (!repo) {
+    return "";
+  }
+  const normalizedOrgId = normalizeScopeValue(orgId);
+  const normalizedOrgSlug = normalizeScopeValue(orgSlug);
+  const org = normalizedOrgId || (normalizedOrgSlug ? `slug:${normalizedOrgSlug}` : "org:none");
+  return `${org}::${repo}`;
+}
+
+function getResolvedCollections(entry) {
+  const map = entry && typeof entry === "object" ? entry[RESOLVED_COLLECTIONS_KEY] : null;
+  return map && typeof map === "object" ? map : {};
+}
+
+function preserveInternalEntryState(existingEntry, nextEntry) {
+  const preserved = {};
+  const existingCollections = getResolvedCollections(existingEntry);
+  if (Object.keys(existingCollections).length > 0) {
+    preserved[RESOLVED_COLLECTIONS_KEY] = existingCollections;
+  }
+  return {
+    ...preserved,
+    ...nextEntry,
+  };
+}
+
 export function loadAuthEntry(backendUrl) {
   if (!backendUrl) {
     return null;
@@ -55,7 +88,8 @@ export function saveAuthEntry(backendUrl, entry) {
   }
   const all = readConfig();
   const key = String(backendUrl);
-  all[key] = entry;
+  const existingEntry = all[key];
+  all[key] = preserveInternalEntryState(existingEntry, entry);
   writeConfig(all);
 }
 
@@ -82,3 +116,39 @@ export function loadAnyAuthEntry() {
   }
   return null;
 }
+
+export function loadResolvedCollection(backendUrl, scope) {
+  if (!backendUrl) {
+    return null;
+  }
+  const scopeKey = buildResolvedCollectionScopeKey(scope);
+  if (!scopeKey) {
+    return null;
+  }
+  const entry = loadAuthEntry(backendUrl);
+  const resolved = getResolvedCollections(entry)[scopeKey];
+  return typeof resolved === "string" && resolved.trim() ? resolved.trim() : null;
+}
+
+export function saveResolvedCollection(backendUrl, scope, collection) {
+  if (!backendUrl) {
+    return;
+  }
+  const scopeKey = buildResolvedCollectionScopeKey(scope);
+  const nextCollection = typeof collection === "string" ? collection.trim() : "";
+  if (!scopeKey || !nextCollection) {
+    return;
+  }
+  const all = readConfig();
+  const key = String(backendUrl);
+  const existingEntry = all[key] && typeof all[key] === "object" ? all[key] : {};
+  const resolvedCollections = {
+    ...getResolvedCollections(existingEntry),
+    [scopeKey]: nextCollection,
+  };
+  all[key] = {
+    ...existingEntry,
+    [RESOLVED_COLLECTIONS_KEY]: resolvedCollections,
+  };
+  writeConfig(all);
+}

package/src/mcpServer.js

@@ -11,9 +11,17 @@ import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/
 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 { loadAnyAuthEntry, loadAuthEntry, readConfig, saveAuthEntry } from "./authConfig.js";
+import {
+  loadAnyAuthEntry,
+  loadAuthEntry,
+  loadResolvedCollection,
+  readConfig,
+  saveAuthEntry,
+  saveResolvedCollection,
+} from "./authConfig.js";
 import { maybeRemapToolArgs, maybeRemapToolResult } from "./resultPathMapping.js";
 import { startSyncDaemon } from "./syncDaemon.js";
+import { computeLogicalRepoIdentity } from "./uploader.js";
 import * as oauthHandler from "./oauthHandler.js";
 
 const LSP_CONN_CACHE_TTL = 5000;
@@ -593,6 +601,7 @@ async function fetchBridgeCollectionState({
   collection,
   sessionId,
   repoName,
+  logicalRepoId,
   bridgeStateToken,
   backendHint,
   uploadServiceUrl,
@@ -612,6 +621,9 @@ async function fetchBridgeCollectionState({
     if (repoName && repoName.trim()) {
       url.searchParams.set("repo_name", repoName.trim());
     }
+    if (logicalRepoId && logicalRepoId.trim()) {
+      url.searchParams.set("logical_repo_id", logicalRepoId.trim());
+    }
 
     const headers = {
       Accept: "application/json",
@@ -646,6 +658,131 @@ async function fetchBridgeCollectionState({
   }
 }
 
+export async function buildDefaultsPayload({
+  workspace,
+  sessionId,
+  explicitCollection,
+  defaultCollection,
+  defaultMode,
+  defaultUnder,
+  config,
+  backendHint,
+  uploadServiceUrl,
+  bridgeStateToken = BRIDGE_STATE_TOKEN,
+  authEntry = undefined,
+  fetchState = fetchBridgeCollectionState,
+  getLogicalRepoIdentity = computeLogicalRepoIdentity,
+  loadResolvedCollectionHint = loadResolvedCollection,
+  saveResolvedCollectionHint = saveResolvedCollection,
+  log = debugLog,
+} = {}) {
+  const defaultsPayload = { session: sessionId };
+  const pinnedCollection =
+    typeof explicitCollection === "string" ? explicitCollection.trim() : "";
+  const configuredCollection =
+    !pinnedCollection && typeof defaultCollection === "string"
+      ? defaultCollection.trim()
+      : "";
+
+  if (pinnedCollection) {
+    defaultsPayload.collection = pinnedCollection;
+  } else if (configuredCollection) {
+    defaultsPayload.collection = configuredCollection;
+  }
+
+  const resolvedAuthEntry = authEntry === undefined
+    ? (backendHint ? loadAuthEntry(backendHint) : null)
+    : authEntry;
+
+  if (resolvedAuthEntry && (resolvedAuthEntry.org_id || resolvedAuthEntry.org_slug)) {
+    if (resolvedAuthEntry.org_id) {
+      defaultsPayload.org_id = resolvedAuthEntry.org_id;
+    }
+    if (resolvedAuthEntry.org_slug) {
+      defaultsPayload.org_slug = resolvedAuthEntry.org_slug;
+    }
+  }
+
+  const repoName = detectRepoName(workspace, config);
+  let logicalRepoId = "";
+  try {
+    logicalRepoId = getLogicalRepoIdentity(workspace)?.id || "";
+  } catch {
+    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}`);
+    }
+  }
+
+  if (!pinnedCollection) {
+    try {
+      const state = await fetchState({
+        workspace,
+        collection: configuredCollection,
+        sessionId,
+        repoName,
+        logicalRepoId,
+        bridgeStateToken,
+        backendHint,
+        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}`);
+          }
+          if (backendHint && logicalRepoId) {
+            saveResolvedCollectionHint(backendHint, {
+              orgId: resolvedAuthEntry?.org_id,
+              orgSlug: resolvedAuthEntry?.org_slug,
+              logicalRepoId,
+            }, servingCollection);
+          }
+        } 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));
+    }
+  }
+
+  if (defaultMode) {
+    defaultsPayload.mode = defaultMode;
+  }
+  if (defaultUnder) {
+    defaultsPayload.under = defaultUnder;
+  }
+
+  return defaultsPayload;
+}
+
 function _validateWorkspacePath(raw) {
   if (typeof raw !== "string" || raw.length === 0) return null;
   const resolved = path.resolve(raw);
@@ -659,6 +796,42 @@ function _validateWorkspacePath(raw) {
   return resolved;
 }
 
+function _readExactWorkspaceCachedCollection(workspacePath) {
+  const resolvedWorkspace = _validateWorkspacePath(workspacePath);
+  if (!resolvedWorkspace) return null;
+
+  const wsDir = _computeWorkspaceDir(resolvedWorkspace);
+  const configPath = path.join(wsDir, "ctx_config.json");
+  const metaPath = path.join(wsDir, "meta.json");
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  if (fs.existsSync(metaPath)) {
+    try {
+      const meta = JSON.parse(fs.readFileSync(metaPath, "utf8"));
+      const metaWorkspace = _validateWorkspacePath(meta && meta.workspace_path);
+      if (!metaWorkspace || metaWorkspace !== resolvedWorkspace) {
+        return null;
+      }
+    } catch (_) {
+      return null;
+    }
+  }
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    const collection =
+      parsed && typeof parsed.default_collection === "string"
+        ? parsed.default_collection.trim()
+        : "";
+    return collection || null;
+  } catch (_) {
+    return null;
+  }
+}
+
 const MAX_WS_SCAN = 50;
 
 function _resolveWorkspace(providedWorkspace) {
@@ -877,55 +1050,17 @@ async function createBridgeServer(options) {
 
   // Best-effort: inform the indexer of default collection and session.
   // If this fails we still proceed, falling back to per-call injection.
-  const defaultsPayload = { session: sessionId };
-  if (defaultCollection) {
-    defaultsPayload.collection = defaultCollection;
-  }
-
-  // Include org context from auth entry if available (for org-scoped collection isolation)
-  try {
-    const authEntry = backendHint ? loadAuthEntry(backendHint) : null;
-    if (authEntry && authEntry.org_id) {
-      defaultsPayload.org_id = authEntry.org_id;
-      defaultsPayload.org_slug = authEntry.org_slug;
-    }
-  } catch {
-    // ignore auth entry lookup failures
-  }
-
-  const repoName = detectRepoName(workspace, config);
-
-  try {
-    const state = await fetchBridgeCollectionState({
-      workspace,
-      collection: defaultCollection,
-      sessionId,
-      repoName,
-      bridgeStateToken: BRIDGE_STATE_TOKEN,
-      backendHint,
-      uploadServiceUrl,
-    });
-    if (state) {
-      const serving = state.serving_collection || state.active_collection;
-      if (serving) {
-        defaultsPayload.collection = serving;
-        if (!defaultCollection || defaultCollection !== serving) {
-          debugLog(
-            `[ctxce] Using serving collection from /bridge/state: ${serving}`,
-          );
-        }
-      }
-    }
-  } catch (err) {
-    debugLog("[ctxce] bridge/state lookup failed: " + String(err));
-  }
-
-  if (defaultMode) {
-    defaultsPayload.mode = defaultMode;
-  }
-  if (defaultUnder) {
-    defaultsPayload.under = defaultUnder;
-  }
+  const defaultsPayload = await buildDefaultsPayload({
+    workspace,
+    sessionId,
+    explicitCollection,
+    defaultCollection,
+    defaultMode,
+    defaultUnder,
+    config,
+    backendHint,
+    uploadServiceUrl,
+  });
 
   async function initializeRemoteClients(forceRecreate = false) {
     if (!forceRecreate && indexerClient) {

package/src/oauthHandler.js

@@ -247,6 +247,8 @@ export function getLoginPage(redirectUri, clientId, state, codeChallenge, codeCh
 
       const data = await resp.json();
       const sessionId = data.session_id || data.sessionId;
+      const orgId = data.org_id || data.orgId || null;
+      const orgSlug = data.org_slug || data.orgSlug || null;
       if (!sessionId) {
         throw new Error('No session in response');
       }
@@ -258,6 +260,8 @@ export function getLoginPage(redirectUri, clientId, state, codeChallenge, codeCh
         body: JSON.stringify({
           session_id: sessionId,
           backend_url: backendUrl,
+          org_id: orgId,
+          org_slug: orgSlug,
           redirect_uri: params.redirect_uri,
           state: params.state,
           code_challenge: params.code_challenge,
@@ -443,7 +447,17 @@ export function handleOAuthStoreSession(req, res) {
     res.setHeader("Content-Type", "application/json");
     try {
       const data = JSON.parse(body);
-      const { session_id, backend_url, redirect_uri, state, code_challenge, code_challenge_method, client_id } = data;
+      const {
+        session_id,
+        backend_url,
+        org_id,
+        org_slug,
+        redirect_uri,
+        state,
+        code_challenge,
+        code_challenge_method,
+        client_id,
+      } = data;
 
       if (!session_id || !backend_url) {
         res.statusCode = 400;
@@ -503,6 +517,8 @@ export function handleOAuthStoreSession(req, res) {
         sessionId: session_id,
         userId: "oauth-user",
         expiresAt: null,
+        org_id: org_id || null,
+        org_slug: org_slug || null,
       });
 
       // Generate auth code

package/src/syncDaemon.js

@@ -26,7 +26,7 @@ const noop = () => {};
 
 // ---------------------------------------------------------------------------
 // Process-level singleton registry
-// keyed by path.resolve(workspace) -> { intervalId, cleanup }
+// keyed by path.resolve(workspace) -> { intervalId, cleanup, updateRuntimeState }
 // ---------------------------------------------------------------------------
 
 const _activeDaemons = new Map();
@@ -153,17 +153,24 @@ export function startSyncDaemon(options) {
     workspace,
     sessionId: initialSessionId,
     authEntry: initialAuthEntry,
-    uploadEndpoint,
+    uploadEndpoint: initialUploadEndpoint,
     intervalMs = DEFAULT_WATCH_INTERVAL_MS,
     log = noop,
   } = options;
 
   const resolvedWorkspace = path.resolve(workspace);
 
-  // Singleton guard: return existing daemon if already running.
+  // Singleton guard: return existing daemon if already running, but refresh
+  // any mutable runtime state supplied by the new caller.
   if (_activeDaemons.has(resolvedWorkspace)) {
+    const existingHandle = _activeDaemons.get(resolvedWorkspace);
+    existingHandle?.updateRuntimeState?.({
+      sessionId: initialSessionId,
+      authEntry: initialAuthEntry,
+      uploadEndpoint: initialUploadEndpoint,
+    });
     log(`[syncDaemon] Daemon already running for ${resolvedWorkspace}, reusing.`);
-    return _activeDaemons.get(resolvedWorkspace);
+    return existingHandle;
   }
 
   log(`[syncDaemon] Starting file watcher for ${resolvedWorkspace} (interval: ${intervalMs / 1000}s)`);
@@ -174,9 +181,28 @@ export function startSyncDaemon(options) {
   let pendingHistoryOnly = true;
   let sessionId = initialSessionId;
   let authEntry = initialAuthEntry;
+  let uploadEndpoint = initialUploadEndpoint;
   let lastKnownHead = "";
 
-  const authBackendUrl = deriveAuthBackendUrl(uploadEndpoint);
+  let authBackendUrl = deriveAuthBackendUrl(uploadEndpoint);
+
+  function updateRuntimeState(nextState = {}) {
+    if (typeof nextState.sessionId === "string" && nextState.sessionId) {
+      sessionId = nextState.sessionId;
+    }
+
+    if (nextState.authEntry && typeof nextState.authEntry === "object") {
+      authEntry = nextState.authEntry;
+      if (typeof nextState.authEntry.sessionId === "string" && nextState.authEntry.sessionId) {
+        sessionId = nextState.authEntry.sessionId;
+      }
+    }
+
+    if (typeof nextState.uploadEndpoint === "string" && nextState.uploadEndpoint) {
+      uploadEndpoint = nextState.uploadEndpoint;
+      authBackendUrl = deriveAuthBackendUrl(uploadEndpoint);
+    }
+  }
 
   // -------------------------------------------------------------------------
   // Session refresh
@@ -407,7 +433,7 @@ export function startSyncDaemon(options) {
   };
 
   // Register in singleton map BEFORE returning so concurrent callers see it.
-  const handle = { intervalId, cleanup };
+  const handle = { intervalId, cleanup, updateRuntimeState };
   _activeDaemons.set(resolvedWorkspace, handle);
 
   return handle;

package/src/uploader.js

@@ -37,6 +37,7 @@ const DEFAULT_IGNORES = [
 ];
 
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
+const ADMIN_SESSION_COOKIE_NAME = "ctxce_session";
 
 function sanitizeRepoName(repoName) {
   return String(repoName || "")
@@ -61,6 +62,116 @@ function getCollectionName(repoName) {
   return `${sanitized}-${hash}`;
 }
 
+function normalizeBackendUrl(raw) {
+  const value = String(raw || "").trim();
+  if (!value) return "";
+  try {
+    const parsed = new URL(value);
+    return `${parsed.protocol}//${parsed.host}`;
+  } catch {
+    return value.replace(/\/+$/, "");
+  }
+}
+
+function buildBridgeStateHeaders(sessionId) {
+  const headers = {
+    Accept: "application/json",
+  };
+  if (sessionId) {
+    headers.Authorization = `Bearer ${sessionId}`;
+    headers["X-Session-Id"] = sessionId;
+    headers.Cookie = `${ADMIN_SESSION_COOKIE_NAME}=${sessionId}`;
+  }
+  return headers;
+}
+
+async function fetchBridgeCollectionState({
+  workspacePath,
+  uploadEndpoint,
+  sessionId,
+  repoName,
+  logicalRepoId,
+  log = console.error,
+}) {
+  const backendUrl = normalizeBackendUrl(uploadEndpoint);
+  if (!backendUrl) {
+    return { kind: "skipped" };
+  }
+
+  try {
+    const url = new URL("/bridge/state", backendUrl);
+    if (workspacePath) {
+      url.searchParams.set("workspace", workspacePath);
+    }
+    if (repoName) {
+      url.searchParams.set("repo_name", repoName);
+    }
+    if (logicalRepoId) {
+      url.searchParams.set("logical_repo_id", logicalRepoId);
+    }
+
+    const resp = await fetch(url, {
+      method: "GET",
+      headers: buildBridgeStateHeaders(sessionId),
+    });
+    if (resp.status === 404) {
+      return { kind: "missing" };
+    }
+    if (resp.status === 401 || resp.status === 403) {
+      return { kind: "unavailable" };
+    }
+    if (!resp.ok) {
+      log(`[uploader] bridge/state lookup failed: HTTP ${resp.status}`);
+      return { kind: "unavailable" };
+    }
+
+    const data = await resp.json();
+    return {
+      kind: "ok",
+      state: data && typeof data === "object" ? data : null,
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log(`[uploader] bridge/state lookup failed: ${message}`);
+    return { kind: "unavailable" };
+  }
+}
+
+async function resolveRepoScopedCollection(workspacePath, uploadEndpoint, sessionId, options = {}) {
+  const { log = console.error } = options;
+  const repoName = extractRepoNameFromPath(workspacePath);
+  const logicalRepoIdentity = computeLogicalRepoIdentity(workspacePath);
+
+  const stateResult = await fetchBridgeCollectionState({
+    workspacePath,
+    uploadEndpoint,
+    sessionId,
+    repoName,
+    logicalRepoId: logicalRepoIdentity.id,
+    log,
+  });
+
+  if (stateResult.kind !== "ok") {
+    return null;
+  }
+
+  const state = stateResult.state || {};
+  const servingCollection = typeof state.serving_collection === "string"
+    ? state.serving_collection.trim()
+    : "";
+  const activeCollection = typeof state.active_collection === "string"
+    ? state.active_collection.trim()
+    : "";
+  const resolvedCollection = servingCollection || activeCollection;
+
+  if (resolvedCollection) {
+    log(`[uploader] Resuming repo-scoped collection ${resolvedCollection} for ${logicalRepoIdentity.id}`);
+    return resolvedCollection;
+  }
+
+  return null;
+}
+
 export function findGitRoot(startPath) {
   let current = path.resolve(startPath);
   while (current !== path.dirname(current)) {
@@ -451,7 +562,13 @@ function scanWorkspace(workspacePath, ig) {
 }
 
 export async function createBundle(workspacePath, options = {}) {
-  const { log = console.error, gitHistory = null, gitState = null, allowEmpty = false } = options;
+  const {
+    log = console.error,
+    gitHistory = null,
+    gitState = null,
+    allowEmpty = false,
+    collectionName = null,
+  } = options;
 
   const ig = loadGitignore(workspacePath);
   const files = scanWorkspace(workspacePath, ig);
@@ -508,7 +625,7 @@ export async function createBundle(workspacePath, options = {}) {
     version: "1.0",
     bundle_id: bundleId,
     workspace_path: workspacePath,
-    collection_name: getCollectionName(repoName),
+    collection_name: collectionName || getCollectionName(repoName),
     created_at: createdAt,
     sequence_number: null,
     parent_sequence: null,
@@ -583,6 +700,12 @@ export async function uploadGitHistoryOnly(workspacePath, uploadEndpoint, sessio
   const { log = console.error, orgId, orgSlug, quietNoop = false } = options;
 
   try {
+    const resolvedCollection = await resolveRepoScopedCollection(
+      workspacePath,
+      uploadEndpoint,
+      sessionId,
+      { log, orgId, orgSlug }
+    );
     const gitHistory = collectGitHistory(workspacePath);
     if (!gitHistory) {
       if (!quietNoop) {
@@ -597,6 +720,7 @@ export async function uploadGitHistoryOnly(workspacePath, uploadEndpoint, sessio
       gitHistory,
       gitState,
       allowEmpty: true,
+      collectionName: resolvedCollection,
     });
     if (!bundle) {
       return { success: false, error: "failed_to_create_history_bundle" };
@@ -740,7 +864,16 @@ async function _indexWorkspaceInner(workspacePath, uploadEndpoint, sessionId, op
     });
   }
 
-  const bundle = await createBundle(workspacePath, { log });
+  const resolvedCollection = await resolveRepoScopedCollection(
+    workspacePath,
+    uploadEndpoint,
+    sessionId,
+    { log, orgId, orgSlug }
+  );
+  const bundle = await createBundle(workspacePath, {
+    log,
+    collectionName: resolvedCollection,
+  });
   if (!bundle) {
     return await uploadGitHistoryOnly(workspacePath, uploadEndpoint, sessionId, {
       log,