@omercnet/paseo-context-mode 1.2.3 → 1.2.4-next.236.1

package/README.md

@@ -22,18 +22,18 @@ These previews were captured from an isolated Paseo test daemon with Context Mod
 
 - Bundles Context Mode as a runtime dependency; a separately installed global executable remains optional.
 - Resolves a configured absolute executable first, then the daemon's `PATH`, then the bundled runtime.
-- Shows Context Mode version, structured diagnostics, provider activation, storage roots, lifetime savings, activity, categories, and indexed sources.
+- Shows Context Mode version, structured diagnostics, provider activation, storage roots, lifetime savings, activity, categories, and indexed sources. Savings lists the built-in harness storage plus the storage of every provider configured in Paseo (including ones derived with `extends`), the latter under its Paseo provider id and the root its own `env` resolves to. `ctx_stats` and the Setup tab report the daemon's storage only.
 - Reads Context Mode 1.0.169 SQLite databases in query-only mode, honors active WAL state, isolates corrupt databases, and reports partial coverage instead of mutating schemas.
 - Injects the bundled stdio MCP server into new supported agents through Paseo's `agent.create` hook.
 - Injects provider identity and an existing provider-specific storage root on create, resume, refresh, and import.
 - Preserves existing MCP servers and explicit environment overrides.
 - Prefers detected native provider integrations to avoid duplicate `ctx_*` tools.
 - Reuses existing provider-specific databases. It does not merge session databases across providers because Context Mode intentionally isolates their session identities.
-- Provides provider- and project-scoped knowledge search, local-path indexing, URL fetch/index, indexed-source visibility, and an Insight link.
+- Provides provider- and project-scoped knowledge search, local-path indexing, URL fetch/index, indexed-source visibility, and an Insight link. Knowledge covers the built-in providers and every configured provider that resolves to a Context Mode store, using that provider's own `env`.
 - Requires an explicit provider, project path, scope review, and second confirmation before purge. Purge remains delegated to Context Mode's own MCP contract.
 - Returns structured install and provider-specific upgrade argv for review; Paseo never executes those commands automatically.
 - On Paseo 0.11, registers the `context-mode` screen with URL-persisted `section`, `agentId`, and `workspaceId` params. Composer pills open Knowledge using the selected host's agent provider and working directory. URL params never carry paths or queries.
-- Custom or named providers that do not exactly match a Knowledge RPC provider require explicit provider selection. Missing agents or mismatched workspaces also require explicit scope selection.
+- Providers that Context Mode does not support, and missing agents or mismatched workspaces, require explicit scope selection.
 - Adds a live Healthy/Failing sidebar footer row on Paseo 0.11, reusing the screen's health data. Paseo 0.9/0.10 retain the static sidebar, Savings surface, and unscoped composer shortcut.
 
 Context Mode currently couples sessions, stats, and indexed content under `CONTEXT_MODE_DIR`. Until upstream supports separate session and content roots, this plugin keeps storage provider-scoped instead of risking cross-provider session contamination.

package/client/context-mode-surface.tsx

@@ -13,7 +13,7 @@ import {
 } from "../shared";
 import { ActionsSection } from "./actions-section";
 import { AnalyticsDashboard } from "./analytics-dashboard";
-import { KnowledgeSection } from "./knowledge-section";
+import { BUILTIN_KNOWLEDGE_PROVIDERS, KnowledgeSection } from "./knowledge-section";
 import { ScopedKnowledgeSection } from "./scoped-knowledge-section";
 import { parseScreenParams, type SurfaceTab } from "./screen-scope";
 
@@ -76,6 +76,10 @@ export function ContextModeSurface({
     refetchInterval: refreshInterval,
     enabled: readySettings !== null,
   });
+  const auditedProviders = integration.data?.providers.map(({ provider }) => provider) ?? [];
+  const knowledgeProviders = auditedProviders.length
+    ? auditedProviders
+    : BUILTIN_KNOWLEDGE_PROVIDERS;
   const refresh = useMutation({
     mutationFn: async () => {
       const nextStatus = await loadStatus({ fresh: true });
@@ -280,16 +284,25 @@ export function ContextModeSurface({
         />
       </View>
       <View style={[styles.tabPanel, activeTab === "knowledge" ? null : styles.tabPanelHidden]}>
-        {activeTab !== "knowledge" ? null : screenParams.agentId || screenParams.workspaceId ? (
+        {activeTab !== "knowledge" ? null : integration.isLoading ? (
+          <Text style={{ color: theme.colors.foregroundMuted }}>Loading providers…</Text>
+        ) : screenParams.agentId || screenParams.workspaceId ? (
           <ScopedKnowledgeSection
             key={JSON.stringify([host.id, screenParams.agentId, screenParams.workspaceId])}
             params={screenParams}
             host={host}
             layout={layout}
             theme={theme}
+            providers={knowledgeProviders}
           />
         ) : (
-          <KnowledgeSection key={host.id} host={host} layout={layout} theme={theme} />
+          <KnowledgeSection
+            key={host.id}
+            host={host}
+            layout={layout}
+            theme={theme}
+            providers={knowledgeProviders}
+          />
         )}
       </View>
       <View style={[styles.tabPanel, activeTab === "setup" ? null : styles.tabPanelHidden]}>

package/client/knowledge-section.tsx

@@ -13,7 +13,6 @@ import {
   type ViewStyle,
 } from "react-native";
 import {
-  type ContextModeProvider,
   fetchAndIndexContextMode,
   indexContextModePath,
   type KnowledgeToolResult,
@@ -22,22 +21,29 @@ import {
 } from "../shared/knowledge";
 import type { KnowledgeScope } from "./screen-scope";
 
-const PROVIDERS = [
-  { value: "claude", label: "Claude" },
-  { value: "codex", label: "Codex" },
-  { value: "copilot", label: "Copilot" },
-  { value: "cursor", label: "Cursor" },
-  { value: "opencode", label: "OpenCode" },
-  { value: "pi", label: "Pi" },
-  { value: "omp", label: "OMP" },
-  { value: "omp-plugin", label: "OMP plugin" },
-] as const;
+const PROVIDER_LABELS: Readonly<Record<string, string>> = {
+  claude: "Claude",
+  codex: "Codex",
+  copilot: "Copilot",
+  cursor: "Cursor",
+  opencode: "OpenCode",
+  pi: "Pi",
+  omp: "OMP",
+  "omp-plugin": "OMP plugin",
+};
+
+/** Used until the integration audit reports the configured providers. */
+export const BUILTIN_KNOWLEDGE_PROVIDERS = Object.keys(PROVIDER_LABELS);
+
+const providerLabel = (id: string) => PROVIDER_LABELS[id] ?? id;
 
 const INSIGHT_URL = "https://context-mode.com/insight";
-type Provider = ContextModeProvider;
+type Provider = string;
 type PurgeScope = "project" | "session";
 export type KnowledgeSectionProps = Pick<PluginSurfaceProps, "theme" | "layout" | "host"> & {
   initialScope?: KnowledgeScope;
+  /** Paseo provider ids with a Context Mode store: the built-ins plus every configured provider. */
+  providers: readonly string[];
 };
 
 interface KnowledgeStyles {
@@ -238,7 +244,13 @@ function ResultPanel({
   );
 }
 
-export function KnowledgeSection({ theme, layout, host, initialScope }: KnowledgeSectionProps) {
+export function KnowledgeSection({
+  theme,
+  layout,
+  host,
+  initialScope,
+  providers,
+}: KnowledgeSectionProps) {
   const styles = useMemo(() => createStyles(theme, layout.compact), [layout.compact, theme]);
   const searchKnowledge = useRpc(searchContextModeKnowledge);
   const indexPath = useRpc(indexContextModePath);
@@ -250,8 +262,15 @@ export function KnowledgeSection({ theme, layout, host, initialScope }: Knowledg
       queryKey: ["context-mode", host.id, "analytics-dashboard"],
     });
 
+  const scopedProvider = initialScope?.provider ?? null;
+  const scopedProviderKnown = scopedProvider !== null && providers.includes(scopedProvider);
+  const note =
+    initialScope?.note ??
+    (scopedProvider && !scopedProviderKnown
+      ? `Provider ${scopedProvider} has no Context Mode store on this host. Select one explicitly.`
+      : undefined);
   const [provider, setProvider] = useState<Provider | null>(
-    initialScope ? initialScope.provider : "claude",
+    initialScope ? (scopedProviderKnown ? scopedProvider : null) : "claude",
   );
   const [projectPath, setProjectPath] = useState(initialScope?.projectPath ?? "");
   const [query, setQuery] = useState("");
@@ -367,18 +386,18 @@ export function KnowledgeSection({ theme, layout, host, initialScope }: Knowledg
 
       <View style={styles.card}>
         <Text style={styles.fieldLabel}>Provider store</Text>
-        {initialScope?.note ? <Text style={styles.scopeNote}>{initialScope.note}</Text> : null}
+        {note ? <Text style={styles.scopeNote}>{note}</Text> : null}
         <View accessibilityRole="radiogroup" style={styles.choiceRow}>
-          {PROVIDERS.map((option) => {
-            const selected = provider === option.value;
+          {providers.map((id) => {
+            const selected = provider === id;
             return (
               <Pressable
-                key={option.value}
-                accessibilityLabel={`${option.label} provider store`}
+                key={id}
+                accessibilityLabel={`${providerLabel(id)} provider store`}
                 disabled={busy}
                 accessibilityRole="radio"
                 accessibilityState={{ checked: selected, disabled: busy }}
-                onPress={() => changeProvider(option.value)}
+                onPress={() => changeProvider(id)}
                 style={[
                   styles.choice,
                   selected ? styles.choiceSelected : null,
@@ -386,7 +405,7 @@ export function KnowledgeSection({ theme, layout, host, initialScope }: Knowledg
                 ]}
               >
                 <Text style={[styles.choiceText, selected ? styles.choiceTextSelected : null]}>
-                  {option.label}
+                  {providerLabel(id)}
                 </Text>
               </Pressable>
             );
@@ -406,7 +425,7 @@ export function KnowledgeSection({ theme, layout, host, initialScope }: Knowledg
         />
         <Text accessibilityLiveRegion="polite" style={styles.scopeNote}>
           {provider && projectPath.trim()
-            ? `Current destination: ${PROVIDERS.find((item) => item.value === provider)?.label} storage for ${projectPath.trim()}.`
+            ? `Current destination: ${providerLabel(provider)} storage for ${projectPath.trim()}.`
             : "Select a provider and absolute project path. No storage destination is selected by default."}
         </Text>
       </View>

package/client/scoped-knowledge-section.tsx

@@ -7,7 +7,7 @@ import { resolveKnowledgeScope, type ScreenParams } from "./screen-scope";
 export function ScopedKnowledgeSection({
   params,
   ...props
-}: PluginSurfaceProps & { params: ScreenParams }) {
+}: PluginSurfaceProps & { params: ScreenParams; providers: readonly string[] }) {
   const paseo = usePaseo();
   const scope = useQuery({
     queryKey: [
@@ -40,7 +40,11 @@ export function ScopedKnowledgeSection({
   // Remount only when the resolved destination changes so stale form state never survives it.
   return (
     <KnowledgeSection
-      key={JSON.stringify([scope.data.provider, scope.data.projectPath])}
+      key={JSON.stringify([
+        scope.data.provider,
+        scope.data.projectPath,
+        props.providers.includes(scope.data.provider ?? ""),
+      ])}
       {...props}
       initialScope={scope.data}
     />

package/client/screen-scope.ts

@@ -1,11 +1,10 @@
 import type { PluginClientContext } from "@getpaseo/plugin/client";
-import { type ContextModeProvider, ContextModeProviderSchema } from "../shared/knowledge";
 
 type PaseoApi = PluginClientContext["paseo"];
 
 export type SurfaceTab = "savings" | "knowledge" | "setup";
 export type KnowledgeScope = {
-  provider: ContextModeProvider | null;
+  provider: string | null;
   projectPath: string;
   note?: string;
 };
@@ -21,11 +20,6 @@ export function parseScreenParams(params: Record<string, string>): ScreenParams
   };
 }
 
-export function knowledgeProvider(provider: string): ContextModeProvider | null {
-  const parsed = ContextModeProviderSchema.safeParse(provider);
-  return parsed.success ? parsed.data : null;
-}
-
 export async function resolveKnowledgeScope(
   paseo: PaseoApi,
   params: ScreenParams,
@@ -39,16 +33,7 @@ export async function resolveKnowledgeScope(
         "Agent no longer belongs to this workspace. Select a provider and project explicitly.",
       );
     }
-    const provider = knowledgeProvider(result.agent.provider);
-    return {
-      provider,
-      projectPath: result.agent.cwd,
-      ...(!provider
-        ? {
-            note: `Provider ${result.agent.provider} cannot be mapped to a knowledge store. Select one explicitly.`,
-          }
-        : {}),
-    };
+    return { provider: result.agent.provider, projectPath: result.agent.cwd };
   }
   const workspace = params.workspaceId
     ? await paseo.workspaces.ref(params.workspaceId).refresh()

package/index.server.ts

@@ -3,7 +3,11 @@ import { createContextModeActionHandlers } from "./server/actions";
 import { createContextModeAnalyticsHandler } from "./server/analytics";
 import { resolveContextModeBinary } from "./server/binary";
 import { createContextModeHandlers } from "./server/handlers";
-import { injectContextModeEnvironment, injectContextModeOnCreate } from "./server/integration";
+import {
+  injectContextModeEnvironment,
+  injectContextModeOnCreate,
+  readProviderOverrides,
+} from "./server/integration";
 import { createContextModeKnowledgeHandlers } from "./server/knowledge";
 import {
   contextModeSettings,
@@ -38,17 +42,19 @@ export default function contribute(server: PluginServerContext) {
   server.handle(getContextModeDoctorReport, actionHandlers.doctor);
   server.handle(getContextModeInstallAction, actionHandlers.install);
   server.handle(getContextModeUpgradeAction, actionHandlers.upgrade);
-  server.before("agent.create", async ({ request }) => {
+  server.before("agent.create", async ({ request }, { paseo }) => {
     const current = await settings.read();
     if (current.status !== "ready") return request;
     const binary = await resolveContextModeBinary(current.values);
     if (binary.state !== "found") return request;
-    return injectContextModeOnCreate(request, current.values, binary.launch);
+    const providers = await readProviderOverrides(paseo);
+    return injectContextModeOnCreate(request, current.values, binary.launch, { providers });
   });
-  server.before("agent.session_open", async ({ request }) => {
+  server.before("agent.session_open", async ({ request }, { paseo }) => {
     const current = await settings.read();
     if (current.status !== "ready") return request;
-    return injectContextModeEnvironment(request, current.values);
+    const providers = await readProviderOverrides(paseo);
+    return injectContextModeEnvironment(request, current.values, { providers });
   });
   return () => {};
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@omercnet/paseo-context-mode",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@omercnet/paseo-context-mode",
-      "version": "1.2.3",
+      "version": "1.2.4",
       "dependencies": {
         "context-mode": "1.0.169"
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omercnet/paseo-context-mode",
-  "version": "1.2.3",
+  "version": "1.2.4-next.236.1",
   "type": "module",
   "description": "Provider-aware Context Mode health, savings, and MCP activation for Paseo.",
   "license": "MIT",

package/server/analytics.ts

@@ -16,6 +16,7 @@ import {
   readContextModeDatabase,
   type SessionDatabaseSnapshot,
 } from "./context-mode-db";
+import { type ProviderConfigSource, readProviderOverrides } from "./integration";
 import {
   discoverContextModeStorageRoots,
   listRegularContextModeDatabases,
@@ -257,7 +258,11 @@ export async function collectContextModeAnalytics(
   const listDatabases = dependencies.listDatabases ?? listRegularContextModeDatabases;
   const readDatabase = dependencies.readDatabase ?? readContextModeDatabase;
   const warningCollector = new WarningCollector();
-  const discovery = await discoverStorage({ home: dependencies.home, env: dependencies.env });
+  const discovery = await discoverStorage({
+    home: dependencies.home,
+    env: dependencies.env,
+    providers: dependencies.providers,
+  });
   for (const warning of discovery.warnings) warningCollector.add(warning);
 
   const total = createAggregate();
@@ -419,6 +424,13 @@ export async function collectContextModeAnalytics(
 
 export function createContextModeAnalyticsHandler(
   dependencies: ContextModeAnalyticsDependencies = {},
-): (_input: Record<string, never>) => Promise<AnalyticsDashboard> {
-  return async () => collectContextModeAnalytics(dependencies);
+): (
+  _input: Record<string, never>,
+  context?: { paseo?: ProviderConfigSource },
+) => Promise<AnalyticsDashboard> {
+  return async (_input, context) =>
+    collectContextModeAnalytics({
+      ...dependencies,
+      providers: dependencies.providers ?? (await readProviderOverrides(context?.paseo)),
+    });
 }

package/server/handlers.ts

@@ -8,7 +8,12 @@ import type {
   IntegrationAudit,
 } from "../shared";
 import { type BinaryResolution, type LaunchDescriptor, resolveContextModeBinary } from "./binary";
-import { createIntegrationAudit } from "./integration";
+import {
+  createIntegrationAudit,
+  type IntegrationDependencies,
+  type ProviderConfigSource,
+  readProviderOverrides,
+} from "./integration";
 import {
   callContextModeTool,
   inspectContextMode,
@@ -28,6 +33,7 @@ export interface ContextModeHandlerDependencies {
   createAudit?: (
     settings: ContextModeSettings,
     runtime: { path: string; version: string | null },
+    dependencies?: IntegrationDependencies,
   ) => Promise<IntegrationAudit>;
 }
 
@@ -35,7 +41,10 @@ export interface ContextModeHandlers {
   status(input: ContextModeRefreshInput): Promise<BinaryStatus>;
   doctor(input: ContextModeRefreshInput): Promise<CommandReport>;
   stats(input: ContextModeRefreshInput): Promise<CommandReport>;
-  audit(input: ContextModeRefreshInput): Promise<IntegrationAudit>;
+  audit(
+    input: ContextModeRefreshInput,
+    context?: { paseo?: ProviderConfigSource },
+  ): Promise<IntegrationAudit>;
 }
 
 interface CacheEntry<T> {
@@ -170,7 +179,10 @@ export function createContextModeHandlers(
     });
   }
 
-  async function audit(_input: ContextModeRefreshInput): Promise<IntegrationAudit> {
+  async function audit(
+    _input: ContextModeRefreshInput,
+    context?: { paseo?: ProviderConfigSource },
+  ): Promise<IntegrationAudit> {
     const resolved = await settingsAndBinary();
     if (resolved.state === "unavailable") {
       return {
@@ -185,10 +197,11 @@ export function createContextModeHandlers(
       version: null,
       tools: [],
     }));
-    return buildAudit(resolved.settings, {
-      path: resolved.binary.path,
-      version: inspection.version,
-    });
+    return buildAudit(
+      resolved.settings,
+      { path: resolved.binary.path, version: inspection.version },
+      { providers: await readProviderOverrides(context?.paseo) },
+    );
   }
 
   return {

package/server/integration.ts

@@ -54,6 +54,52 @@ export interface IntegrationDependencies {
   fileContains?: (path: string, text: string) => Promise<boolean>;
   now?: () => Date;
   env?: NodeJS.ProcessEnv;
+  providers?: ProviderOverrides;
+}
+
+export type ProviderOverrides = Readonly<
+  Record<string, { extends?: string; env?: Readonly<Record<string, string>> }>
+>;
+
+/** Structural slice of the hook/RPC `paseo` API; avoids a client-package import. */
+export interface ProviderConfigSource {
+  config: { get(): Promise<{ config: { providers?: unknown } }> };
+}
+
+/**
+ * Reads `agents.providers` from the daemon. Paseo applies a provider's own `env` and `extends`
+ * after the `agent.create` hook runs, so the hooks must look them up to find the right storage.
+ * Failures degrade to "no overrides" (canonical provider behavior).
+ */
+export async function readProviderOverrides(
+  paseo: ProviderConfigSource | undefined,
+): Promise<ProviderOverrides> {
+  try {
+    const { config } = (await paseo?.config.get()) ?? {};
+    const entries: Array<[string, { extends?: string; env?: Record<string, string> }]> = [];
+    for (const [id, value] of Object.entries(config?.providers ?? {})) {
+      if (typeof value !== "object" || value === null) continue;
+      const { extends: parent, env } = value as { extends?: unknown; env?: unknown };
+      entries.push([
+        id,
+        {
+          ...(typeof parent === "string" ? { extends: parent } : {}),
+          ...(typeof env === "object" && env !== null && !Array.isArray(env)
+            ? {
+                env: Object.fromEntries(
+                  Object.entries(env).filter(
+                    (entry): entry is [string, string] => typeof entry[1] === "string",
+                  ),
+                ),
+              }
+            : {}),
+        },
+      ]);
+    }
+    return Object.fromEntries(entries);
+  } catch {
+    return {};
+  }
 }
 
 export interface ContextModeStorageOptions {
@@ -241,7 +287,23 @@ const PROVIDER_POLICIES: Readonly<Record<Exclude<AuditedProvider, "omp-plugin">,
 
 function providerPolicy(provider: string): ProviderPolicy | null {
   if (provider === "omp-plugin" || provider.startsWith("omp-plugin-")) return OMP_POLICY;
-  return PROVIDER_POLICIES[provider as keyof typeof PROVIDER_POLICIES] ?? null;
+  return Object.hasOwn(PROVIDER_POLICIES, provider)
+    ? PROVIDER_POLICIES[provider as keyof typeof PROVIDER_POLICIES]
+    : null;
+}
+
+/**
+ * Mirrors Paseo's single-level `extends`: a derived provider uses its parent's policy, and its
+ * effective env is the parent's override env overlaid with its own.
+ */
+export function resolveProvider(
+  id: string,
+  providers: ProviderOverrides = {},
+): { base: string; policy: ProviderPolicy | null; env: Record<string, string> } {
+  const own = Object.hasOwn(providers, id) ? providers[id] : undefined;
+  const base = own?.extends ?? id;
+  const parent = base !== id && Object.hasOwn(providers, base) ? providers[base] : undefined;
+  return { base, policy: providerPolicy(base), env: { ...parent?.env, ...own?.env } };
 }
 
 async function defaultPathExists(path: string): Promise<boolean> {
@@ -322,24 +384,40 @@ export async function createIntegrationAudit(
   const pathExists = dependencies.pathExists ?? defaultPathExists;
   const fileContains = dependencies.fileContains ?? defaultFileContains;
   const hostEnvironment = dependencies.env ?? process.env;
-  const context = providerContext(home, undefined, hostEnvironment);
-  const nativeByPolicy = new Map<ProviderPolicy, Promise<boolean>>();
-  const detectNative = (policy: ProviderPolicy) => {
-    const existing = nativeByPolicy.get(policy);
+  const nativeByPolicy = new Map<string, Promise<boolean>>();
+  const detectNative = (
+    policy: ProviderPolicy,
+    env: Readonly<Record<string, string | undefined>>,
+    key: string,
+  ) => {
+    const cacheKey = `${policy.platform}\0${key}`;
+    const existing = nativeByPolicy.get(cacheKey);
     if (existing) return existing;
-    const detected = nativeIntegrationDetected(policy, context, pathExists, fileContains);
-    nativeByPolicy.set(policy, detected);
+    const detected = nativeIntegrationDetected(
+      policy,
+      providerContext(home, undefined, env),
+      pathExists,
+      fileContains,
+    );
+    nativeByPolicy.set(cacheKey, detected);
     return detected;
   };
+  const configured = dependencies.providers ?? {};
+  const derived = Object.keys(configured).filter(
+    (id) => !(AUDITED_PROVIDERS as readonly string[]).includes(id),
+  );
   const providers: ProviderIntegration[] = [];
-  for (const provider of AUDITED_PROVIDERS) {
-    const policy = providerPolicy(provider);
+  for (const provider of [...AUDITED_PROVIDERS, ...derived]) {
+    const { base, policy, env: providerEnv } = resolveProvider(provider, configured);
     if (!policy) continue;
-    const storageRoot = contextModeStorageRootFor(provider, { home, env: hostEnvironment });
+    const env = { ...hostEnvironment, ...providerEnv };
+    const storageRoot = contextModeStorageRootFor(base, { home, env });
     if (!storageRoot) continue;
     const reusesExistingStorage = await pathExists(storageRoot);
     const native =
-      settings.autoInject && settings.preferNativeIntegrations && (await detectNative(policy));
+      settings.autoInject &&
+      settings.preferNativeIntegrations &&
+      (await detectNative(policy, env, JSON.stringify(providerEnv)));
     const activation = !settings.autoInject ? "disabled" : native ? "native" : "mcp";
     providers.push({
       provider,
@@ -377,34 +455,35 @@ export async function injectContextModeOnCreate<T extends CreateRequest>(
   ) {
     return request;
   }
-  const policy = providerPolicy(request.config.provider);
+  const {
+    base,
+    policy,
+    env: providerEnv,
+  } = resolveProvider(request.config.provider, dependencies.providers);
   if (!policy) return request;
   const home = dependencies.home ?? homedir();
   const hostEnvironment = dependencies.env ?? process.env;
   const pathExists = dependencies.pathExists ?? defaultPathExists;
   const fileContains = dependencies.fileContains ?? defaultFileContains;
-  const context = providerContext(home, request.config.cwd, {
-    ...hostEnvironment,
-    ...request.env,
-  });
+  const env = { ...hostEnvironment, ...providerEnv, ...request.env };
   if (
     settings.preferNativeIntegrations &&
-    (await nativeIntegrationDetected(policy, context, pathExists, fileContains))
+    (await nativeIntegrationDetected(
+      policy,
+      providerContext(home, request.config.cwd, env),
+      pathExists,
+      fileContains,
+    ))
   ) {
     return request;
   }
-  const storageRoot = contextModeStorageRootFor(request.config.provider, {
-    home,
-    cwd: request.config.cwd,
-    env: { ...hostEnvironment, ...request.env },
-  });
+  const storageRoot = contextModeStorageRootFor(base, { home, cwd: request.config.cwd, env });
   if (!storageRoot) return request;
-  const env = serverEnvironment(policy, storageRoot, request.env);
   const server: McpServer = {
     type: "stdio",
     command: launch.program,
     args: launch.args,
-    env,
+    env: serverEnvironment(policy, storageRoot, request.env),
   };
   return {
     ...request,
@@ -421,14 +500,18 @@ export async function injectContextModeEnvironment<T extends SessionOpenRequest>
   dependencies: IntegrationDependencies = {},
 ): Promise<T> {
   if (!settings.autoInject) return request;
-  const policy = providerPolicy(request.provider);
+  const {
+    base,
+    policy,
+    env: providerEnv,
+  } = resolveProvider(request.provider, dependencies.providers);
   if (!policy) return request;
   const home = dependencies.home ?? homedir();
   const hostEnvironment = dependencies.env ?? process.env;
-  const storageRoot = contextModeStorageRootFor(request.provider, {
+  const storageRoot = contextModeStorageRootFor(base, {
     home,
     cwd: request.cwd,
-    env: { ...hostEnvironment, ...request.env },
+    env: { ...hostEnvironment, ...providerEnv, ...request.env },
   });
   if (!storageRoot) return request;
   return {

package/server/knowledge.ts

@@ -12,7 +12,13 @@ import type {
 } from "../shared/knowledge";
 import type { ContextModeSettings, contextModeSettings } from "../shared/settings";
 import { type BinaryResolution, type LaunchDescriptor, resolveContextModeBinary } from "./binary";
-import { contextModeStorageRootFor } from "./integration";
+import {
+  contextModeStorageRootFor,
+  type ProviderConfigSource,
+  type ProviderOverrides,
+  readProviderOverrides,
+  resolveProvider,
+} from "./integration";
 import {
   type ContextModeToolName,
   callContextModeTool,
@@ -35,11 +41,16 @@ export interface KnowledgeHandlerDependencies {
   callTool?: KnowledgeToolCaller;
 }
 
+type KnowledgeContext = { paseo?: ProviderConfigSource };
+
 export interface ContextModeKnowledgeHandlers {
-  search(input: SearchKnowledgeInput): Promise<KnowledgeToolResult>;
-  indexPath(input: IndexPathInput): Promise<KnowledgeToolResult>;
-  fetchAndIndex(input: FetchAndIndexInput): Promise<KnowledgeToolResult>;
-  purge(input: PurgeKnowledgeInput): Promise<KnowledgeToolResult>;
+  search(input: SearchKnowledgeInput, context?: KnowledgeContext): Promise<KnowledgeToolResult>;
+  indexPath(input: IndexPathInput, context?: KnowledgeContext): Promise<KnowledgeToolResult>;
+  fetchAndIndex(
+    input: FetchAndIndexInput,
+    context?: KnowledgeContext,
+  ): Promise<KnowledgeToolResult>;
+  purge(input: PurgeKnowledgeInput, context?: KnowledgeContext): Promise<KnowledgeToolResult>;
 }
 
 const PROVIDER_PLATFORMS: Readonly<Record<ContextModeProvider, ContextModePlatform>> = {
@@ -57,17 +68,21 @@ export function contextModePlatformFor(provider: ContextModeProvider): ContextMo
   return PROVIDER_PLATFORMS[provider];
 }
 
+/**
+ * `provider` is a Paseo provider id: a built-in, or a configured one whose own `extends` and env
+ * decide the storage root (`providers` is `agents.providers`).
+ */
 export function contextModeEnvironmentFor(
-  provider: ContextModeProvider,
+  provider: string,
   home = homedir(),
   env: NodeJS.ProcessEnv = process.env,
+  providers: ProviderOverrides = {},
 ): NodeJS.ProcessEnv {
-  const storageRoot = contextModeStorageRootFor(provider, { home, env });
-  if (!storageRoot) throw new Error(`Context Mode does not support provider ${provider}.`);
-  return {
-    CONTEXT_MODE_PLATFORM: contextModePlatformFor(provider),
-    CONTEXT_MODE_DIR: storageRoot,
-  };
+  const { base, policy, env: providerEnv } = resolveProvider(provider, providers);
+  const storageRoot = contextModeStorageRootFor(base, { home, env: { ...env, ...providerEnv } });
+  if (!policy || !storageRoot)
+    throw new Error(`Context Mode does not support provider ${provider}.`);
+  return { CONTEXT_MODE_PLATFORM: policy.platform, CONTEXT_MODE_DIR: storageRoot };
 }
 
 function definedArguments(values: Record<string, unknown>): McpToolArguments {
@@ -95,42 +110,51 @@ export function createContextModeKnowledgeHandlers(
   }
 
   async function run(
-    provider: ContextModeProvider,
+    provider: string,
     projectPath: string,
     name: ContextModeToolName,
     arguments_: McpToolArguments,
+    context: KnowledgeContext | undefined,
     environmentOverrides: NodeJS.ProcessEnv = {},
   ): Promise<KnowledgeToolResult> {
     const launch = await launchDescriptor();
+    const providers = await readProviderOverrides(context?.paseo);
     const output = await callTool(launch, name, arguments_, {
-      env: { ...contextModeEnvironmentFor(provider), ...environmentOverrides },
+      env: {
+        ...contextModeEnvironmentFor(provider, homedir(), process.env, providers),
+        ...environmentOverrides,
+      },
       cwd: projectPath,
     });
     return { provider, output, completedAt: now().toISOString() };
   }
 
   return {
-    search({ provider, projectPath, queries, limit, source, contentType, sort }) {
+    search({ provider, projectPath, queries, limit, source, contentType, sort }, context) {
       return run(
         provider,
         projectPath,
         "ctx_search",
         definedArguments({ queries, limit, source, contentType, sort }),
+        context,
       );
     },
-    indexPath({
-      provider,
-      projectPath,
-      path,
-      source,
-      include,
-      exclude,
-      maxDepth,
-      maxFiles,
-      extensions,
-      respectGitignore,
-      followSymlinks,
-    }) {
+    indexPath(
+      {
+        provider,
+        projectPath,
+        path,
+        source,
+        include,
+        exclude,
+        maxDepth,
+        maxFiles,
+        extensions,
+        respectGitignore,
+        followSymlinks,
+      },
+      context,
+    ) {
       if (!isAbsolute(path)) {
         throw new Error("Knowledge indexing requires an absolute path on this host.");
       }
@@ -149,18 +173,20 @@ export function createContextModeKnowledgeHandlers(
           respectGitignore,
           followSymlinks,
         }),
+        context,
       );
     },
-    fetchAndIndex({ provider, projectPath, url, source, force, ttl }) {
+    fetchAndIndex({ provider, projectPath, url, source, force, ttl }, context) {
       return run(
         provider,
         projectPath,
         "ctx_fetch_and_index",
         definedArguments({ url, source, force, ttl }),
+        context,
         { CTX_FETCH_STRICT: "1" },
       );
     },
-    async purge(input) {
+    async purge(input, context) {
       const raw = input as PurgeKnowledgeInput & { sessionId?: string };
       if (raw.confirm !== true) {
         throw new Error("Purge requires exact confirmation with confirm: true.");
@@ -169,19 +195,24 @@ export function createContextModeKnowledgeHandlers(
         if (raw.sessionId !== undefined) {
           throw new Error("Purge requires exactly one scope.");
         }
-        return await run(raw.provider, raw.projectPath, "ctx_purge", {
-          confirm: true,
-          scope: "project",
-        });
+        return await run(
+          raw.provider,
+          raw.projectPath,
+          "ctx_purge",
+          { confirm: true, scope: "project" },
+          context,
+        );
       }
       if (raw.scope !== "session" || !raw.sessionId) {
         throw new Error("Session purge requires exactly one non-empty sessionId scope.");
       }
-      return await run(raw.provider, raw.projectPath, "ctx_purge", {
-        confirm: true,
-        scope: "session",
-        sessionId: raw.sessionId,
-      });
+      return await run(
+        raw.provider,
+        raw.projectPath,
+        "ctx_purge",
+        { confirm: true, scope: "session", sessionId: raw.sessionId },
+        context,
+      );
     },
   };
 }

package/server/storage-discovery.ts

@@ -3,6 +3,7 @@ import { lstat, readdir, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, isAbsolute, join, resolve } from "node:path";
 import type { AnalyticsWarning } from "../shared/analytics";
+import { contextModeStorageRootFor, type ProviderOverrides, resolveProvider } from "./integration";
 
 const MAX_DATABASES_PER_DIRECTORY = 512;
 const MAX_LOCAL_DISCOVERY_WARNINGS = 10;
@@ -23,6 +24,8 @@ export interface StorageDiscoveryOptions {
   home?: string;
   env?: NodeJS.ProcessEnv;
   platform?: NodeJS.Platform;
+  /** Paseo `agents.providers`; each one contributes the storage its own env resolves to. */
+  providers?: ProviderOverrides;
 }
 
 interface ProviderLocation {
@@ -54,6 +57,7 @@ function providerLocations(
   env: NodeJS.ProcessEnv,
   warnings: AnalyticsWarning[],
   platform: NodeJS.Platform,
+  providers: ProviderOverrides,
 ): ProviderLocation[] {
   const configuredRoot = configuredDirectory(
     env.CONTEXT_MODE_DIR,
@@ -82,6 +86,14 @@ function providerLocations(
       : (configuredDirectory(env.XDG_CONFIG_HOME, home, "XDG_CONFIG_HOME", warnings) ??
         join(home, ".config"));
 
+  const configured = Object.keys(providers).flatMap((id) => {
+    const { base, policy, env: providerEnv } = resolveProvider(id, providers);
+    const root = policy
+      ? contextModeStorageRootFor(base, { home, env: { ...env, ...providerEnv } })
+      : null;
+    return root ? [{ provider: id, root }] : [];
+  });
+
   return [
     ...(configuredRoot ? [{ provider: "custom", root: configuredRoot }] : []),
     ...(configuredDataRoot
@@ -106,6 +118,7 @@ function providerLocations(
       provider: "jetbrains-copilot",
       root: join(home, ".config", "JetBrains", "context-mode"),
     },
+    ...configured,
   ];
 }
 
@@ -132,6 +145,7 @@ export async function discoverContextModeStorageRoots(
     env,
     warnings,
     options.platform ?? process.platform,
+    options.providers ?? {},
   )) {
     try {
       const info = await lstat(location.root);

package/shared/knowledge.ts

@@ -27,6 +27,9 @@ export const ContextModePlatformSchema = z.enum([
   "omp",
 ]);
 
+/** A Paseo provider id: a built-in or one configured in `agents.providers`. */
+export const KnowledgeProviderSchema = z.string().trim().min(1).max(128);
+
 const boundedLabel = z.string().trim().min(1).max(MAX_LABEL_LENGTH);
 const boundedPattern = z.string().trim().min(1).max(256);
 const absoluteLocalPath = z
@@ -43,7 +46,7 @@ const absoluteLocalPath = z
     { message: "path must be an absolute local path" },
   );
 const providerScope = z
-  .object({ provider: ContextModeProviderSchema, projectPath: absoluteLocalPath })
+  .object({ provider: KnowledgeProviderSchema, projectPath: absoluteLocalPath })
   .strict();
 const httpUrl = z
   .string()
@@ -55,7 +58,7 @@ const httpUrl = z
 
 export const KnowledgeToolResultSchema = z
   .object({
-    provider: ContextModeProviderSchema,
+    provider: KnowledgeProviderSchema,
     output: z.string().max(MAX_OUTPUT_LENGTH),
     completedAt: z.string().datetime(),
   })
@@ -96,7 +99,7 @@ export const FetchAndIndexInputSchema = providerScope
 
 const projectPurge = z
   .object({
-    provider: ContextModeProviderSchema,
+    provider: KnowledgeProviderSchema,
     projectPath: absoluteLocalPath,
     confirm: z.literal(true),
     scope: z.literal("project"),
@@ -104,7 +107,7 @@ const projectPurge = z
   .strict();
 const sessionPurge = z
   .object({
-    provider: ContextModeProviderSchema,
+    provider: KnowledgeProviderSchema,
     projectPath: absoluteLocalPath,
     confirm: z.literal(true),
     scope: z.literal("session"),