bikky 0.3.13 → 0.4.1

package/dist/mcp/tools.js

@@ -5,8 +5,10 @@ import crypto from "node:crypto";
 import { z } from "zod";
 import { STALENESS_DAYS, THRESHOLD_DUPLICATE, THRESHOLD_RELATED, QDRANT_INDEXES, categoryValues, categoryEnumDescription, domainValues, domainEnumDescription, kindValues, kindEnumDescription, memorySubtypeValues, memorySubtypeEnumDescription, sourceValues, sourceEnumDescription, DEFAULT_CATEGORY, DEFAULT_DOMAIN, DEFAULT_KIND, DEFAULT_SOURCE, categoryForMemorySubtype, layerForMemorySubtype, normalizeCategory, normalizeDomain, normalizeKind, validateMemorySubtype, } from "./taxonomy.js";
 import { contentHash, daysSince, lastActivityDate, computeCombinedScore, buildFilter, formatFact, structuredFact, MEMORY_RECALL_EXCLUDED_KINDS, } from "./helpers.js";
-import { ready, qdrantUrl, qdrantApiKey, setupError, setQdrantUrl, setQdrantApiKey, setReady, getCollection, log, embed, getEmbeddingConfig, qdrantReq, ensureCollection, qdrantUpsert, qdrantSearch, qdrantScroll, qdrantSetPayload, qdrantGetPoints, } from "./api.js";
+import { ready, setupError, setReady, log, embed, getEmbeddingConfig, qdrantReq, ensureCollectionsAll, qdrantUpsert, qdrantSearch, qdrantScroll, qdrantSetPayload, qdrantGetPoints, rebuildPool, hasPool, listDestinations, resolveDest, findPointById, } from "./api.js";
+import { DestinationNotFoundError } from "../routing.js";
 import { saveConfig, loadConfig, EXTRACTION_HEALTH_PATH } from "../config.js";
+import { availableSearchScopes, resolveSearchScope, SearchScopeNotFoundError, } from "../search-scope.js";
 import { existsSync, readFileSync } from "node:fs";
 import { inspectWatcherPaths, formatIssue, repairSuspiciousWatcherPaths } from "../daemon/watcher-health.js";
 import { normalizeActorId, resolveActorIdentity } from "../provenance/actor.js";
@@ -17,6 +19,7 @@ import { addRedactionPayload, combineRedactions, redactStorageText, } from "../p
 const NUDGE_INTERVAL_MS = 10 * 60 * 1000;
 const MEMORY_RECALL_DEFAULT_LIMIT = 10;
 const MEMORY_RECALL_MAX_LIMIT = 50;
+const searchScopeSchema = z.union([z.string(), z.array(z.string())]).optional();
 let lastStoreTime = Date.now();
 let heartbeatCount = 0;
 // ---------------------------------------------------------------------------
@@ -28,32 +31,105 @@ function nowISO() {
 function newId() {
     return crypto.randomUUID();
 }
-export function resolveScope(workspaceId, includeLegacyWorkspace = false, actorId) {
-    const resolved = workspaceId?.trim()
-        || process.env.BIKKY_WORKSPACE?.trim()
-        || loadConfig().default_workspace?.trim()
-        || undefined;
-    // The literal "default" workspace also includes legacy facts that have no
-    // workspace_id payload (pre-migration data). Any other named workspace stays
-    // strict. An explicit includeLegacyWorkspace=true from the caller still wins.
-    const isDefault = resolved === "default";
+// Build a RoutingInput from the standard memory-tool fields.
+function routingInput(args) {
     return {
-        workspaceId: resolved,
-        actorId: normalizeActorId(actorId),
-        includeLegacy: includeLegacyWorkspace || isDefault,
+        destination: args.destination,
+        cwd: process.cwd(),
+        content: args.content,
+        entities: args.entities,
+        metadata: args.metadata,
     };
 }
-function scopedFilter(scope, extra = {}) {
-    return buildFilter({
-        ...extra,
-        workspace_id: scope.workspaceId,
-        includeLegacyWorkspace: scope.includeLegacy,
-    });
+// Resolve a destination from a routing input, returning either the destination
+// or an MCP error result if the override is invalid / no destinations exist.
+function resolveDestOrError(input) {
+    try {
+        return { dest: resolveDest(input) };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (e instanceof DestinationNotFoundError) {
+            return {
+                error: {
+                    content: [{ type: "text", text: JSON.stringify({
+                                status: "destination_not_found",
+                                message: msg,
+                                available_destinations: listDestinations().map((d) => d.name),
+                            }, null, 2) }],
+                    isError: true,
+                },
+            };
+        }
+        return {
+            error: {
+                content: [{ type: "text", text: JSON.stringify({ status: "error", message: msg }, null, 2) }],
+                isError: true,
+            },
+        };
+    }
+}
+function withDestination(point, destination) {
+    return { ...point, _destination: destination };
+}
+function structuredScopedFact(point) {
+    return {
+        ...structuredFact(point),
+        destination: point._destination.name,
+    };
+}
+function formatScopedFact(point, includeDestination) {
+    const formatted = formatFact(point);
+    return includeDestination ? `[${point._destination.name}] ${formatted}` : formatted;
+}
+function resolveSearchScopeOrError(args) {
+    if (args.destination && args.search_scope !== undefined) {
+        return {
+            error: {
+                content: [{ type: "text", text: JSON.stringify({
+                            status: "ambiguous_search_scope",
+                            message: "Use either destination for a single destination override or search_scope for routed/all/list search, not both.",
+                        }, null, 2) }],
+                isError: true,
+            },
+        };
+    }
+    if (args.destination) {
+        const resolved = resolveDestOrError({ ...args.input, destination: args.destination });
+        if (resolved.error)
+            return { error: resolved.error };
+        return {
+            scope: {
+                name: resolved.dest.name,
+                description: resolved.dest.description ?? `Search only the '${resolved.dest.name}' destination.`,
+                requested: resolved.dest.name,
+                destinations: [resolved.dest],
+            },
+        };
+    }
+    const cfg = loadConfig();
+    const dests = listDestinations();
+    try {
+        return { scope: resolveSearchScope(args.search_scope, cfg, dests, args.input) };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+            error: {
+                content: [{ type: "text", text: JSON.stringify({
+                            status: e instanceof SearchScopeNotFoundError ? "search_scope_not_found" : "search_scope_error",
+                            message: msg,
+                            available_search_scopes: availableSearchScopes(cfg, dests),
+                        }, null, 2) }],
+                isError: true,
+            },
+        };
+    }
 }
-function addWorkspacePayload(payload, scope, actor) {
-    if (scope.workspaceId)
-        payload["workspace_id"] = scope.workspaceId;
-    const actorId = actor?.actor_id ?? scope.actorId;
+// Add actor identity payload fields. Workspace was removed in v0.4.0 — physical
+// separation now happens via routing destinations (see routing.ts).
+function addActorPayload(payload, actor, actorIdOverride) {
+    const actorId = actor?.actor_id ?? normalizeActorId(actorIdOverride);
     if (actorId)
         payload["actor_id"] = actorId;
     if (actor?.actor_label) {
@@ -66,19 +142,34 @@ function addWorkspacePayload(payload, scope, actor) {
         payload["metadata"] = metadata;
     }
 }
-async function getPointForWorkspaceWrite(factId, _scope) {
-    const existing = await qdrantGetPoints([factId]);
+async function getPointForWrite(dest, factId) {
+    const existing = await qdrantGetPoints(dest, [factId]);
     const point = existing.result?.[0];
     if (!point) {
         return { error: { status: "not_found", fact_id: factId } };
     }
     return { point };
 }
+// Locate which destination owns a fact ID (fan-out across pool). Used by
+// ID-based ops where the caller doesn't know upfront which destination holds
+// the point (memory_forget, memory_verify, memory_report_outcome, etc.).
+async function locatePoint(factId) {
+    const found = await findPointById(factId);
+    if (!found)
+        return null;
+    return { dest: found.destination, point: found.point };
+}
+function notFoundResult(factId) {
+    return {
+        content: [{ type: "text", text: JSON.stringify({ status: "not_found", fact_id: factId }, null, 2) }],
+        isError: true,
+    };
+}
 function requireReady() {
     if (!ready) {
         const missing = [];
-        if (!qdrantUrl)
-            missing.push("qdrant-url");
+        if (!hasPool())
+            missing.push("destinations");
         return {
             content: [{
                     type: "text",
@@ -86,9 +177,6 @@ function requireReady() {
                         status: "setup_required",
                         ready: false,
                         missing,
-                        // Surface the underlying init failure (embedding / Qdrant) when
-                        // present so users see an actionable reason instead of a generic
-                        // "setup required" message.
                         ...(setupError ? { setup_error: setupError } : {}),
                         setup_instructions: "Memory is not configured. Run `bikky setup` or call configure_credentials:\n" +
                             "1. Go to cloud.qdrant.io → sign up (free tier: 1GB, no credit card)\n" +
@@ -126,7 +214,7 @@ function clampRecallLimit(limit) {
 /**
  * Entity-graph traversal for memory_recall.
  */
-async function graphTraversal(primaryResults, limit, scope) {
+async function graphTraversal(dest, primaryResults, limit) {
     try {
         const primaryEntities = new Set();
         const primaryIds = new Set();
@@ -140,16 +228,16 @@ async function graphTraversal(primaryResults, limit, scope) {
             return { points: [] };
         const relatedEntities = new Set();
         for (const entity of primaryEntities) {
-            const outgoingFilter = scopedFilter(scope, { excludeKinds: MEMORY_RECALL_EXCLUDED_KINDS }) ?? { must: [] };
+            const outgoingFilter = buildFilter({ excludeKinds: MEMORY_RECALL_EXCLUDED_KINDS }) ?? { must: [] };
             outgoingFilter.must.push({ key: "from_entity", match: { value: entity } });
-            const outgoing = await qdrantScroll(outgoingFilter, 10).catch(() => ({ result: { points: [] } }));
+            const outgoing = await qdrantScroll(dest, outgoingFilter, 10).catch(() => ({ result: { points: [] } }));
             for (const pt of (outgoing.result?.points ?? [])) {
                 if (pt.payload.to_entity)
                     relatedEntities.add(pt.payload.to_entity);
             }
-            const incomingFilter = scopedFilter(scope, { excludeKinds: MEMORY_RECALL_EXCLUDED_KINDS }) ?? { must: [] };
+            const incomingFilter = buildFilter({ excludeKinds: MEMORY_RECALL_EXCLUDED_KINDS }) ?? { must: [] };
             incomingFilter.must.push({ key: "to_entity", match: { value: entity } });
-            const incoming = await qdrantScroll(incomingFilter, 10).catch(() => ({ result: { points: [] } }));
+            const incoming = await qdrantScroll(dest, incomingFilter, 10).catch(() => ({ result: { points: [] } }));
             for (const pt of (incoming.result?.points ?? [])) {
                 if (pt.payload.from_entity)
                     relatedEntities.add(pt.payload.from_entity);
@@ -162,9 +250,9 @@ async function graphTraversal(primaryResults, limit, scope) {
         const relatedFacts = [];
         const maxPerEntity = Math.max(2, Math.floor(limit / relatedEntities.size));
         for (const entity of relatedEntities) {
-            const filter = scopedFilter(scope, { excludeKinds: MEMORY_RECALL_EXCLUDED_KINDS }) ?? { must: [] };
+            const filter = buildFilter({ excludeKinds: MEMORY_RECALL_EXCLUDED_KINDS }) ?? { must: [] };
             filter.must.push({ key: "entities", match: { value: entity } });
-            const result = await qdrantScroll(filter, maxPerEntity).catch(() => ({ result: { points: [] } }));
+            const result = await qdrantScroll(dest, filter, maxPerEntity).catch(() => ({ result: { points: [] } }));
             for (const pt of (result.result?.points ?? [])) {
                 if (!primaryIds.has(pt.id)) {
                     relatedFacts.push(pt);
@@ -189,33 +277,57 @@ export function registerTools(mcp) {
         "Use this when memory tools return a 'setup_required' error, or once at session start if you're not sure bikky is wired up. Reports which credentials are missing and includes onboarding instructions if anything is incomplete.",
         "Read-only — safe to call any time.",
     ].join(" "), {}, async () => {
-        const activeWorkspace = process.env.BIKKY_WORKSPACE?.trim()
-            || loadConfig().default_workspace?.trim()
-            || null;
+        const cfg = loadConfig();
+        const dests = listDestinations();
         const status = {
             ready,
-            qdrant_url: !!qdrantUrl,
-            qdrant_api_key: !!qdrantApiKey,
+            destinations_configured: dests.length,
             missing: [],
-            qdrant_connected: false,
             embedding_connected: false,
             embedding_provider: getEmbeddingConfig().provider,
             embedding_model: getEmbeddingConfig().model,
             embedding_dimensions: getEmbeddingConfig().dimensions,
-            ...(activeWorkspace ? { active_workspace: activeWorkspace } : {}),
             ...(setupError ? { setup_error: setupError } : {}),
         };
         const missing = status["missing"];
-        if (!qdrantUrl)
-            missing.push("qdrant-url");
-        // qdrant-api-key is optional (local / self-hosted Qdrant doesn't need it).
-        if (qdrantUrl) {
+        if (dests.length === 0)
+            missing.push("destinations");
+        // Per-destination health
+        const destStatus = [];
+        for (const d of dests) {
+            const block = {
+                name: d.name,
+                qdrant_url_host: (() => { try {
+                    return new URL(d.qdrant_url).host;
+                }
+                catch {
+                    return d.qdrant_url;
+                } })(),
+                collection: d.collection,
+                default: d.default ?? false,
+                ...(d.description ? { description: d.description } : {}),
+                connected: false,
+                collection_exists: false,
+            };
+            try {
+                await qdrantReq(d, "GET", "/collections");
+                block["connected"] = true;
+            }
+            catch (e) {
+                block["last_error"] = e instanceof Error ? e.message : String(e);
+            }
             try {
-                await qdrantReq("GET", "/collections");
-                status["qdrant_connected"] = true;
+                await qdrantReq(d, "GET", `/collections/${d.collection}`);
+                block["collection_exists"] = true;
             }
             catch { /* ignore */ }
+            destStatus.push(block);
         }
+        status["destinations"] = destStatus;
+        status["default_search_scope"] = cfg.default_search_scope;
+        status["search_scopes"] = availableSearchScopes(cfg, dests);
+        status["search_scope_hint"] =
+            "Read/search tools accept search_scope: 'routed', 'all', a destination name, a configured scope name, a comma-separated destination list, or an array of destination names. Use destination only when you want an exact single-destination override.";
         try {
             await embed("test");
             status["embedding_connected"] = true;
@@ -224,8 +336,11 @@ export function registerTools(mcp) {
         // Watcher / extraction health (issue #58)
         const warnings = [];
         try {
-            const cfg = loadConfig();
             status["watcher_path"] = cfg.watchers.copilot.path;
+            status["watcher_paths"] = {
+                copilot: cfg.watchers.copilot.path,
+                claude: cfg.watchers.claude.path,
+            };
             for (const issue of inspectWatcherPaths(cfg)) {
                 warnings.push(formatIssue(issue));
             }
@@ -237,17 +352,19 @@ export function registerTools(mcp) {
                 status["extraction_last_tick_at"] = health.last_tick_at ?? null;
                 status["extraction_last_active_session_at"] = health.last_active_session_at ?? null;
                 status["extraction_active_session_count"] = health.active_session_count ?? 0;
+                if (health.sources)
+                    status["extraction_sources"] = health.sources;
                 if (health.last_active_session_at) {
                     const hours = (Date.now() - Date.parse(health.last_active_session_at)) / 3_600_000;
                     status["extraction_hours_since_active_session"] = Math.round(hours * 10) / 10;
                     if (hours > 6) {
-                        warnings.push(`Watcher has not seen any active Copilot sessions for ${Math.round(hours)}h — ` +
+                        warnings.push(`Watcher has not seen any active transcript sources for ${Math.round(hours)}h — ` +
                             `check watcher_path (${health.watcher_path ?? "unknown"}) and that the daemon is running.`);
                     }
                 }
                 else {
                     status["extraction_hours_since_active_session"] = null;
-                    warnings.push("Daemon has never observed an active Copilot session — extraction may be stalled.");
+                    warnings.push("Daemon has never observed an active transcript source — extraction may be stalled.");
                 }
             }
             else {
@@ -269,6 +386,25 @@ export function registerTools(mcp) {
         }
         return { content: [{ type: "text", text: JSON.stringify(status, null, 2) }] };
     });
+    // ── memory_search_scopes ─────────────────────────────────────────────────
+    mcp.tool("memory_search_scopes", [
+        "List the configured memory search scopes and destination descriptions.",
+        "Use this before memory_recall, memory_entity, or memory_relations when multiple destinations exist so you can choose the right search_scope.",
+        "Read-only — returns built-in scopes ('routed', 'all'), destination-name scopes, configured named scopes, and the default_search_scope.",
+    ].join(" "), {}, async () => {
+        const cfg = loadConfig();
+        const dests = listDestinations();
+        return {
+            content: [{ type: "text", text: JSON.stringify({
+                        default_search_scope: cfg.default_search_scope,
+                        scopes: availableSearchScopes(cfg, dests),
+                        usage: {
+                            search_scope: "Pass one scope name, 'routed', 'all', a destination name, a comma-separated destination list, or an array of destination names.",
+                            destination: "Use this older parameter only for an exact single-destination override. Do not combine it with search_scope.",
+                        },
+                    }, null, 2) }],
+        };
+    });
     // ── configure_credentials ───────────────────────────────────────────────
     mcp.tool("configure_credentials", [
         "Persist Qdrant and embedding credentials to ~/.bikky/config.json and bring the memory system online.",
@@ -283,12 +419,10 @@ export function registerTools(mcp) {
         if (qdrant_url) {
             const url = qdrant_url.replace(/\/+$/, "");
             cfg.qdrant_url = url;
-            setQdrantUrl(url);
             results["qdrant_url"] = "stored ✓";
         }
         if (qdrant_api_key) {
             cfg.qdrant_api_key = qdrant_api_key;
-            setQdrantApiKey(qdrant_api_key);
             results["qdrant_api_key"] = "stored ✓";
         }
         if (openai_api_key) {
@@ -301,14 +435,22 @@ export function registerTools(mcp) {
             results["watcher_path_repairs"] = watcherRepairs;
         }
         saveConfig(cfg);
-        if (qdrantUrl) {
-            try {
-                await ensureCollection(QDRANT_INDEXES);
-                results["qdrant_collection"] = `'${getCollection()}' ready ✓`;
-            }
-            catch (e) {
-                results["qdrant_collection"] = `error: ${e instanceof Error ? e.message : String(e)}`;
-            }
+        // Rebuild the destination pool from the updated config so the
+        // synthesized default destination picks up the new url/key.
+        try {
+            rebuildPool();
+        }
+        catch (e) {
+            results["pool_rebuild"] = `error: ${e instanceof Error ? e.message : String(e)}`;
+        }
+        if (hasPool()) {
+            const ensured = await ensureCollectionsAll(QDRANT_INDEXES);
+            results["destinations"] = ensured.map((r) => ({
+                name: r.destination.name,
+                collection: r.destination.collection,
+                ok: r.ok,
+                ...(r.error ? { error: r.error } : {}),
+            }));
         }
         try {
             await embed("memory system test");
@@ -318,7 +460,7 @@ export function registerTools(mcp) {
         catch (e) {
             results["embedding"] = `error: ${e instanceof Error ? e.message : String(e)}`;
         }
-        setReady(!!qdrantUrl);
+        setReady(hasPool());
         results["ready"] = ready;
         return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
     });
@@ -328,21 +470,31 @@ export function registerTools(mcp) {
         "Use this to debug a sudden 'setup_required' or empty-recall after a network blip or credential change. Lighter than configure_credentials — does not write to disk.",
         "Read-only.",
     ].join(" "), {}, async () => {
-        const results = { qdrant: false, embedding: false, collection: false };
-        if (qdrantUrl) {
+        const results = { embedding: false };
+        const dests = listDestinations();
+        const destResults = [];
+        for (const d of dests) {
+            const block = {
+                name: d.name,
+                collection: d.collection,
+                qdrant: false,
+                collection_exists: false,
+            };
             try {
-                await qdrantReq("GET", "/collections");
-                results["qdrant"] = true;
+                await qdrantReq(d, "GET", "/collections");
+                block["qdrant"] = true;
             }
             catch (e) {
-                results["qdrant_error"] = e instanceof Error ? e.message : String(e);
+                block["qdrant_error"] = e instanceof Error ? e.message : String(e);
             }
             try {
-                await qdrantReq("GET", `/collections/${getCollection()}`);
-                results["collection"] = true;
+                await qdrantReq(d, "GET", `/collections/${d.collection}`);
+                block["collection_exists"] = true;
             }
             catch { /* ignore */ }
+            destResults.push(block);
         }
+        results["destinations"] = destResults;
         try {
             await embed("connection test");
             results["embedding"] = true;
@@ -350,7 +502,8 @@ export function registerTools(mcp) {
         catch (e) {
             results["embedding_error"] = e instanceof Error ? e.message : String(e);
         }
-        const allReady = results["qdrant"] === true && results["embedding"] === true && results["collection"] === true;
+        const allReady = results["embedding"] === true && destResults.length > 0
+            && destResults.every((b) => b["qdrant"] === true && b["collection_exists"] === true);
         results["ready"] = allReady;
         setReady(allReady);
         return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
@@ -369,7 +522,8 @@ export function registerTools(mcp) {
         domain: z.enum(domainValues()).default(DEFAULT_DOMAIN).describe(domainEnumDescription()),
         kind: z.enum(kindValues()).default(DEFAULT_KIND).describe(kindEnumDescription()),
         memory_subtype: z.enum(memorySubtypeValues()).optional().describe(memorySubtypeEnumDescription()),
-        workspace_id: z.string().optional().describe("Workspace namespace for team-shared memory. Omit to use the default workspace from config."),
+        workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op. Routing now uses destinations — see destination."),
+        destination: z.string().optional().describe("Optional destination override. When set, routes to that destination by name. Hard-errors if no such destination exists. Omit to let routing rules in ~/.bikky/config.json decide based on cwd/entities/content/metadata."),
         actor_id: z.string().optional().describe("Stable actor/person/agent identity associated with this capture. Overrides identity config/env/Git-derived fallback for this write."),
         episode_id: z.string().optional().describe("Coherent activity-segment ID. Group facts captured during the same coherent task or transcript."),
         workstream_key: z.string().optional().describe("Durable continuity key for a long-running objective (survives across sessions)."),
@@ -387,13 +541,21 @@ export function registerTools(mcp) {
             to: z.string().describe("Target entity (lowercase)."),
         }).optional().describe("Optional typed edge between two entities — created in the same call. Use this whenever the fact also expresses a relationship; no separate tool call needed."),
         metadata: z.record(z.string(), z.string()).optional().describe("Arbitrary key-value metadata. Stored with the fact and exact-match filterable via memory_recall.metadata_filter (all key/value pairs must match — AND logic)."),
-    }, async ({ content, category, entities, domain, kind, memory_subtype, workspace_id, actor_id, episode_id, workstream_key, task_key, repo, branch, review_status, source, confidence, importance, supersedes, relation, metadata, }) => {
+    }, async ({ content, category, entities, domain, kind, memory_subtype, workspace_id: _workspace_id, destination, actor_id, episode_id, workstream_key, task_key, repo, branch, review_status, source, confidence, importance, supersedes, relation, metadata, }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         lastStoreTime = Date.now();
         const now = nowISO();
-        const scope = resolveScope(workspace_id);
+        const resolved = resolveDestOrError(routingInput({
+            destination,
+            content,
+            entities,
+            metadata,
+        }));
+        if (resolved.error)
+            return resolved.error;
+        const dest = resolved.dest;
         const actor = resolveActorIdentity({ actorId: actor_id, config: loadConfig() });
         const normalizedKind = normalizeKind(kind);
         let normalizedSubtype = null;
@@ -439,14 +601,14 @@ export function registerTools(mcp) {
         } : null;
         // 1. Exact dedup via content hash
         try {
-            const hashFilter = scopedFilter(scope) ?? { must: [] };
+            const hashFilter = buildFilter({}) ?? { must: [] };
             hashFilter.must.push({ key: "content_hash", match: { value: hash } });
-            const existing = await qdrantScroll(hashFilter, 1);
+            const existing = await qdrantScroll(dest, hashFilter, 1);
             const existingPoint = existing.result?.points?.[0];
             if (existingPoint) {
                 const point = existingPoint;
                 const count = (point.payload.reinforcement_count || 1) + 1;
-                await qdrantSetPayload([point.id], {
+                await qdrantSetPayload(dest, [point.id], {
                     reinforcement_count: count,
                     last_reinforced_at: now,
                     updated_at: now,
@@ -470,18 +632,18 @@ export function registerTools(mcp) {
         let similarFacts = [];
         let potentialConflicts = [];
         try {
-            const filter = scopedFilter(scope) ?? { must: [] };
+            const filter = buildFilter({}) ?? { must: [] };
             if (normalizedEntities.length > 0) {
                 filter.must.push({ key: "entities", match: { any: normalizedEntities } });
             }
-            const results = await qdrantSearch(vector, filter, 3);
+            const results = await qdrantSearch(dest, vector, filter, 3);
             const firstResult = results.result?.[0];
             if (results.result?.length > 0 && firstResult) {
                 const topScore = firstResult.score ?? 0;
                 if (topScore > THRESHOLD_DUPLICATE) {
                     const point = firstResult;
                     const count = (point.payload.reinforcement_count || 1) + 1;
-                    await qdrantSetPayload([point.id], {
+                    await qdrantSetPayload(dest, [point.id], {
                         reinforcement_count: count,
                         last_reinforced_at: now,
                         updated_at: now,
@@ -531,11 +693,11 @@ export function registerTools(mcp) {
         // 5. Supersede old fact if requested
         if (supersedes) {
             try {
-                const existing = await getPointForWorkspaceWrite(supersedes, scope);
+                const existing = await getPointForWrite(dest, supersedes);
                 if (existing.error) {
                     return { content: [{ type: "text", text: JSON.stringify(existing.error, null, 2) }], isError: true };
                 }
-                await qdrantSetPayload([supersedes], {
+                await qdrantSetPayload(dest, [supersedes], {
                     superseded_by: factId,
                     superseded_at: now,
                 });
@@ -583,9 +745,9 @@ export function registerTools(mcp) {
         }
         if (review_status)
             payload["review_status"] = review_status;
-        addWorkspacePayload(payload, scope, actor);
+        addActorPayload(payload, actor);
         addRedactionPayload(payload, factRedactionSummary);
-        await qdrantUpsert(factId, vector, payload);
+        await qdrantUpsert(dest, factId, vector, payload);
         // 7. Insert relation point if provided
         let relationId = null;
         if (sanitizedRelation) {
@@ -612,14 +774,14 @@ export function registerTools(mcp) {
                 relation_type: sanitizedRelation.type.toLowerCase(),
                 to_entity: sanitizedRelation.to.toLowerCase(),
             };
-            addWorkspacePayload(relPayload, scope, actor);
+            addActorPayload(relPayload, actor);
             addRedactionPayload(relPayload, relationRedactionSummary);
-            await qdrantUpsert(relationId, relVector, relPayload);
+            await qdrantUpsert(dest, relationId, relVector, relPayload);
         }
         const result = {
             action: "inserted",
             fact_id: factId,
-            workspace_id: scope.workspaceId,
+            destination: dest.name,
         };
         if (actor.actor_id)
             result["actor_id"] = actor.actor_id;
@@ -646,6 +808,7 @@ export function registerTools(mcp) {
         "  3. Conflict/replacement check — recall similar facts when you suspect new information may supersede an older fact. Deduplication during memory_store is automatic.",
         "Combine the natural-language query with structured filters (category, domain, entity, date range, metadata) for tighter results.",
         "If you have a known entity name and want everything about it, prefer memory_entity. For 'what does X own/use?' style questions, prefer memory_relations.",
+        "When multiple Qdrant destinations are configured, use search_scope to choose 'routed' (routing/default behavior), 'all', a destination name, a configured scope name, a comma-separated destination list, or an array of destination names. Call memory_search_scopes to inspect available scopes and descriptions.",
         `By default output is human-readable text. Use output_format=json for machine-parseable results with separate results and related arrays. Default limit is ${MEMORY_RECALL_DEFAULT_LIMIT}; maximum effective limit is ${MEMORY_RECALL_MAX_LIMIT}.`,
     ].join("\n"), {
         query: z.string().describe("Natural-language description of what you're looking for. Embedded and matched semantically — full sentences work better than keyword lists."),
@@ -653,9 +816,11 @@ export function registerTools(mcp) {
         domain: z.string().optional().describe("Filter by domain activity profile (same vocabulary as memory_store.domain). Optional."),
         kind: z.string().optional().describe("Filter by kind: fact, summary, distilled, relation. Optional. Telemetry is excluded by default."),
         memory_subtype: z.string().optional().describe("Filter by memory subtype (must be valid for the chosen kind). Optional."),
-        workspace_id: z.string().optional().describe("Filter to facts in this workspace namespace. Omit to use the default workspace from config."),
+        workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op."),
+        destination: z.string().optional().describe("Optional legacy single-destination override. Do not combine with search_scope. Prefer search_scope for routed/all/list search."),
+        search_scope: searchScopeSchema.describe("Optional read/search scope. Accepts 'routed', 'all', a destination name, a configured scope name, a comma-separated destination list, or an array of destination names. Omit to use config.default_search_scope."),
         actor_id: z.string().optional().describe("Filter to facts captured by or associated with this stable actor identity. Optional."),
-        include_legacy_workspace: z.boolean().optional().describe("Backwards-compatibility flag: also include legacy facts that have no workspace_id. Default false. Only set this if you suspect pre-migration data is missing from results."),
+        include_legacy_workspace: z.boolean().optional().describe("[Removed in v0.4.0] No-op."),
         entity: z.string().optional().describe("Restrict to facts mentioning this entity (case-insensitive). For full entity context prefer memory_entity."),
         episode_id: z.string().optional().describe("Filter by coherent episode ID."),
         workstream_key: z.string().optional().describe("Filter by durable workstream key."),
@@ -669,14 +834,25 @@ export function registerTools(mcp) {
         graph_depth: z.number().optional().default(0).describe("Entity-graph traversal depth. 0 = vector search only (fast, default). 1 = also surface up to ceil(limit / 2) extra 1-hop entity-related facts (slower; use when the user asks 'what's connected to X?'). In JSON output these are returned separately as related."),
         output_format: z.enum(["text", "json"]).optional().default("text").describe("Response format. text = backward-compatible human-readable lines (default). json = parseable object with query, limit metadata, results, related, counts, and optional nudge."),
         metadata_filter: z.record(z.string(), z.string()).optional().describe("Exact-match filter on the metadata map stored with each fact. All key/value pairs must match (AND logic)."),
-    }, async ({ query, category, domain, kind, memory_subtype, workspace_id, actor_id, include_legacy_workspace, entity, episode_id, workstream_key, task_key, repo, branch, review_status, since, until, limit, graph_depth, output_format, metadata_filter, }) => {
+    }, async ({ query, category, domain, kind, memory_subtype, workspace_id: _workspace_id, destination, search_scope, actor_id, include_legacy_workspace: _include_legacy_workspace, entity, episode_id, workstream_key, task_key, repo, branch, review_status, since, until, limit, graph_depth, output_format, metadata_filter, }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         const requestedLimit = limit ?? MEMORY_RECALL_DEFAULT_LIMIT;
         const effectiveLimit = clampRecallLimit(limit);
         const actorFilter = resolveActorIdentity({ actorId: actor_id, useGitFallback: false });
-        const scope = resolveScope(workspace_id, include_legacy_workspace, actorFilter.actor_id);
+        const scopeResolved = resolveSearchScopeOrError({
+            destination,
+            search_scope,
+            input: routingInput({
+                content: query,
+                entities: entity ? [entity] : [],
+                metadata: metadata_filter,
+            }),
+        });
+        if (scopeResolved.error)
+            return scopeResolved.error;
+        const searchScope = scopeResolved.scope;
         const redactedQuery = redactStorageText(query);
         const vector = await embed(redactedQuery.text);
         const normalizedKind = kind ? normalizeKind(kind) : undefined;
@@ -692,11 +868,12 @@ export function registerTools(mcp) {
                 };
             }
         }
-        const filter = scopedFilter(scope, {
+        const filter = buildFilter({
             category: category ? normalizeCategory(category) : undefined,
             domain: domain ? normalizeDomain(domain) : undefined,
             kind: normalizedKind,
             memory_subtype: normalizedSubtype,
+            actor_id: actorFilter.actor_id,
             entity,
             episode_id,
             workstream_key,
@@ -709,12 +886,42 @@ export function registerTools(mcp) {
             metadata: metadata_filter,
             excludeKinds: MEMORY_RECALL_EXCLUDED_KINDS,
         });
-        const results = await qdrantSearch(vector, filter, effectiveLimit * 2);
-        if (!results.result?.length) {
+        const searchedDestinations = searchScope.destinations.map((dest) => dest.name);
+        const failedDestinations = [];
+        const scopedResults = [];
+        for (const dest of searchScope.destinations) {
+            try {
+                const results = await qdrantSearch(dest, vector, filter, effectiveLimit * 2);
+                scopedResults.push(...(results.result ?? []).map((point) => withDestination(point, dest)));
+            }
+            catch (e) {
+                failedDestinations.push({
+                    destination: dest.name,
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        if (failedDestinations.length === searchScope.destinations.length && searchScope.destinations.length > 0) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            status: "search_failed",
+                            query: redactedQuery.text,
+                            search_scope: searchScope.name,
+                            searched_destinations: searchedDestinations,
+                            failed_destinations: failedDestinations,
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
+        if (scopedResults.length === 0) {
             const nudge = buildMemoryNudge();
             if (output_format === "json") {
                 return { content: [{ type: "text", text: JSON.stringify({
                                 query: redactedQuery.text,
+                                search_scope: searchScope.name,
+                                search_scope_description: searchScope.description,
+                                searched_destinations: searchedDestinations,
+                                failed_destinations: failedDestinations,
                                 requested_limit: requestedLimit,
                                 effective_limit: effectiveLimit,
                                 max_limit: MEMORY_RECALL_MAX_LIMIT,
@@ -728,31 +935,61 @@ export function registerTools(mcp) {
                                 ...(redactedQuery.redacted ? { query_redaction: redactedQuery } : {}),
                             }, null, 2) }] };
             }
-            const text = nudge ? `No matching facts found.\n\n${nudge}` : "No matching facts found.";
+            const warning = failedDestinations.length > 0
+                ? `\n\nSearch warnings: ${failedDestinations.map((failure) => `${failure.destination}: ${failure.error}`).join("; ")}`
+                : "";
+            const text = nudge
+                ? `No matching facts found.${warning}\n\n${nudge}`
+                : `No matching facts found.${warning}`;
             return { content: [{ type: "text", text }] };
         }
-        const ranked = results.result
+        const ranked = scopedResults
             .map((r) => ({ ...r, _combinedScore: computeCombinedScore(r) }))
             .sort((a, b) => b._combinedScore - a._combinedScore)
             .slice(0, effectiveLimit);
-        const lines = ranked.map((r) => formatFact(r));
-        let related = { points: [] };
+        const includeDestination = searchScope.destinations.length > 1 || searchScope.name === "all";
+        const lines = ranked.map((r) => formatScopedFact(r, includeDestination));
+        const related = { points: [], errors: [] };
         if ((graph_depth ?? 0) >= 1) {
-            related = await graphTraversal(ranked, effectiveLimit, scope);
+            const byDestination = new Map();
+            for (const point of ranked) {
+                const existing = byDestination.get(point._destination.name);
+                if (existing) {
+                    existing.points.push(point);
+                }
+                else {
+                    byDestination.set(point._destination.name, { dest: point._destination, points: [point] });
+                }
+            }
+            for (const entry of byDestination.values()) {
+                const traversal = await graphTraversal(entry.dest, entry.points, effectiveLimit);
+                related.points.push(...traversal.points.map((point) => withDestination(point, entry.dest)));
+                if (traversal.error) {
+                    related.errors.push({ destination: entry.dest.name, error: traversal.error });
+                }
+            }
+            related.points = related.points.slice(0, Math.ceil(effectiveLimit / 2));
             if (related.points.length > 0) {
                 lines.push("", "── Related (1-hop) ──");
-                lines.push(...related.points.map((r) => formatFact(r)));
+                lines.push(...related.points.map((r) => formatScopedFact(r, includeDestination)));
             }
-            else if (related.error) {
-                lines.push("", `(graph traversal failed: ${related.error})`);
+            if (related.errors.length > 0) {
+                lines.push("", `(graph traversal warnings: ${related.errors.map((failure) => `${failure.destination}: ${failure.error}`).join("; ")})`);
             }
         }
+        if (failedDestinations.length > 0) {
+            lines.push("", `(search warnings: ${failedDestinations.map((failure) => `${failure.destination}: ${failure.error}`).join("; ")})`);
+        }
         const nudge = buildMemoryNudge();
         if (nudge)
             lines.push("", nudge);
         if (output_format === "json") {
             return { content: [{ type: "text", text: JSON.stringify({
                             query: redactedQuery.text,
+                            search_scope: searchScope.name,
+                            search_scope_description: searchScope.description,
+                            searched_destinations: searchedDestinations,
+                            failed_destinations: failedDestinations,
                             requested_limit: requestedLimit,
                             effective_limit: effectiveLimit,
                             max_limit: MEMORY_RECALL_MAX_LIMIT,
@@ -760,9 +997,9 @@ export function registerTools(mcp) {
                             graph_depth: graph_depth ?? 0,
                             result_count: ranked.length,
                             related_count: related.points.length,
-                            results: ranked.map((r) => structuredFact(r)),
-                            related: related.points.map((r) => structuredFact(r)),
-                            ...(related.error ? { graph_error: related.error } : {}),
+                            results: ranked.map((r) => structuredScopedFact(r)),
+                            related: related.points.map((r) => structuredScopedFact(r)),
+                            ...(related.errors.length > 0 ? { graph_errors: related.errors } : {}),
                             ...(nudge ? { nudge } : {}),
                             ...(redactedQuery.redacted ? { query_redaction: redactedQuery } : {}),
                         }, null, 2) }] };
@@ -777,73 +1014,113 @@ export function registerTools(mcp) {
     ].join(" "), {
         name: z.string().describe("Entity name (case-insensitive, e.g. 'qdrant', 'workspace_id'). Should match the lowercase canonical form used when facts were stored."),
         limit: z.number().optional().default(20).describe("Max facts to return (default 20). Relations are always returned in full, capped at 50 each direction."),
-        workspace_id: z.string().optional().describe("Workspace namespace. Omit to use the default from config."),
-        include_legacy_workspace: z.boolean().optional().describe("Backwards-compatibility: also include legacy facts with no workspace_id. Default false."),
-    }, async ({ name, limit, workspace_id, include_legacy_workspace }) => {
+        workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op."),
+        destination: z.string().optional().describe("Optional legacy single-destination override. Do not combine with search_scope."),
+        search_scope: searchScopeSchema.describe("Optional read/search scope. Accepts 'routed', 'all', a destination name, a configured scope name, a comma-separated destination list, or an array of destination names. Omit to use config.default_search_scope."),
+        include_legacy_workspace: z.boolean().optional().describe("[Removed in v0.4.0] No-op."),
+    }, async ({ name, limit, workspace_id: _workspace_id, destination, search_scope, include_legacy_workspace: _include_legacy_workspace }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         const entityName = name.toLowerCase();
-        const scope = resolveScope(workspace_id, include_legacy_workspace);
-        // Look up the daemon-classified entity type, if any.
-        let entityType = null;
-        try {
-            const typeFilter = scopedFilter(scope) ?? { must: [] };
-            typeFilter.must.push({ key: "kind", match: { value: "entity_type" } });
-            typeFilter.must.push({ key: "entity_name", match: { value: entityName } });
-            const typePoints = await qdrantScroll(typeFilter, 1);
-            const typePoint = typePoints.result?.points?.[0];
-            const payload = typePoint?.payload;
-            if (payload?.entity_type) {
-                entityType = String(payload.entity_type);
+        const scopeResolved = resolveSearchScopeOrError({
+            destination,
+            search_scope,
+            input: routingInput({ entities: [entityName] }),
+        });
+        if (scopeResolved.error)
+            return scopeResolved.error;
+        const searchScope = scopeResolved.scope;
+        const effectiveLimit = Math.max(1, Math.trunc(limit ?? 20));
+        const entityTypes = new Map();
+        const factPoints = [];
+        const relationPoints = [];
+        const failures = [];
+        for (const dest of searchScope.destinations) {
+            // Look up the daemon-classified entity type, if any.
+            try {
+                const typeFilter = buildFilter({}) ?? { must: [] };
+                typeFilter.must.push({ key: "kind", match: { value: "entity_type" } });
+                typeFilter.must.push({ key: "entity_name", match: { value: entityName } });
+                const typePoints = await qdrantScroll(dest, typeFilter, 1);
+                const typePoint = typePoints.result?.points?.[0];
+                const payload = typePoint?.payload;
+                if (payload?.entity_type) {
+                    entityTypes.set(dest.name, String(payload.entity_type));
+                }
+            }
+            catch {
+                // Type lookup is best-effort — never fails the request.
+            }
+            try {
+                const factsFilter = buildFilter({}) ?? { must: [] };
+                factsFilter.must.push({ key: "entities", match: { value: entityName } });
+                const facts = await qdrantScroll(dest, factsFilter, effectiveLimit);
+                factPoints.push(...(facts.result?.points ?? []).map((point) => withDestination(point, dest)));
+                const fromFilter = buildFilter({}) ?? { must: [] };
+                fromFilter.must.push({ key: "from_entity", match: { value: entityName } });
+                const relationsFrom = await qdrantScroll(dest, fromFilter, 50);
+                const toFilter = buildFilter({}) ?? { must: [] };
+                toFilter.must.push({ key: "to_entity", match: { value: entityName } });
+                const relationsTo = await qdrantScroll(dest, toFilter, 50);
+                relationPoints.push(...[
+                    ...(relationsFrom.result?.points ?? []),
+                    ...(relationsTo.result?.points ?? []),
+                ].map((point) => withDestination(point, dest)));
+            }
+            catch (e) {
+                failures.push({ destination: dest.name, error: e instanceof Error ? e.message : String(e) });
             }
         }
-        catch {
-            // Type lookup is best-effort — never fails the request.
-        }
-        const factsFilter = scopedFilter(scope) ?? { must: [] };
-        factsFilter.must.push({ key: "entities", match: { value: entityName } });
-        const facts = await qdrantScroll(factsFilter, limit ?? 20);
-        const fromFilter = scopedFilter(scope) ?? { must: [] };
-        fromFilter.must.push({ key: "from_entity", match: { value: entityName } });
-        const relationsFrom = await qdrantScroll(fromFilter, 50);
-        const toFilter = scopedFilter(scope) ?? { must: [] };
-        toFilter.must.push({ key: "to_entity", match: { value: entityName } });
-        const relationsTo = await qdrantScroll(toFilter, 50);
+        if (failures.length === searchScope.destinations.length && searchScope.destinations.length > 0) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            status: "search_failed",
+                            entity: entityName,
+                            search_scope: searchScope.name,
+                            searched_destinations: searchScope.destinations.map((dest) => dest.name),
+                            failed_destinations: failures,
+                        }, null, 2) }],
+                isError: true,
+            };
+        }
         const output = [];
-        const factPoints = facts.result?.points ?? [];
+        const includeDestination = searchScope.destinations.length > 1 || searchScope.name === "all";
+        const entityTypeValues = [...new Set(entityTypes.values())];
+        const entityType = entityTypeValues.length === 1 ? entityTypeValues[0] : null;
         if (factPoints.length > 0) {
             const header = entityType
-                ? `## Facts about ${name} [type: ${entityType}] (${factPoints.length})`
-                : `## Facts about ${name} (${factPoints.length})`;
+                ? `## Facts about ${name} [type: ${entityType}] (${Math.min(factPoints.length, effectiveLimit)})`
+                : `## Facts about ${name} (${Math.min(factPoints.length, effectiveLimit)})`;
             output.push(header);
-            for (const p of factPoints) {
+            for (const p of factPoints.slice(0, effectiveLimit)) {
                 if (p.payload.category !== "relation") {
-                    output.push(`- ${formatFact(p)}`);
+                    output.push(`- ${formatScopedFact(p, includeDestination)}`);
                 }
             }
         }
         else if (entityType) {
             output.push(`## ${name} [type: ${entityType}]`);
         }
-        const allRelations = [
-            ...(relationsFrom.result?.points ?? []),
-            ...(relationsTo.result?.points ?? []),
-        ];
         const seen = new Set();
-        const uniqueRelations = allRelations.filter((r) => {
-            if (seen.has(r.id))
+        const uniqueRelations = relationPoints.filter((r) => {
+            const key = `${r._destination.name}:${r.id}`;
+            if (seen.has(key))
                 return false;
-            seen.add(r.id);
+            seen.add(key);
             return true;
         });
         if (uniqueRelations.length > 0) {
             output.push(`\n## Relations (${uniqueRelations.length})`);
             for (const r of uniqueRelations) {
                 const p = r.payload;
-                output.push(`- ${p.from_entity} --[${p.relation_type}]--> ${p.to_entity}`);
+                const prefix = includeDestination ? `[${r._destination.name}] ` : "";
+                output.push(`- ${prefix}${p.from_entity} --[${p.relation_type}]--> ${p.to_entity}`);
             }
         }
+        if (failures.length > 0) {
+            output.push(`\nSearch warnings: ${failures.map((failure) => `${failure.destination}: ${failure.error}`).join("; ")}`);
+        }
         if (output.length === 0) {
             return { content: [{ type: "text", text: `No facts or relations found for '${name}'.` }] };
         }
@@ -858,47 +1135,85 @@ export function registerTools(mcp) {
         entity: z.string().describe("Entity name to query (case-insensitive)."),
         relation_type: z.string().optional().describe("Filter to a specific edge label (e.g. 'owns', 'uses', 'decided', 'prefers', 'works-on'). Optional."),
         direction: z.enum(["from", "to", "both"]).optional().default("both").describe("Which side of the edge the entity is on. 'from' = entity is the source (X --[?]--> ?). 'to' = entity is the target (? --[?]--> X). 'both' = either (default)."),
-        workspace_id: z.string().optional().describe("Workspace namespace. Omit to use the default from config."),
-        include_legacy_workspace: z.boolean().optional().describe("Backwards-compatibility: also include legacy facts with no workspace_id. Default false."),
-    }, async ({ entity, relation_type, direction, workspace_id, include_legacy_workspace }) => {
+        workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op."),
+        destination: z.string().optional().describe("Optional legacy single-destination override. Do not combine with search_scope."),
+        search_scope: searchScopeSchema.describe("Optional read/search scope. Accepts 'routed', 'all', a destination name, a configured scope name, a comma-separated destination list, or an array of destination names. Omit to use config.default_search_scope."),
+        include_legacy_workspace: z.boolean().optional().describe("[Removed in v0.4.0] No-op."),
+    }, async ({ entity, relation_type, direction, workspace_id: _workspace_id, destination, search_scope, include_legacy_workspace: _include_legacy_workspace }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         const entityName = entity.toLowerCase();
-        const scope = resolveScope(workspace_id, include_legacy_workspace);
+        const scopeResolved = resolveSearchScopeOrError({
+            destination,
+            search_scope,
+            input: routingInput({ entities: [entityName] }),
+        });
+        if (scopeResolved.error)
+            return scopeResolved.error;
+        const searchScope = scopeResolved.scope;
         const results = [];
-        if (direction === "from" || direction === "both") {
-            const filter = scopedFilter(scope) ?? { must: [] };
-            filter.must.push({ key: "from_entity", match: { value: entityName } });
-            if (relation_type) {
-                filter.must.push({ key: "relation_type", match: { value: relation_type.toLowerCase() } });
+        const failures = [];
+        for (const dest of searchScope.destinations) {
+            try {
+                if (direction === "from" || direction === "both") {
+                    const filter = buildFilter({}) ?? { must: [] };
+                    filter.must.push({ key: "from_entity", match: { value: entityName } });
+                    if (relation_type) {
+                        filter.must.push({ key: "relation_type", match: { value: relation_type.toLowerCase() } });
+                    }
+                    const r = await qdrantScroll(dest, filter, 50);
+                    results.push(...(r.result?.points ?? []).map((point) => withDestination(point, dest)));
+                }
+                if (direction === "to" || direction === "both") {
+                    const filter = buildFilter({}) ?? { must: [] };
+                    filter.must.push({ key: "to_entity", match: { value: entityName } });
+                    if (relation_type) {
+                        filter.must.push({ key: "relation_type", match: { value: relation_type.toLowerCase() } });
+                    }
+                    const r = await qdrantScroll(dest, filter, 50);
+                    results.push(...(r.result?.points ?? []).map((point) => withDestination(point, dest)));
+                }
             }
-            const r = await qdrantScroll(filter, 50);
-            results.push(...(r.result?.points ?? []));
-        }
-        if (direction === "to" || direction === "both") {
-            const filter = scopedFilter(scope) ?? { must: [] };
-            filter.must.push({ key: "to_entity", match: { value: entityName } });
-            if (relation_type) {
-                filter.must.push({ key: "relation_type", match: { value: relation_type.toLowerCase() } });
+            catch (e) {
+                failures.push({ destination: dest.name, error: e instanceof Error ? e.message : String(e) });
             }
-            const r = await qdrantScroll(filter, 50);
-            results.push(...(r.result?.points ?? []));
+        }
+        if (failures.length === searchScope.destinations.length && searchScope.destinations.length > 0) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({
+                            status: "search_failed",
+                            entity: entityName,
+                            search_scope: searchScope.name,
+                            searched_destinations: searchScope.destinations.map((dest) => dest.name),
+                            failed_destinations: failures,
+                        }, null, 2) }],
+                isError: true,
+            };
         }
         const seen = new Set();
         const unique = results.filter((r) => {
-            if (seen.has(r.id))
+            const key = `${r._destination.name}:${r.id}`;
+            if (seen.has(key))
                 return false;
-            seen.add(r.id);
+            seen.add(key);
             return true;
         });
         if (unique.length === 0) {
-            return { content: [{ type: "text", text: `No relations found for '${entity}'.` }] };
+            const warning = failures.length > 0
+                ? ` Search warnings: ${failures.map((failure) => `${failure.destination}: ${failure.error}`).join("; ")}`
+                : "";
+            return { content: [{ type: "text", text: `No relations found for '${entity}'.${warning}` }] };
         }
+        const includeDestination = searchScope.destinations.length > 1 || searchScope.name === "all";
         const lines = unique.map((r) => {
             const p = r.payload;
-            return `${p.from_entity} --[${p.relation_type}]--> ${p.to_entity} (confidence: ${p.confidence}, id: ${r.id})`;
+            const prefix = includeDestination ? `[${r._destination.name}] ` : "";
+            return `${prefix}${p.from_entity} --[${p.relation_type}]--> ${p.to_entity} (confidence: ${p.confidence}, id: ${r.id})`;
         });
+        if (failures.length > 0) {
+            lines.push("", `Search warnings: ${failures.map((failure) => `${failure.destination}: ${failure.error}`).join("; ")}`);
+        }
         return { content: [{ type: "text", text: lines.join("\n") }] };
     });
     // ── memory_forget ───────────────────────────────────────────────────────
@@ -908,21 +1223,19 @@ export function registerTools(mcp) {
     ].join(" "), {
         fact_id: z.string().describe("ID of the fact to forget (returned by memory_store / memory_recall as 'id')."),
         reason: z.string().describe("Short human-readable reason this fact is being retired (stored in 'superseded_by' for future audit)."),
-        workspace_id: z.string().optional().describe("Workspace namespace. Omit to use the default from config."),
-    }, async ({ fact_id, reason, workspace_id }) => {
+        workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op."),
+    }, async ({ fact_id, reason, workspace_id: _workspace_id }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         const now = nowISO();
         try {
-            const scope = resolveScope(workspace_id);
-            const _actor = resolveActorIdentity({ config: loadConfig() });
-            const existing = await getPointForWorkspaceWrite(fact_id, scope);
-            if (existing.error) {
-                return { content: [{ type: "text", text: JSON.stringify(existing.error, null, 2) }], isError: true };
-            }
+            const located = await locatePoint(fact_id);
+            if (!located)
+                return notFoundResult(fact_id);
+            const { dest } = located;
             const redactedReason = redactStorageText(reason);
-            await qdrantSetPayload([fact_id], {
+            await qdrantSetPayload(dest, [fact_id], {
                 superseded_by: `forgotten:${redactedReason.text}`,
                 superseded_at: now,
                 updated_at: now,
@@ -937,6 +1250,7 @@ export function registerTools(mcp) {
             return { content: [{ type: "text", text: JSON.stringify({
                             status: "forgotten",
                             fact_id,
+                            destination: dest.name,
                             reason: redactedReason.text,
                             ...(redactedReason.redacted ? { redaction: redactedReason } : {}),
                         }) }] };
@@ -952,26 +1266,20 @@ export function registerTools(mcp) {
         "If the fact is no longer true, use memory_forget or memory_store(supersedes:) instead.",
     ].join(" "), {
         fact_id: z.string().describe("ID of the fact to verify (from memory_recall or memory_heartbeat)."),
-        workspace_id: z.string().optional().describe("Workspace namespace. Omit to use the default from config."),
-    }, async ({ fact_id, workspace_id }) => {
+        workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op."),
+    }, async ({ fact_id, workspace_id: _workspace_id }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         const now = nowISO();
         try {
-            const scope = resolveScope(workspace_id);
-            const _actor = resolveActorIdentity({ config: loadConfig() });
-            const writable = await getPointForWorkspaceWrite(fact_id, scope);
-            if (writable.error) {
-                return { content: [{ type: "text", text: JSON.stringify(writable.error, null, 2) }], isError: true };
-            }
-            let currentCount = 0;
-            const existingPt = writable.point;
-            if (existingPt) {
-                currentCount = existingPt.payload.verification_count ?? 0;
-            }
+            const located = await locatePoint(fact_id);
+            if (!located)
+                return notFoundResult(fact_id);
+            const { dest, point } = located;
+            const currentCount = point.payload.verification_count ?? 0;
             const newCount = currentCount + 1;
-            await qdrantSetPayload([fact_id], {
+            await qdrantSetPayload(dest, [fact_id], {
                 last_verified_at: now,
                 last_reinforced_at: now,
                 verification_count: newCount,
@@ -981,6 +1289,7 @@ export function registerTools(mcp) {
                 content: [{ type: "text", text: JSON.stringify({
                             status: "verified",
                             fact_id,
+                            destination: dest.name,
                             verification_count: newCount,
                             message: "Fact confirmed as still accurate. Staleness clock reset.",
                         }) }],
@@ -998,23 +1307,21 @@ export function registerTools(mcp) {
     ].join(" "), {
         fact_id: z.string().describe("ID of the fact that was useful (from memory_recall or memory_entity)."),
         note: z.string().optional().describe("Optional short note about how the fact was useful (e.g. 'unblocked auth debug'). Stored on the telemetry event for future analysis."),
-        workspace_id: z.string().optional().describe("Workspace namespace. Omit to use the default from config."),
-    }, async ({ fact_id, note, workspace_id }) => {
+        workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op."),
+    }, async ({ fact_id, note, workspace_id: _workspace_id }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         const now = nowISO();
         try {
-            const scope = resolveScope(workspace_id);
+            const located = await locatePoint(fact_id);
+            if (!located)
+                return notFoundResult(fact_id);
+            const { dest, point } = located;
             const actor = resolveActorIdentity({ config: loadConfig() });
-            const writable = await getPointForWorkspaceWrite(fact_id, scope);
-            if (writable.error) {
-                return { content: [{ type: "text", text: JSON.stringify(writable.error, null, 2) }], isError: true };
-            }
-            const existingPt = writable.point;
-            const currentCount = existingPt?.payload.useful_count ?? 0;
+            const currentCount = point.payload.useful_count ?? 0;
             const newCount = currentCount + 1;
-            await qdrantSetPayload([fact_id], {
+            await qdrantSetPayload(dest, [fact_id], {
                 useful_count: newCount,
                 last_useful_at: now,
                 updated_at: now,
@@ -1043,11 +1350,11 @@ export function registerTools(mcp) {
                 created_at: now,
                 updated_at: now,
             };
-            addWorkspacePayload(eventPayload, scope, actor);
+            addActorPayload(eventPayload, actor);
             addRedactionPayload(eventPayload, redactedEvent);
             try {
                 const eventVector = await embed(redactedEvent.text);
-                await qdrantUpsert(eventId, eventVector, eventPayload);
+                await qdrantUpsert(dest, eventId, eventVector, eventPayload);
             }
             catch (e) {
                 log("WARN", `Failed to record feedback_event: ${e instanceof Error ? e.message : String(e)}`);
@@ -1056,6 +1363,7 @@ export function registerTools(mcp) {
                 content: [{ type: "text", text: JSON.stringify({
                             status: "marked_useful",
                             fact_id,
+                            destination: dest.name,
                             useful_count: newCount,
                             event_id: eventId,
                         }) }],
@@ -1074,19 +1382,18 @@ export function registerTools(mcp) {
         fact_id: z.string().describe("ID of the fact whose outcome you are reporting."),
         outcome: z.enum(["useful", "misleading", "irrelevant", "wrong"]).describe("How the fact actually played out. 'useful' = helped you finish the task; 'misleading' = sent you the wrong way; 'irrelevant' = semantically matched but didn't help; 'wrong' = factually incorrect."),
         notes: z.string().optional().describe("Optional short context for the outcome (e.g. 'API moved in v2', 'wrong port number'). Stored on the telemetry event for future analysis."),
-        workspace_id: z.string().optional().describe("Workspace namespace. Omit to use the default from config."),
-    }, async ({ fact_id, outcome, notes, workspace_id }) => {
+        workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op."),
+    }, async ({ fact_id, outcome, notes, workspace_id: _workspace_id }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         const now = nowISO();
         try {
-            const scope = resolveScope(workspace_id);
+            const located = await locatePoint(fact_id);
+            if (!located)
+                return notFoundResult(fact_id);
+            const { dest } = located;
             const actor = resolveActorIdentity({ config: loadConfig() });
-            const target = await getPointForWorkspaceWrite(fact_id, scope);
-            if (target.error) {
-                return { content: [{ type: "text", text: JSON.stringify(target.error, null, 2) }], isError: true };
-            }
             const eventId = newId();
             const eventContent = notes
                 ? `Fact ${fact_id} outcome=${outcome}: ${notes}`
@@ -1109,14 +1416,15 @@ export function registerTools(mcp) {
                 created_at: now,
                 updated_at: now,
             };
-            addWorkspacePayload(eventPayload, scope, actor);
+            addActorPayload(eventPayload, actor);
             addRedactionPayload(eventPayload, redactedEvent);
             const eventVector = await embed(redactedEvent.text);
-            await qdrantUpsert(eventId, eventVector, eventPayload);
+            await qdrantUpsert(dest, eventId, eventVector, eventPayload);
             return {
                 content: [{ type: "text", text: JSON.stringify({
                             status: "outcome_recorded",
                             fact_id,
+                            destination: dest.name,
                             outcome,
                             event_id: eventId,
                         }) }],
@@ -1138,16 +1446,24 @@ export function registerTools(mcp) {
         workstream_key: z.string().optional().describe("Durable continuity key for a long-running objective (survives across sessions)."),
         task_key: z.string().optional().describe("Task or issue key (e.g. GitHub issue number, JIRA key)."),
         repo: z.string().optional().describe("Repository or project surface this summary relates to."),
-        workspace_id: z.string().optional().describe("Workspace namespace. Omit to use the default from config."),
+        workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op."),
+        destination: z.string().optional().describe("Optional destination override. Omit to let routing rules decide."),
         actor_id: z.string().optional().describe("Stable actor identity associated with this session summary. Overrides identity config/env/Git fallback."),
-    }, async ({ content, entities, episode_id, workstream_key, task_key, repo, workspace_id, actor_id }) => {
+    }, async ({ content, entities, episode_id, workstream_key, task_key, repo, workspace_id: _workspace_id, destination, actor_id }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         lastStoreTime = Date.now();
         const now = nowISO();
         try {
-            const scope = resolveScope(workspace_id);
+            const resolved = resolveDestOrError(routingInput({
+                destination,
+                content,
+                entities: entities ?? [],
+            }));
+            if (resolved.error)
+                return resolved.error;
+            const dest = resolved.dest;
             const actor = resolveActorIdentity({ actorId: actor_id, config: loadConfig() });
             const normalizedEntities = (entities ?? []).map((e) => e.trim().toLowerCase()).filter(Boolean);
             const summaryId = newId();
@@ -1180,14 +1496,14 @@ export function registerTools(mcp) {
                 payload["task_key"] = task_key;
             if (repo)
                 payload["repo"] = repo;
-            addWorkspacePayload(payload, scope, actor);
+            addActorPayload(payload, actor);
             addRedactionPayload(payload, redactedContent);
-            await qdrantUpsert(summaryId, vector, payload);
+            await qdrantUpsert(dest, summaryId, vector, payload);
             return {
                 content: [{ type: "text", text: JSON.stringify({
                             status: "summary_stored",
                             summary_id: summaryId,
-                            workspace_id: scope.workspaceId,
+                            destination: dest.name,
                             actor_id: actor.actor_id,
                         }) }],
             };
@@ -1207,27 +1523,35 @@ export function registerTools(mcp) {
         supersedes: z.string().optional().describe("ID of an earlier distilled fact that this one replaces. Old fact is marked superseded and excluded from recall."),
         task_key: z.string().optional().describe("Task or issue key associated with this learning, if relevant."),
         repo: z.string().optional().describe("Repository or project surface this learning applies to."),
-        workspace_id: z.string().optional().describe("Workspace namespace. Omit to use the default from config."),
+        workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op."),
+        destination: z.string().optional().describe("Optional destination override. Omit to let routing rules decide."),
         actor_id: z.string().optional().describe("Stable actor identity associated with this distillation. Overrides identity config/env/Git fallback."),
-    }, async ({ content, entities, supersedes, task_key, repo, workspace_id, actor_id }) => {
+    }, async ({ content, entities, supersedes, task_key, repo, workspace_id: _workspace_id, destination, actor_id }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         lastStoreTime = Date.now();
         const now = nowISO();
         try {
-            const scope = resolveScope(workspace_id);
+            const resolved = resolveDestOrError(routingInput({
+                destination,
+                content,
+                entities,
+            }));
+            if (resolved.error)
+                return resolved.error;
+            const dest = resolved.dest;
             const actor = resolveActorIdentity({ actorId: actor_id, config: loadConfig() });
             const normalizedEntities = entities.map((e) => e.trim().toLowerCase()).filter(Boolean);
             const distilledId = newId();
             const redactedContent = redactStorageText(content);
             const vector = await embed(redactedContent.text);
             if (supersedes) {
-                const existing = await getPointForWorkspaceWrite(supersedes, scope);
-                if (existing.error) {
-                    return { content: [{ type: "text", text: JSON.stringify(existing.error, null, 2) }], isError: true };
-                }
-                await qdrantSetPayload([supersedes], {
+                // Supersede may live in a different destination — locate it.
+                const located = await locatePoint(supersedes);
+                if (!located)
+                    return notFoundResult(supersedes);
+                await qdrantSetPayload(located.dest, [supersedes], {
                     superseded_by: distilledId,
                     superseded_at: now,
                 });
@@ -1255,15 +1579,15 @@ export function registerTools(mcp) {
                 payload["task_key"] = task_key;
             if (repo)
                 payload["repo"] = repo;
-            addWorkspacePayload(payload, scope, actor);
+            addActorPayload(payload, actor);
             addRedactionPayload(payload, redactedContent);
-            await qdrantUpsert(distilledId, vector, payload);
+            await qdrantUpsert(dest, distilledId, vector, payload);
             return {
                 content: [{ type: "text", text: JSON.stringify({
                             status: "distilled_stored",
                             distilled_id: distilledId,
+                            destination: dest.name,
                             supersedes: supersedes ?? null,
-                            workspace_id: scope.workspaceId,
                             actor_id: actor.actor_id,
                         }) }],
             };
@@ -1282,26 +1606,37 @@ export function registerTools(mcp) {
         fact_id: z.string().optional().describe("Fact ID to act on. Required for approve / reject / correct."),
         reason: z.string().optional().describe("Required for action=reject. Short reason the fact is wrong."),
         corrected_content: z.string().optional().describe("Required for action=correct. The fixed fact text. Stored as a new fact that supersedes the original."),
-        workspace_id: z.string().optional().describe("Workspace namespace. Omit to use the default from config."),
-        include_legacy_workspace: z.boolean().optional().describe("Backwards-compatibility: also include legacy facts with no workspace_id. Default false."),
-    }, async ({ limit, action, fact_id, reason, corrected_content, workspace_id, include_legacy_workspace }) => {
+        workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op."),
+        include_legacy_workspace: z.boolean().optional().describe("[Removed in v0.4.0] No-op."),
+    }, async ({ limit, action, fact_id, reason, corrected_content, workspace_id: _workspace_id, include_legacy_workspace: _include_legacy_workspace }) => {
         const guard = requireReady();
         if (guard)
             return guard;
-        const scope = resolveScope(workspace_id, include_legacy_workspace);
         if (action === "list") {
-            const filter = scopedFilter(scope) ?? { must: [] };
-            filter.must.push({ key: "source", match: { any: ["system", "daemon"] } });
-            const result = await qdrantScroll(filter, (limit ?? 10) * 2);
-            const points = (result.result?.points ?? [])
-                .sort((a, b) => (b.payload.created_at ?? "").localeCompare(a.payload.created_at ?? ""))
+            // List spans all destinations.
+            const destinations = listDestinations();
+            const allPoints = [];
+            const filter = { must: [{ key: "source", match: { any: ["system", "daemon"] } }] };
+            for (const dest of destinations) {
+                try {
+                    const result = await qdrantScroll(dest, filter, (limit ?? 10) * 2);
+                    const points = result.result?.points ?? [];
+                    for (const pt of points)
+                        allPoints.push({ dest: dest.name, point: pt });
+                }
+                catch (e) {
+                    log("WARN", `memory_review list scroll failed on ${dest.name}: ${e instanceof Error ? e.message : String(e)}`);
+                }
+            }
+            const sorted = allPoints
+                .sort((a, b) => (b.point.payload.created_at ?? "").localeCompare(a.point.payload.created_at ?? ""))
                 .slice(0, limit ?? 10);
-            if (points.length === 0) {
+            if (sorted.length === 0) {
                 return { content: [{ type: "text", text: "No system-captured facts found." }] };
             }
-            const lines = points.map((pt) => {
+            const lines = sorted.map(({ dest, point: pt }) => {
                 const p = pt.payload;
-                return `[${p.category}] ${p.content}\n  id: ${pt.id} | confidence: ${p.confidence} | importance: ${p.importance} | entities: ${(p.entities ?? []).join(", ")} | created: ${p.created_at}`;
+                return `[${p.category}] ${p.content}\n  id: ${pt.id} | dest: ${dest} | confidence: ${p.confidence} | importance: ${p.importance} | entities: ${(p.entities ?? []).join(", ")} | created: ${p.created_at}`;
             });
             return { content: [{ type: "text", text: lines.join("\n\n") }] };
         }
@@ -1310,32 +1645,28 @@ export function registerTools(mcp) {
         }
         const now = nowISO();
         if (action === "approve") {
-            const writable = await getPointForWorkspaceWrite(fact_id, scope);
-            if (writable.error) {
-                return { content: [{ type: "text", text: JSON.stringify(writable.error, null, 2) }], isError: true };
-            }
-            let currentCount = 0;
-            const approvePt = writable.point;
-            if (approvePt) {
-                currentCount = approvePt.payload.verification_count ?? 0;
-            }
-            await qdrantSetPayload([fact_id], {
+            const located = await locatePoint(fact_id);
+            if (!located)
+                return notFoundResult(fact_id);
+            const { dest, point } = located;
+            const currentCount = point.payload.verification_count ?? 0;
+            await qdrantSetPayload(dest, [fact_id], {
                 last_verified_at: now,
                 verification_count: currentCount + 1,
                 updated_at: now,
             });
-            return { content: [{ type: "text", text: JSON.stringify({ status: "approved", fact_id }) }] };
+            return { content: [{ type: "text", text: JSON.stringify({ status: "approved", fact_id, destination: dest.name }) }] };
         }
         if (action === "reject") {
             if (!reason) {
                 return { content: [{ type: "text", text: "Error: reason is required for reject action." }] };
             }
-            const writable = await getPointForWorkspaceWrite(fact_id, scope);
-            if (writable.error) {
-                return { content: [{ type: "text", text: JSON.stringify(writable.error, null, 2) }], isError: true };
-            }
+            const located = await locatePoint(fact_id);
+            if (!located)
+                return notFoundResult(fact_id);
+            const { dest } = located;
             const redactedReason = redactStorageText(reason);
-            await qdrantSetPayload([fact_id], {
+            await qdrantSetPayload(dest, [fact_id], {
                 superseded_by: `rejected:${redactedReason.text}`,
                 superseded_at: now,
                 updated_at: now,
@@ -1343,6 +1674,7 @@ export function registerTools(mcp) {
             return { content: [{ type: "text", text: JSON.stringify({
                             status: "rejected",
                             fact_id,
+                            destination: dest.name,
                             reason: redactedReason.text,
                             ...(redactedReason.redacted ? { redaction: redactedReason } : {}),
                         }) }] };
@@ -1351,15 +1683,12 @@ export function registerTools(mcp) {
             if (!corrected_content) {
                 return { content: [{ type: "text", text: "Error: corrected_content is required for correct action." }] };
             }
-            const writable = await getPointForWorkspaceWrite(fact_id, scope);
-            if (writable.error) {
-                return { content: [{ type: "text", text: JSON.stringify(writable.error, null, 2) }], isError: true };
-            }
-            const origPayload = writable.point?.payload;
+            const located = await locatePoint(fact_id);
+            if (!located)
+                return notFoundResult(fact_id);
+            const { dest, point } = located;
+            const origPayload = point.payload;
             const redactedCorrected = redactStorageText(corrected_content);
-            const correctionScope = origPayload?.workspace_id
-                ? resolveScope(origPayload.workspace_id, false)
-                : scope;
             const actor = resolveActorIdentity({ config: loadConfig() });
             const vector = await embed(redactedCorrected.text);
             const correctedId = crypto.randomUUID();
@@ -1390,15 +1719,15 @@ export function registerTools(mcp) {
                 updated_at: now,
                 metadata: { ...(origPayload?.metadata ?? {}), corrected_from: fact_id },
             };
-            addWorkspacePayload(correctedPayload, correctionScope, actor);
+            addActorPayload(correctedPayload, actor);
             addRedactionPayload(correctedPayload, redactedCorrected);
-            await qdrantUpsert(correctedId, vector, correctedPayload);
-            await qdrantSetPayload([fact_id], {
+            await qdrantUpsert(dest, correctedId, vector, correctedPayload);
+            await qdrantSetPayload(dest, [fact_id], {
                 superseded_by: correctedId,
                 superseded_at: now,
                 updated_at: now,
             });
-            return { content: [{ type: "text", text: JSON.stringify({ status: "corrected", old_fact_id: fact_id, new_fact_id: correctedId }) }] };
+            return { content: [{ type: "text", text: JSON.stringify({ status: "corrected", old_fact_id: fact_id, new_fact_id: correctedId, destination: dest.name }) }] };
         }
         return { content: [{ type: "text", text: `Unknown action: ${String(action)}` }] };
     });
@@ -1415,8 +1744,7 @@ export function registerTools(mcp) {
         if (heartbeatCount % 3 === 0 && ready) {
             try {
                 const staleThreshold = new Date(Date.now() - STALENESS_DAYS * 86400000).toISOString();
-                const scope = resolveScope();
-                const staleFilter = scopedFilter(scope) ?? { must: [] };
+                const staleFilter = { must: [] };
                 staleFilter.must.push({ key: "category", match: { any: ["engineering", "product", "human", "system"] } });
                 staleFilter.should = [
                     { key: "last_reinforced_at", range: { lte: staleThreshold } },
@@ -1425,10 +1753,24 @@ export function registerTools(mcp) {
                 staleFilter.must_not = [
                     { key: "last_verified_at", range: { gte: staleThreshold } },
                 ];
-                const staleResults = await qdrantScroll(staleFilter, 3);
-                const staleFacts = staleResults.result?.points ?? [];
-                if (staleFacts.length > 0) {
-                    const staleLines = staleFacts.map((f) => {
+                // Aggregate stale facts across all destinations.
+                const staleFacts = [];
+                for (const dest of listDestinations()) {
+                    try {
+                        const r = await qdrantScroll(dest, staleFilter, 3);
+                        const pts = r.result?.points ?? [];
+                        for (const pt of pts)
+                            staleFacts.push(pt);
+                        if (staleFacts.length >= 3)
+                            break;
+                    }
+                    catch (e) {
+                        log("WARN", `Staleness check failed on ${dest.name}: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                }
+                const trimmed = staleFacts.slice(0, 3);
+                if (trimmed.length > 0) {
+                    const staleLines = trimmed.map((f) => {
                         const d = Math.round(daysSince(lastActivityDate(f.payload)));
                         return `  • [${f.payload.category}] ${f.payload.content} (${d}d old, id: ${f.id})`;
                     });