bikky 0.4.1 → 0.4.3

package/dist/daemon/qdrant.js

@@ -8,35 +8,84 @@
  * self-hosted instances.
  */
 import { createHash, randomUUID } from "node:crypto";
-import { loadConfig } from "../config.js";
+import { getEffectiveDestinations, loadConfig } from "../config.js";
 import { embed, initEmbedding, getEmbeddingConfig } from "../llm/index.js";
-import { QdrantClient } from "../lib/qdrant-client.js";
-import { DEFAULT_DOMAIN, QDRANT_INDEXES, categoryForMemorySubtype, layerForMemorySubtype, normalizeCategory, normalizeDomain, normalizeKind, normalizeSource, validateMemorySubtype, } from "../mcp/taxonomy.js";
+import { QdrantPool } from "../lib/qdrant-pool.js";
+import { buildResolver } from "../routing.js";
+import { DEFAULT_DOMAIN, QDRANT_INDEXES, categoryForMemorySubtype, layerForMemorySubtype, normalizeCategory, normalizeDomain, normalizeKind, validateMemorySubtype, } from "../mcp/taxonomy.js";
 import { combineRedactions, redactStorageText, } from "../privacy/redaction.js";
+import { buildOperationOrigin } from "../provenance/origin.js";
 // ---------------------------------------------------------------------------
 // State
 // ---------------------------------------------------------------------------
-let qdrantUrl = null;
-let qdrantApiKey = null;
 let collection = "bikky";
 let logFn = () => { };
-let client = null;
+let destinations = [];
+let pool = null;
+let resolver = null;
 const setLogger = (fn) => { logFn = fn; };
 const setEmbeddingConfig = (overrides) => {
     if (overrides && overrides.provider)
         initEmbedding(overrides);
 };
 const clientLogAdapter = (level, msg) => logFn(level, msg);
+const fallbackDestination = () => {
+    if (destinations.length === 0) {
+        throw new Error("Qdrant client not initialized — call init() first");
+    }
+    return destinations.find((destination) => destination.default === true) ?? destinations[0];
+};
+const resolveDestination = (input = {}) => {
+    if (!resolver)
+        return fallbackDestination();
+    return resolver(input);
+};
+const destinationFromRef = (ref) => {
+    if (!ref)
+        return fallbackDestination();
+    if (typeof ref !== "string")
+        return ref;
+    const found = destinations.find((destination) => destination.name === ref);
+    if (!found) {
+        throw new Error(`Unknown Qdrant destination '${ref}'. Configured destinations: ${destinations.map((d) => d.name).join(", ") || "(none)"}`);
+    }
+    return found;
+};
+const pathForDestination = (urlPath, destination) => {
+    if (!urlPath.startsWith("/collections/"))
+        return urlPath;
+    return urlPath.replace(/^\/collections\/[^/]+/, `/collections/${destination.collection}`);
+};
+const routingInputForFact = (fact, normalizedContent, normalizedEntities, extraMetadata = {}) => ({
+    content: normalizedContent,
+    entities: normalizedEntities,
+    metadata: {
+        ...(fact.metadata ?? {}),
+        ...extraMetadata,
+        category: fact.category,
+        domain: fact.domain ?? DEFAULT_DOMAIN,
+        kind: fact.kind ?? "fact",
+        ...(fact.memory_subtype ? { memory_subtype: fact.memory_subtype } : {}),
+        ...(fact.source ? { source: fact.source } : {}),
+        ...(fact.actor_id ? { actor_id: fact.actor_id } : {}),
+        ...(fact.session_id ? { session_id: fact.session_id } : {}),
+        ...(fact.episode_id ? { episode_id: fact.episode_id } : {}),
+        ...(fact.workstream_key ? { workstream_key: fact.workstream_key } : {}),
+        ...(fact.task_key ? { task_key: fact.task_key } : {}),
+        ...(fact.repo ? { repo: fact.repo } : {}),
+        ...(fact.branch ? { branch: fact.branch } : {}),
+        ...(fact.surface ? { surface: fact.surface } : {}),
+    },
+});
 // ---------------------------------------------------------------------------
 // Init — reads credentials from loadConfig()
 // ---------------------------------------------------------------------------
 const init = () => {
     const cfg = loadConfig();
-    qdrantUrl = cfg.qdrant_url;
-    qdrantApiKey = cfg.qdrant_api_key;
-    collection = cfg.collection || "bikky";
-    if (qdrantUrl)
-        qdrantUrl = qdrantUrl.replace(/\/+$/, "");
+    destinations = getEffectiveDestinations(cfg);
+    collection = (destinations.find((destination) => destination.default === true) ?? destinations[0])?.collection
+        ?? cfg.collection
+        ?? "bikky";
     // Initialize embedding provider from config
     const embCfg = initEmbedding({
         provider: cfg.embedding.provider,
@@ -50,48 +99,72 @@ const init = () => {
         retryBaseDelayMs: cfg.embedding.retry_base_delay_ms,
     });
     logFn("INFO", `Embedding provider: ${embCfg.provider}/${embCfg.model} (${embCfg.dimensions}d) @ ${embCfg.baseUrl}`);
-    const ready = !!qdrantUrl;
+    const ready = destinations.length > 0;
     if (ready) {
-        client = new QdrantClient({
-            url: qdrantUrl,
-            apiKey: qdrantApiKey,
-            collection,
-            timeoutMs: cfg.qdrant_client.timeout_ms,
-            retries: cfg.qdrant_client.retries,
-            retryBaseDelayMs: cfg.qdrant_client.retry_base_delay_ms,
+        pool = new QdrantPool(destinations, {
+            client: cfg.qdrant_client,
             log: clientLogAdapter,
         });
+        resolver = buildResolver(destinations);
+        logFn("INFO", `Qdrant destinations: ${destinations.map((destination) => `${destination.name}/${destination.collection}`).join(", ")}`);
     }
     else {
-        client = null;
+        pool = null;
+        resolver = null;
         logFn("WARN", "Qdrant client: missing URL (some memory features disabled)");
     }
     return ready;
 };
-const isReady = () => !!(qdrantUrl && client);
+const isReady = () => !!(pool && destinations.length > 0);
 const ensureCollection = async () => {
-    if (!client) {
+    if (!pool) {
         throw new Error("Qdrant client not initialized — call init() first");
     }
     const embCfg = getEmbeddingConfig();
-    await client.ensureCollection(embCfg.dimensions, QDRANT_INDEXES);
-    logFn("INFO", `Qdrant collection '${collection}' ready (${QDRANT_INDEXES.length} indexes)`);
+    const results = await Promise.all(destinations.map(async (destination) => {
+        try {
+            await pool.ensureCollection(destination.name, embCfg.dimensions, QDRANT_INDEXES);
+            logFn("INFO", `Qdrant destination '${destination.name}' collection '${destination.collection}' ready (${QDRANT_INDEXES.length} indexes)`);
+            return { destination, ok: true, error: null };
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            logFn("WARN", `Qdrant destination '${destination.name}' readiness check failed: ${message}`);
+            return { destination, ok: false, error: message };
+        }
+    }));
+    if (!results.some((result) => result.ok)) {
+        throw new Error(`No Qdrant destinations ready: ${results.map((result) => `${result.destination.name}: ${result.error}`).join("; ")}`);
+    }
 };
 // ---------------------------------------------------------------------------
 // HTTP requests
 // ---------------------------------------------------------------------------
-const qdrantRequest = async (method, urlPath, body) => {
-    if (!client) {
+const qdrantRequest = async (method, urlPath, body, destinationRef) => {
+    if (!pool) {
         throw new Error(`Qdrant client not initialized — call init() first (${method} ${urlPath})`);
     }
-    const result = await client.request(method, urlPath, body);
+    const destination = destinationFromRef(destinationRef);
+    const result = await pool.client(destination.name).request(method, pathForDestination(urlPath, destination), body);
     // Some Qdrant endpoints return empty bodies on success — preserve old return shape.
     return result ?? {};
 };
+const collectionForDestination = (destinationRef) => destinationFromRef(destinationRef).collection;
+const destinationNames = () => destinations.map((destination) => destination.name);
+const readyDestinations = () => {
+    if (!pool)
+        return [];
+    return destinations.filter((destination) => pool.isCollectionReady(destination.name));
+};
+const activeDestinations = () => {
+    const ready = readyDestinations();
+    return ready.length > 0 ? ready : destinations;
+};
 // ---------------------------------------------------------------------------
 // Read methods
 // ---------------------------------------------------------------------------
-const searchFacts = async (query, filters = {}, limit = 10) => {
+const searchFacts = async (query, filters = {}, limit = 10, destinationRef) => {
+    const destination = destinationFromRef(destinationRef);
     const vector = await embed(query);
     const must = [
         { is_null: { key: "superseded_by" } },
@@ -114,14 +187,15 @@ const searchFacts = async (query, filters = {}, limit = 10) => {
     if (filters.workspaceId) {
         must.push({ key: "workspace_id", match: { value: filters.workspaceId } });
     }
-    const result = await qdrantRequest("POST", `/collections/${collection}/points/search`, {
+    const result = await qdrantRequest("POST", `/collections/${destination.collection}/points/search`, {
         vector,
         filter: { must },
         limit,
         with_payload: true,
-    });
+    }, destination);
     return (result.result || []).map((hit) => ({
         id: hit.id,
+        destination: destination.name,
         score: hit.score,
         content: hit.payload?.content ?? "",
         category: hit.payload?.category ?? "",
@@ -131,7 +205,8 @@ const searchFacts = async (query, filters = {}, limit = 10) => {
         created_at: hit.payload?.created_at ?? "",
     }));
 };
-const scrollFacts = async (filters = {}, limit = 10) => {
+const scrollFacts = async (filters = {}, limit = 10, destinationRef) => {
+    const destination = destinationFromRef(destinationRef);
     const must = [
         { is_null: { key: "superseded_by" } },
     ];
@@ -179,14 +254,15 @@ const scrollFacts = async (filters = {}, limit = 10) => {
     if (filters.workspaceId) {
         must.push({ key: "workspace_id", match: { value: filters.workspaceId } });
     }
-    const result = await qdrantRequest("POST", `/collections/${collection}/points/scroll`, {
+    const result = await qdrantRequest("POST", `/collections/${destination.collection}/points/scroll`, {
         filter: { must, must_not },
         limit,
         ...(filters.orderBy ? { order_by: { key: filters.orderBy.key, direction: filters.orderBy.direction } } : {}),
         with_payload: true,
-    });
+    }, destination);
     return (result.result?.points || []).map((pt) => ({
         id: pt.id,
+        destination: destination.name,
         content: pt.payload?.content ?? "",
         category: pt.payload?.category ?? "",
         entities: pt.payload?.entities || [],
@@ -203,10 +279,17 @@ const scrollFacts = async (filters = {}, limit = 10) => {
         source_fact_ids: pt.payload?.source_fact_ids ?? [],
     }));
 };
+const scrollFactsAcrossDestinations = async (filters = {}, limit = 10) => {
+    const results = await Promise.all(activeDestinations().map((destination) => scrollFacts(filters, limit, destination).catch((e) => {
+        logFn("WARN", `Qdrant scroll failed for destination '${destination.name}': ${e.message}`);
+        return [];
+    })));
+    return results.flat();
+};
 // ---------------------------------------------------------------------------
 // Write methods
 // ---------------------------------------------------------------------------
-const storeFact = async (fact) => {
+const storeFact = async (fact, routeInput) => {
     const normalizedKind = normalizeKind(fact.kind);
     const normalizedSubtype = validateMemorySubtype(normalizedKind, fact.memory_subtype);
     const normalizedCategory = normalizedSubtype
@@ -226,9 +309,18 @@ const storeFact = async (fact) => {
         ...redactedEntities,
         ...(redactedRelation ? [redactedRelation.from, redactedRelation.type, redactedRelation.to] : []),
     ]);
-    const vector = await embed(redactedContent.text);
     const now = new Date().toISOString();
     const id = randomUUID();
+    const origin = fact.origin ?? buildOperationOrigin({
+        interface: "daemon",
+        action: "create",
+        subsystem: "qdrant.store_fact",
+        metadata: {
+            category: normalizedCategory,
+            kind: normalizedKind,
+            ...(normalizedSubtype ? { memory_subtype: normalizedSubtype } : {}),
+        },
+    });
     const payload = {
         content: redactedContent.text,
         category: normalizedCategory,
@@ -236,9 +328,9 @@ const storeFact = async (fact) => {
         kind: normalizedKind,
         ...(normalizedLayer ? { layer: normalizedLayer } : {}),
         ...(normalizedSubtype ? { memory_subtype: normalizedSubtype } : {}),
-        ...(fact.actor_id ? { actor_id: fact.actor_id } : {}),
+        origin,
+        ...(fact.last_operation_origin ? { last_operation_origin: fact.last_operation_origin } : {}),
         entities: redactedEntities.map((entity) => entity.text.toLowerCase()),
-        source: normalizeSource(fact.source ?? "system"),
         confidence: fact.confidence ?? 0.7,
         importance: fact.importance ?? 0.5,
         content_hash: redactedContent.redacted
@@ -281,37 +373,58 @@ const storeFact = async (fact) => {
     if (redaction.redacted) {
         payload.redaction = redaction;
     }
-    await qdrantRequest("PUT", `/collections/${collection}/points`, {
+    const destination = resolveDestination(routeInput ?? routingInputForFact(fact, redactedContent.text, payload.entities, {
+        category: normalizedCategory,
+        domain: normalizedDomain,
+        kind: normalizedKind,
+        ...(normalizedSubtype ? { memory_subtype: normalizedSubtype } : {}),
+    }));
+    const vector = await embed(redactedContent.text);
+    await qdrantRequest("PUT", `/collections/${destination.collection}/points`, {
         points: [{ id, vector, payload }],
-    });
-    logFn("DEBUG", `Qdrant: stored fact ${id} [${normalizedCategory}] ${redactedContent.text.slice(0, 60)}`);
+    }, destination);
+    logFn("DEBUG", `Qdrant: stored fact ${id} in '${destination.name}' [${normalizedCategory}] ${redactedContent.text.slice(0, 60)}`);
     return id;
 };
-const supersedeFact = async (oldFactId, newFactId) => {
+const supersedeFact = async (oldFactId, newFactId, destinationRef, origin) => {
+    const destination = destinationFromRef(destinationRef);
     const now = new Date().toISOString();
-    await qdrantRequest("POST", `/collections/${collection}/points/payload`, {
+    await qdrantRequest("POST", `/collections/${destination.collection}/points/payload`, {
         payload: {
             superseded_by: newFactId,
             superseded_at: now,
             updated_at: now,
+            last_operation_origin: origin ?? buildOperationOrigin({
+                interface: "daemon",
+                action: "supersede",
+                subsystem: "qdrant.supersede_fact",
+                metadata: { new_fact_id: newFactId },
+            }),
         },
         points: [oldFactId],
-    });
-    logFn("DEBUG", `Qdrant: superseded fact ${oldFactId} → ${newFactId}`);
+    }, destination);
+    logFn("DEBUG", `Qdrant: superseded fact ${oldFactId} → ${newFactId} in '${destination.name}'`);
 };
-const reinforceFact = async (factId, currentCount) => {
+const reinforceFact = async (factId, currentCount, destinationRef, origin) => {
+    const destination = destinationFromRef(destinationRef);
     const now = new Date().toISOString();
-    await qdrantRequest("POST", `/collections/${collection}/points/payload`, {
+    await qdrantRequest("POST", `/collections/${destination.collection}/points/payload`, {
         payload: {
             reinforcement_count: (currentCount || 1) + 1,
             last_reinforced_at: now,
             updated_at: now,
+            last_operation_origin: origin ?? buildOperationOrigin({
+                interface: "daemon",
+                action: "reinforce",
+                subsystem: "qdrant.reinforce_fact",
+            }),
         },
         points: [factId],
-    });
-    logFn("DEBUG", `Qdrant: reinforced fact ${factId}`);
+    }, destination);
+    logFn("DEBUG", `Qdrant: reinforced fact ${factId} in '${destination.name}'`);
 };
-const dedupCheck = async (content, contentHashVal, { exactThreshold = 0.92, supersedeThreshold = 0.80 } = {}, workspaceId) => {
+const dedupCheck = async (content, contentHashVal, { exactThreshold = 0.92, supersedeThreshold = 0.80 } = {}, workspaceId, routeInput) => {
+    const destination = resolveDestination(routeInput ?? { content });
     // First: hash-based exact check (fast, no embedding)
     try {
         const must = [
@@ -320,15 +433,16 @@ const dedupCheck = async (content, contentHashVal, { exactThreshold = 0.92, supe
         ];
         if (workspaceId)
             must.push({ key: "workspace_id", match: { value: workspaceId } });
-        const hashResult = await qdrantRequest("POST", `/collections/${collection}/points/scroll`, {
+        const hashResult = await qdrantRequest("POST", `/collections/${destination.collection}/points/scroll`, {
             filter: { must },
             limit: 1,
             with_payload: true,
-        });
+        }, destination);
         const existing = hashResult.result?.points?.[0];
         if (existing) {
             return {
                 action: "skip",
+                destination: destination.name,
                 existingId: existing.id,
                 existingCount: existing.payload?.reinforcement_count || 1,
                 score: 1.0,
@@ -345,18 +459,19 @@ const dedupCheck = async (content, contentHashVal, { exactThreshold = 0.92, supe
         const must = [{ is_null: { key: "superseded_by" } }];
         if (workspaceId)
             must.push({ key: "workspace_id", match: { value: workspaceId } });
-        const searchResult = await qdrantRequest("POST", `/collections/${collection}/points/search`, {
+        const searchResult = await qdrantRequest("POST", `/collections/${destination.collection}/points/search`, {
             vector,
             filter: { must },
             limit: 1,
             with_payload: true,
-        });
+        }, destination);
         const top = searchResult.result?.[0];
         if (!top)
-            return { action: "insert" };
+            return { action: "insert", destination: destination.name };
         if (top.score >= exactThreshold) {
             return {
                 action: "skip",
+                destination: destination.name,
                 existingId: top.id,
                 existingCount: top.payload?.reinforcement_count || 1,
                 score: top.score,
@@ -365,17 +480,18 @@ const dedupCheck = async (content, contentHashVal, { exactThreshold = 0.92, supe
         if (top.score >= supersedeThreshold) {
             return {
                 action: "supersede",
+                destination: destination.name,
                 existingId: top.id,
                 existingCount: top.payload?.reinforcement_count || 1,
                 score: top.score,
             };
         }
-        return { action: "insert" };
+        return { action: "insert", destination: destination.name };
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
         logFn("WARN", `Qdrant dedup vector check failed: ${msg}`);
-        return { action: "insert" }; // fail open — better to duplicate than lose
+        return { action: "insert", destination: destination.name }; // fail open — better to duplicate than lose
     }
 };
 /**
@@ -387,7 +503,8 @@ const dedupCheck = async (content, contentHashVal, { exactThreshold = 0.92, supe
  * No hardcoded vocabulary — purely embedding-similarity based, and the
  * exemplar set grows organically every time a user calls memory_forget.
  */
-const badExemplarCheck = async (content, workspaceId) => {
+const badExemplarCheck = async (content, workspaceId, routeInput) => {
+    const destination = resolveDestination(routeInput ?? { content });
     try {
         const vector = await embed(content);
         const must = [
@@ -395,12 +512,12 @@ const badExemplarCheck = async (content, workspaceId) => {
         ];
         if (workspaceId)
             must.push({ key: "workspace_id", match: { value: workspaceId } });
-        const result = await qdrantRequest("POST", `/collections/${collection}/points/search`, {
+        const result = await qdrantRequest("POST", `/collections/${destination.collection}/points/search`, {
             vector,
             filter: { must },
             limit: 1,
             with_payload: true,
-        });
+        }, destination);
         const top = result.result?.[0];
         if (!top)
             return null;
@@ -419,5 +536,5 @@ const badExemplarCheck = async (content, workspaceId) => {
 // ---------------------------------------------------------------------------
 // Exports
 // ---------------------------------------------------------------------------
-export { init, isReady, ensureCollection, setLogger, setEmbeddingConfig, qdrantRequest, embed, searchFacts, scrollFacts, storeFact, supersedeFact, reinforceFact, dedupCheck, badExemplarCheck, collection, };
+export { init, isReady, ensureCollection, setLogger, setEmbeddingConfig, qdrantRequest, resolveDestination, collectionForDestination, destinationNames, readyDestinations, activeDestinations, embed, searchFacts, scrollFacts, scrollFactsAcrossDestinations, storeFact, supersedeFact, reinforceFact, dedupCheck, badExemplarCheck, collection, };
 //# sourceMappingURL=qdrant.js.map

package/dist/daemon/relations.d.ts

@@ -44,8 +44,8 @@ declare const buildChangedCoOccurrenceCandidates: (facts: QdrantScrollResult[])
  * Get the set of entity pairs that already have a system-inferred relation.
  * Returns a Set of pairKeys.
  */
-declare const getExistingRelations: () => Promise<Set<string>>;
-declare const fetchSupportingFacts: (entityA: string, entityB: string) => Promise<RelationFact[]>;
+declare const getExistingRelations: (destination?: string) => Promise<Set<string>>;
+declare const fetchSupportingFacts: (entityA: string, entityB: string, destination?: string) => Promise<RelationFact[]>;
 declare const inferRelation: (candidate: RelationCandidate) => Promise<{
     from: string;
     type: string;
@@ -60,7 +60,7 @@ declare const inferRelation: (candidate: RelationCandidate) => Promise<{
         directionality_clarity?: string;
     };
 } | null>;
-declare const storeRelation: (fromEntity: string, toEntity: string, relationType: string, content: string, candidate: RelationCandidate, extras?: {
+declare const storeRelation: (fromEntity: string, toEntity: string, relationType: string, content: string, candidate: RelationCandidate, destination?: string, extras?: {
     evidence?: string;
     confidence?: number;
     inVocabulary?: boolean;

package/dist/daemon/relations.js

@@ -7,6 +7,7 @@
  */
 import { createHash } from "node:crypto";
 import * as qdrant from "./qdrant.js";
+import { buildOperationOrigin } from "../provenance/origin.js";
 import { chatCompletion } from "../llm/index.js";
 import { relationsPrompt, RELATIONS_PROMPT_DESCRIPTOR, safeParseJson, } from "../prompts/index.js";
 import { DEFAULT_CAPTURE_CONTEXT } from "./capture-policy.js";
@@ -72,8 +73,9 @@ const buildChangedCoOccurrenceCandidates = (facts) => {
  * Get the set of entity pairs that already have a system-inferred relation.
  * Returns a Set of pairKeys.
  */
-const getExistingRelations = async () => {
+const getExistingRelations = async (destination) => {
     const existing = new Set();
+    const collection = qdrant.collectionForDestination(destination);
     let offset = null;
     for (;;) {
         const body = {
@@ -89,7 +91,7 @@ const getExistingRelations = async () => {
         };
         if (offset)
             body.offset = offset;
-        const result = await qdrant.qdrantRequest("POST", `/collections/${qdrant.collection}/points/scroll`, body);
+        const result = await qdrant.qdrantRequest("POST", `/collections/${collection}/points/scroll`, body, destination);
         const points = result.result?.points || [];
         if (points.length === 0)
             break;
@@ -106,8 +108,9 @@ const getExistingRelations = async () => {
     logFn("DEBUG", `Relations: ${existing.size} existing daemon-inferred relations`);
     return existing;
 };
-const fetchSupportingFacts = async (entityA, entityB) => {
-    const result = await qdrant.qdrantRequest("POST", `/collections/${qdrant.collection}/points/scroll`, {
+const fetchSupportingFacts = async (entityA, entityB, destination) => {
+    const collection = qdrant.collectionForDestination(destination);
+    const result = await qdrant.qdrantRequest("POST", `/collections/${collection}/points/scroll`, {
         filter: {
             must: [
                 { is_null: { key: "superseded_by" } },
@@ -122,7 +125,7 @@ const fetchSupportingFacts = async (entityA, entityB) => {
         order_by: { key: "updated_at", direction: "desc" },
         limit: SUPPORTING_FACTS_LIMIT,
         with_payload: true,
-    });
+    }, destination);
     return (result.result?.points ?? []).map((point) => ({
         id: point.id,
         content: point.payload?.content ?? "",
@@ -133,8 +136,8 @@ const fetchSupportingFacts = async (entityA, entityB) => {
         metadata: point.payload?.metadata ?? {},
     }));
 };
-const buildRelationCandidate = async (changed) => {
-    const supportingFacts = await fetchSupportingFacts(changed.entityA, changed.entityB);
+const buildRelationCandidate = async (changed, destination) => {
+    const supportingFacts = await fetchSupportingFacts(changed.entityA, changed.entityB, destination);
     if (supportingFacts.length < MIN_SHARED_FACTS)
         return null;
     return {
@@ -224,7 +227,7 @@ const inferRelation = async (candidate) => {
         judgment: parsed.judgment,
     };
 };
-const storeRelation = async (fromEntity, toEntity, relationType, content, candidate, extras = {}) => {
+const storeRelation = async (fromEntity, toEntity, relationType, content, candidate, destination, extras = {}) => {
     const hash = createHash("sha256")
         .update(`daemon-relation:${pairKey(fromEntity, toEntity)}:${relationType}`)
         .digest("hex");
@@ -256,11 +259,19 @@ const storeRelation = async (fromEntity, toEntity, relationType, content, candid
         domain: DEFAULT_CAPTURE_CONTEXT.domain,
         kind: "relation",
         entities: [fromEntity, toEntity],
-        source: "system",
         confidence: extras.confidence ?? 0.7,
         importance: 0.6,
         content_hash: hash,
         metadata,
+        origin: buildOperationOrigin({
+            interface: "daemon",
+            action: "create",
+            subsystem: "relations",
+            metadata: {
+                relation_type: relationType,
+                supporting_fact_count: candidate.supportingFactIds.length,
+            },
+        }),
         source_fact_ids: candidate.supportingFactIds,
         ...(candidate.workstreamKeys.length > 0 ? { workstream_key: candidate.workstreamKeys[0] } : {}),
         relation: {
@@ -268,7 +279,7 @@ const storeRelation = async (fromEntity, toEntity, relationType, content, candid
             type: relationType,
             to: toEntity,
         },
-    });
+    }, destination ? { destination } : undefined);
     logFn("INFO", `Relations: inferred ${fromEntity} —[${relationType}]→ ${toEntity} (id: ${id})`);
     return id;
 };
@@ -287,12 +298,13 @@ const tick = async (config) => {
     const attempts = pruneRecentAttempts(job.recent_attempts, now, RELATION_ATTEMPT_BACKOFF_MS);
     const maxPairs = config.daemon.relation_inference_max_pairs_per_run ?? 3;
     const since = job.cursor_updated_at ?? new Date(now.getTime() - DEFAULT_LOOKBACK_MS).toISOString();
+    const destination = qdrant.resolveDestination({}).name;
     try {
         const changedFacts = await qdrant.scrollFacts({
             sinceUpdated: since,
             excludeKinds: ["relation"],
             orderBy: { key: "updated_at", direction: "asc" },
-        }, CHANGED_FACTS_LIMIT);
+        }, CHANGED_FACTS_LIMIT, destination);
         if (changedFacts.length === 0) {
             recordMaintenanceRun("relation_inference", {
                 job: "relation_inference",
@@ -318,14 +330,14 @@ const tick = async (config) => {
             }, { cursorUpdatedAt: changedFacts.map((fact) => fact.updated_at || fact.created_at).filter(Boolean).sort().at(-1) ?? nowIso, recentAttempts: attempts }, logFn);
             return;
         }
-        const existing = await getExistingRelations();
+        const existing = await getExistingRelations(destination);
         const touchedPairs = changedPairs
             .filter((pair) => !existing.has(pairKey(pair.entityA, pair.entityB)))
             .filter((pair) => !isAttemptBackedOff(attempts, pairKey(pair.entityA, pair.entityB), now, RELATION_ATTEMPT_BACKOFF_MS));
         const supportLookupLimit = Math.max(maxPairs * 5, maxPairs);
         const relationCandidates = [];
         for (const changed of touchedPairs.slice(0, supportLookupLimit)) {
-            const candidate = await buildRelationCandidate(changed);
+            const candidate = await buildRelationCandidate(changed, destination);
             if (candidate)
                 relationCandidates.push(candidate);
             if (relationCandidates.length >= maxPairs)
@@ -345,12 +357,12 @@ const tick = async (config) => {
                 const hash = createHash("sha256")
                     .update(`daemon-relation:${pairKey(result.from, result.to)}:${result.type}`)
                     .digest("hex");
-                const dedup = await qdrant.dedupCheck(result.content, hash);
+                const dedup = await qdrant.dedupCheck(result.content, hash, undefined, undefined, { destination });
                 if (dedup.action === "skip") {
                     logFn("DEBUG", `Relations: skipping duplicate ${candidate.entityA}↔${candidate.entityB}`);
                     continue;
                 }
-                await storeRelation(result.from, result.to, result.type, result.content, candidate, { evidence: result.evidence, confidence: result.confidence, inVocabulary: result.inVocabulary, judgment: result.judgment });
+                await storeRelation(result.from, result.to, result.type, result.content, candidate, destination, { evidence: result.evidence, confidence: result.confidence, inVocabulary: result.inVocabulary, judgment: result.judgment });
                 inferred++;
             }
             catch (e) {

package/dist/daemon/session-index.d.ts

@@ -2,6 +2,7 @@ import type { BikkyConfig } from "../config.js";
 import type { EpisodeSummaryWriteResult } from "./episode-summary.js";
 import type { QdrantPayload } from "./qdrant.js";
 import { type RedactionSummary } from "../privacy/redaction.js";
+import { type OperationOrigin } from "../provenance/origin.js";
 export interface WorkspaceScope {
     workspaceId?: string;
     actorId?: string;
@@ -38,6 +39,8 @@ export declare const buildSessionIndexPayload: (input: {
         enabled: boolean;
         redactPii: boolean;
     };
+    config?: BikkyConfig;
+    origin?: OperationOrigin;
 }) => SessionIndexPayloadResult;
 export declare const updateSessionIndex: (input: {
     sessionId: string;
@@ -45,9 +48,11 @@ export declare const updateSessionIndex: (input: {
     episodeResults: EpisodeSummaryWriteResult[];
     scope: WorkspaceScope;
     config: BikkyConfig;
+    destination?: string;
 }) => Promise<{
     action: "stored" | "updated" | "skipped";
     factId?: string;
+    destination?: string;
     reason?: string;
 }>;
 //# sourceMappingURL=session-index.d.ts.map