bikky 0.3.12 → 0.4.0

package/dist/mcp/tools.js

@@ -5,7 +5,8 @@ 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 { existsSync, readFileSync } from "node:fs";
 import { inspectWatcherPaths, formatIssue, repairSuspiciousWatcherPaths } from "../daemon/watcher-health.js";
@@ -28,32 +29,48 @@ 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 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 +83,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 +118,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 +155,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 +169,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 +191,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 +218,51 @@ 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 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,
+                connected: false,
+                collection_exists: false,
+            };
             try {
-                await qdrantReq("GET", "/collections");
-                status["qdrant_connected"] = true;
+                await qdrantReq(d, "GET", "/collections");
+                block["connected"] = true;
+            }
+            catch (e) {
+                block["last_error"] = e instanceof Error ? e.message : String(e);
+            }
+            try {
+                await qdrantReq(d, "GET", `/collections/${d.collection}`);
+                block["collection_exists"] = true;
             }
             catch { /* ignore */ }
+            destStatus.push(block);
         }
+        status["destinations"] = destStatus;
         try {
             await embed("test");
             status["embedding_connected"] = true;
@@ -283,12 +330,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 +346,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 +371,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 +381,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 +413,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 +433,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 +452,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 +512,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 +543,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 +604,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 +656,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 +685,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;
@@ -653,9 +726,10 @@ 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 destination override. When set, queries that destination by name. Hard-errors if no such destination exists. Omit to let routing rules decide."),
         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 +743,22 @@ 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, 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 resolved = resolveDestOrError(routingInput({
+            destination,
+            content: query,
+            entities: entity ? [entity] : [],
+            metadata: metadata_filter,
+        }));
+        if (resolved.error)
+            return resolved.error;
+        const dest = resolved.dest;
         const redactedQuery = redactStorageText(query);
         const vector = await embed(redactedQuery.text);
         const normalizedKind = kind ? normalizeKind(kind) : undefined;
@@ -692,11 +774,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,7 +792,7 @@ export function registerTools(mcp) {
             metadata: metadata_filter,
             excludeKinds: MEMORY_RECALL_EXCLUDED_KINDS,
         });
-        const results = await qdrantSearch(vector, filter, effectiveLimit * 2);
+        const results = await qdrantSearch(dest, vector, filter, effectiveLimit * 2);
         if (!results.result?.length) {
             const nudge = buildMemoryNudge();
             if (output_format === "json") {
@@ -738,7 +821,7 @@ export function registerTools(mcp) {
         const lines = ranked.map((r) => formatFact(r));
         let related = { points: [] };
         if ((graph_depth ?? 0) >= 1) {
-            related = await graphTraversal(ranked, effectiveLimit, scope);
+            related = await graphTraversal(dest, ranked, effectiveLimit);
             if (related.points.length > 0) {
                 lines.push("", "── Related (1-hop) ──");
                 lines.push(...related.points.map((r) => formatFact(r)));
@@ -777,21 +860,25 @@ 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 destination override. Omit to let routing rules decide."),
+        include_legacy_workspace: z.boolean().optional().describe("[Removed in v0.4.0] No-op."),
+    }, async ({ name, limit, workspace_id: _workspace_id, destination, 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);
+        const resolved = resolveDestOrError(routingInput({ destination, entities: [entityName] }));
+        if (resolved.error)
+            return resolved.error;
+        const dest = resolved.dest;
         // Look up the daemon-classified entity type, if any.
         let entityType = null;
         try {
-            const typeFilter = scopedFilter(scope) ?? { must: [] };
+            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(typeFilter, 1);
+            const typePoints = await qdrantScroll(dest, typeFilter, 1);
             const typePoint = typePoints.result?.points?.[0];
             const payload = typePoint?.payload;
             if (payload?.entity_type) {
@@ -801,15 +888,15 @@ export function registerTools(mcp) {
         catch {
             // Type lookup is best-effort — never fails the request.
         }
-        const factsFilter = scopedFilter(scope) ?? { must: [] };
+        const factsFilter = buildFilter({}) ?? { must: [] };
         factsFilter.must.push({ key: "entities", match: { value: entityName } });
-        const facts = await qdrantScroll(factsFilter, limit ?? 20);
-        const fromFilter = scopedFilter(scope) ?? { must: [] };
+        const facts = await qdrantScroll(dest, factsFilter, limit ?? 20);
+        const fromFilter = buildFilter({}) ?? { must: [] };
         fromFilter.must.push({ key: "from_entity", match: { value: entityName } });
-        const relationsFrom = await qdrantScroll(fromFilter, 50);
-        const toFilter = scopedFilter(scope) ?? { must: [] };
+        const relationsFrom = await qdrantScroll(dest, fromFilter, 50);
+        const toFilter = buildFilter({}) ?? { must: [] };
         toFilter.must.push({ key: "to_entity", match: { value: entityName } });
-        const relationsTo = await qdrantScroll(toFilter, 50);
+        const relationsTo = await qdrantScroll(dest, toFilter, 50);
         const output = [];
         const factPoints = facts.result?.points ?? [];
         if (factPoints.length > 0) {
@@ -858,31 +945,35 @@ 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 destination override. Omit to let routing rules decide."),
+        include_legacy_workspace: z.boolean().optional().describe("[Removed in v0.4.0] No-op."),
+    }, async ({ entity, relation_type, direction, workspace_id: _workspace_id, destination, 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 resolved = resolveDestOrError(routingInput({ destination, entities: [entityName] }));
+        if (resolved.error)
+            return resolved.error;
+        const dest = resolved.dest;
         const results = [];
         if (direction === "from" || direction === "both") {
-            const filter = scopedFilter(scope) ?? { must: [] };
+            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(filter, 50);
+            const r = await qdrantScroll(dest, filter, 50);
             results.push(...(r.result?.points ?? []));
         }
         if (direction === "to" || direction === "both") {
-            const filter = scopedFilter(scope) ?? { must: [] };
+            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(filter, 50);
+            const r = await qdrantScroll(dest, filter, 50);
             results.push(...(r.result?.points ?? []));
         }
         const seen = new Set();
@@ -908,21 +999,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 +1026,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 +1042,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 +1065,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 +1083,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 +1126,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 +1139,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 +1158,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 +1192,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 +1222,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 +1272,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 +1299,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 +1355,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 +1382,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 +1421,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 +1450,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 +1459,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 +1495,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 +1520,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 +1529,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})`;
                     });