bikky 0.4.1 → 0.4.3

package/dist/daemon/episode-summary.js

@@ -13,6 +13,7 @@ import { CAPTURE_POLICY_VERSION, CAPTURE_TRIGGERS, DEFAULT_CAPTURE_CONTEXT, PROM
 import * as qdrant from "./qdrant.js";
 import { combineRedactions, redactStorageText, } from "../privacy/redaction.js";
 import { resolveWorkstreamKey, } from "./workstream-resolver.js";
+import { buildOperationOrigin } from "../provenance/origin.js";
 export { buildEpisodeSummaryMessages } from "../prompts/index.js";
 const DEFAULT_EPISODE_IMPORTANCE = 0.75;
 const contentHash = (text) => createHash("sha256").update(`episode:${text}`).digest("hex");
@@ -120,6 +121,17 @@ export const buildEpisodeSummaryPayload = (input) => {
     ]);
     const existingPayload = input.existing?.payload ?? {};
     const workstreamKey = input.draft.workstream_key ?? input.segment.workstream_key ?? null;
+    const operationOrigin = input.origin ?? buildOperationOrigin({
+        interface: "daemon",
+        action: input.existing ? "update" : "create",
+        subsystem: "episode_summary",
+        config: input.config,
+        metadata: {
+            session_id: input.sessionId,
+            episode_id: input.segment.episode_id,
+            event_count: input.segment.event_count,
+        },
+    });
     const payload = {
         ...existingPayload,
         content: redactedContent.text,
@@ -129,9 +141,9 @@ export const buildEpisodeSummaryPayload = (input) => {
         memory_subtype: "episode",
         layer: "episode",
         ...(input.scope.workspaceId ? { workspace_id: input.scope.workspaceId } : {}),
-        ...(input.scope.actorId ? { actor_id: input.scope.actorId } : {}),
+        origin: existingPayload.origin ?? operationOrigin,
+        ...(input.existing ? { last_operation_origin: operationOrigin } : {}),
         entities: redactedEntities.map((entity) => entity.text.toLowerCase()),
-        source: "system",
         confidence: 1.0,
         importance: input.draft.importance,
         content_hash: contentHash(redactedContent.text),
@@ -184,19 +196,36 @@ const summarizeEpisodeTranscript = async (input) => {
         throw new Error("Episode summary LLM returned null");
     return parseEpisodeSummaryDraft(result);
 };
-const findExistingEpisodeSummary = async (episodeId, scope) => {
-    const result = await qdrant.qdrantRequest("POST", `/collections/${qdrant.collection}/points/scroll`, {
+const findExistingEpisodeSummary = async (episodeId, scope, destination) => {
+    const collection = qdrant.collectionForDestination(destination);
+    const result = await qdrant.qdrantRequest("POST", `/collections/${collection}/points/scroll`, {
         filter: buildEpisodeSummaryFilter(episodeId, scope),
         limit: 1,
         with_payload: true,
-    });
+    }, destination);
     return result.result?.points?.[0] ?? null;
 };
 export const updateEpisodeSummary = async (input) => {
     if (!input.segment.transcript.trim()) {
         return { action: "skipped", reason: "empty_transcript", episodeId: input.segment.episode_id };
     }
-    const existing = await findExistingEpisodeSummary(input.segment.episode_id, input.scope);
+    const destination = qdrant.resolveDestination({
+        content: input.segment.transcript,
+        entities: [
+            input.sessionId,
+            ...(input.segment.workstream_key ? [input.segment.workstream_key] : []),
+        ],
+        metadata: {
+            session_id: input.sessionId,
+            episode_id: input.segment.episode_id,
+            ...(input.segment.workstream_key ? { workstream_key: input.segment.workstream_key } : {}),
+            memory_subtype: "episode",
+            kind: "summary",
+            origin_interface: "daemon",
+            origin_agent_type: "daemon",
+        },
+    });
+    const existing = await findExistingEpisodeSummary(input.segment.episode_id, input.scope, destination.name);
     const draft = await summarizeEpisodeTranscript({
         transcript: input.segment.transcript,
         sessionId: input.sessionId,
@@ -222,6 +251,7 @@ export const updateEpisodeSummary = async (input) => {
         scope: input.scope,
         now,
         existing,
+        config: input.config,
         redactionOptions: {
             enabled: true,
             redactPii: false,
@@ -229,13 +259,14 @@ export const updateEpisodeSummary = async (input) => {
     });
     const vector = await qdrant.embed(String(payload.content));
     const factId = existing?.id ?? randomUUID();
-    await qdrant.qdrantRequest("PUT", `/collections/${qdrant.collection}/points`, {
+    await qdrant.qdrantRequest("PUT", `/collections/${destination.collection}/points`, {
         points: [{ id: factId, vector, payload }],
-    });
+    }, destination.name);
     return {
         action: existing ? "updated" : "stored",
         factId,
         episodeId: input.segment.episode_id,
+        destination: destination.name,
         workstreamKey: resolved.key,
     };
 };

package/dist/daemon/extraction.d.ts

@@ -1,6 +1,6 @@
 /**
  * Events-based memory extraction — reads supported coding-agent transcripts,
- * extracts facts via LLM, and stores them in Qdrant with source: "system".
+ * extracts facts via LLM, and stores them in Qdrant with daemon origin metadata.
  *
  * Uses a JSON file for extraction state (high-water byte offsets) instead of SQLite.
  * Copilot session detection uses lock files. Claude Code detection uses

package/dist/daemon/extraction.js

@@ -1,6 +1,6 @@
 /**
  * Events-based memory extraction — reads supported coding-agent transcripts,
- * extracts facts via LLM, and stores them in Qdrant with source: "system".
+ * extracts facts via LLM, and stores them in Qdrant with daemon origin metadata.
  *
  * Uses a JSON file for extraction state (high-water byte offsets) instead of SQLite.
  * Copilot session detection uses lock files. Claude Code detection uses
@@ -19,7 +19,7 @@ import { CAPTURE_POLICY_VERSION, CAPTURE_TRIGGERS, DEFAULT_CAPTURE_CONTEXT, QUAL
 import { shouldSummarizeEvents, updateSessionSummary } from "./session-summary.js";
 import { redactStorageText } from "../privacy/redaction.js";
 import { compareSubtype, hasTypedToken, verifyGrounding, verifyVolatilityCoherence } from "./extraction-rules.js";
-import { resolveActorIdentity } from "../provenance/actor.js";
+import { buildOperationOrigin } from "../provenance/origin.js";
 import { discoverClaudeTranscriptMappings, discoverCopilotTranscriptMappings, extractionStateKey, readNewTranscriptEvents, transcriptLabel, } from "./transcript-sources.js";
 // ── Module state ─────────────────────────────────────────────────────────────
 let logFn = (() => { });
@@ -415,11 +415,6 @@ const storeFacts = async (facts, sessionId, config, source) => {
     };
     if (source)
         baseMeta.extraction_source = source;
-    const actor = resolveActorIdentity({ config });
-    if (actor.actor_label)
-        baseMeta.actor_label = actor.actor_label;
-    if (actor.source)
-        baseMeta.actor_source = actor.source;
     let stored = 0;
     for (const fact of facts) {
         const redactedContent = redactStorageText(fact.content);
@@ -429,12 +424,34 @@ const storeFacts = async (facts, sessionId, config, source) => {
             entities: fact.entities.map((entity) => entity.toLowerCase()),
         };
         const hash = contentHash(sanitizedFact.content);
+        const routeInput = {
+            content: sanitizedFact.content,
+            entities: sanitizedFact.entities,
+            metadata: {
+                ...baseMeta,
+                ...(fact.repo ? { repo: fact.repo } : {}),
+                ...(fact.branch ? { branch: fact.branch } : {}),
+                ...(fact.task_key ? { task_key: fact.task_key } : {}),
+                ...(fact.workstream_key ? { workstream_key: fact.workstream_key } : {}),
+                category: fact.category,
+            },
+        };
         try {
-            const dedup = await qdrant.dedupCheck(sanitizedFact.content, hash);
+            const dedup = await qdrant.dedupCheck(sanitizedFact.content, hash, undefined, undefined, routeInput);
             if (dedup.action === "skip") {
                 // Reinforce existing fact
                 if (dedup.existingId) {
-                    await qdrant.reinforceFact(dedup.existingId, dedup.existingCount || 1);
+                    await qdrant.reinforceFact(dedup.existingId, dedup.existingCount || 1, dedup.destination, buildOperationOrigin({
+                        interface: "daemon",
+                        action: "reinforce",
+                        subsystem: "extraction",
+                        config,
+                        metadata: {
+                            session_id: sessionId,
+                            ...(source ? { transcript_source: source } : {}),
+                            dedup_action: dedup.action,
+                        },
+                    }));
                 }
                 continue;
             }
@@ -444,6 +461,7 @@ const storeFacts = async (facts, sessionId, config, source) => {
                     const contradiction = await detectContradiction(sanitizedFact, config, {
                         sessionId,
                         workstreamKey: sanitizedFact.workstream_key ?? undefined,
+                        destination: dedup.destination,
                     });
                     if (contradiction.contradiction && contradiction.existingId) {
                         logFn("INFO", `Extraction: contradiction detected for "${fact.content.slice(0, 60)}..." vs ${contradiction.existingId}: ${contradiction.reason}`);
@@ -533,7 +551,7 @@ const storeFacts = async (facts, sessionId, config, source) => {
             // Downgrade to candidate with reduced confidence rather than dropping
             // outright: similarity is a soft signal, not a hard reject.
             try {
-                const badMatch = await qdrant.badExemplarCheck(sanitizedFact.content);
+                const badMatch = await qdrant.badExemplarCheck(sanitizedFact.content, undefined, routeInput);
                 if (badMatch && badMatch.score >= 0.85) {
                     effectiveConfidence = clamp01(effectiveConfidence - 0.2);
                     reviewStatus = "candidate";
@@ -553,7 +571,6 @@ const storeFacts = async (facts, sessionId, config, source) => {
                 domain: DEFAULT_CAPTURE_CONTEXT.domain,
                 memory_subtype: effectiveSubtype,
                 entities: sanitizedFact.entities,
-                source: "system",
                 kind: "fact",
                 confidence: effectiveConfidence,
                 importance: fact.importance,
@@ -571,17 +588,35 @@ const storeFacts = async (facts, sessionId, config, source) => {
                 task_key: fact.task_key,
                 workstream_key: fact.workstream_key,
                 metadata: factMeta,
+                origin: buildOperationOrigin({
+                    interface: "daemon",
+                    action: "create",
+                    subsystem: "extraction",
+                    config,
+                    metadata: {
+                        session_id: sessionId,
+                        ...(source ? { transcript_source: source } : {}),
+                        capture_policy_version: CAPTURE_POLICY_VERSION,
+                    },
+                }),
             };
-            if (actor.actor_id) {
-                storePayload.actor_id = actor.actor_id;
-            }
             if (dedup.action === "supersede" && dedup.existingId) {
-                const newId = await qdrant.storeFact(storePayload);
-                await qdrant.supersedeFact(dedup.existingId, newId);
+                const newId = await qdrant.storeFact(storePayload, routeInput);
+                await qdrant.supersedeFact(dedup.existingId, newId, dedup.destination, buildOperationOrigin({
+                    interface: "daemon",
+                    action: "supersede",
+                    subsystem: "extraction",
+                    config,
+                    metadata: {
+                        session_id: sessionId,
+                        new_fact_id: newId,
+                        ...(source ? { transcript_source: source } : {}),
+                    },
+                }));
                 stored++;
             }
             else {
-                await qdrant.storeFact(storePayload);
+                await qdrant.storeFact(storePayload, routeInput);
                 stored++;
             }
         }

package/dist/daemon/qdrant.d.ts

@@ -7,9 +7,12 @@
  * `qdrant_api_key` is optional — leave unset for unauthenticated local /
  * self-hosted instances.
  */
+import { type Destination } from "../config.js";
 import { embed } from "../llm/index.js";
 import type { InitEmbeddingInput } from "../llm/index.js";
+import { type RoutingInput } from "../routing.js";
 import { type RedactionSummary } from "../privacy/redaction.js";
+import { type OperationOrigin } from "../provenance/origin.js";
 export type LogFn = (level: string, ...args: unknown[]) => void;
 export interface QdrantPayload {
     content: string;
@@ -18,10 +21,15 @@ export interface QdrantPayload {
     kind: string;
     layer?: string | null;
     memory_subtype?: string | null;
+    origin?: OperationOrigin;
+    last_operation_origin?: OperationOrigin;
+    /** @deprecated Origin is canonical for new writes. */
     workspace_id?: string;
+    /** @deprecated Origin is canonical for new writes. */
     actor_id?: string;
     entities: string[];
-    source: string;
+    /** @deprecated Origin is canonical for new writes. */
+    source?: string;
     confidence: number;
     importance: number;
     content_hash: string;
@@ -65,11 +73,15 @@ export interface StoreFact {
     layer?: string | null;
     memory_subtype?: string | null;
     entities: string[];
+    origin?: OperationOrigin;
+    last_operation_origin?: OperationOrigin;
+    /** @deprecated Origin is canonical for new writes. */
     source?: string;
     confidence?: number;
     importance?: number;
     content_hash: string;
     workspace_id?: string;
+    /** @deprecated Origin is canonical for new writes. */
     actor_id?: string;
     metadata?: Record<string, string | number | boolean | null>;
     session_id?: string | null;
@@ -100,6 +112,7 @@ export interface StoreFact {
 }
 export interface QdrantSearchResult {
     id: string;
+    destination?: string;
     score: number;
     content: string;
     category: string;
@@ -110,6 +123,7 @@ export interface QdrantSearchResult {
 }
 export interface QdrantScrollResult {
     id: string;
+    destination?: string;
     content: string;
     category: string;
     entities: string[];
@@ -151,6 +165,7 @@ export interface QdrantScrollFilters {
 export type DedupAction = "insert" | "skip" | "supersede";
 export interface DedupResult {
     action: DedupAction;
+    destination?: string;
     existingId?: string;
     existingCount?: number;
     score?: number;
@@ -162,16 +177,23 @@ export interface DedupThresholds {
 declare let collection: string;
 declare const setLogger: (fn: LogFn) => void;
 declare const setEmbeddingConfig: (overrides?: Partial<InitEmbeddingInput>) => void;
+type DestinationRef = Destination | string | null | undefined;
+declare const resolveDestination: (input?: RoutingInput) => Destination;
 declare const init: () => boolean;
 declare const isReady: () => boolean;
 declare const ensureCollection: () => Promise<void>;
-declare const qdrantRequest: (method: string, urlPath: string, body?: unknown) => Promise<Record<string, unknown>>;
-declare const searchFacts: (query: string, filters?: QdrantSearchFilters, limit?: number) => Promise<QdrantSearchResult[]>;
-declare const scrollFacts: (filters?: QdrantScrollFilters, limit?: number) => Promise<QdrantScrollResult[]>;
-declare const storeFact: (fact: StoreFact) => Promise<string>;
-declare const supersedeFact: (oldFactId: string, newFactId: string) => Promise<void>;
-declare const reinforceFact: (factId: string, currentCount: number) => Promise<void>;
-declare const dedupCheck: (content: string, contentHashVal: string, { exactThreshold, supersedeThreshold }?: DedupThresholds, workspaceId?: string) => Promise<DedupResult>;
+declare const qdrantRequest: (method: string, urlPath: string, body?: unknown, destinationRef?: DestinationRef) => Promise<Record<string, unknown>>;
+declare const collectionForDestination: (destinationRef?: DestinationRef) => string;
+declare const destinationNames: () => string[];
+declare const readyDestinations: () => Destination[];
+declare const activeDestinations: () => Destination[];
+declare const searchFacts: (query: string, filters?: QdrantSearchFilters, limit?: number, destinationRef?: DestinationRef) => Promise<QdrantSearchResult[]>;
+declare const scrollFacts: (filters?: QdrantScrollFilters, limit?: number, destinationRef?: DestinationRef) => Promise<QdrantScrollResult[]>;
+declare const scrollFactsAcrossDestinations: (filters?: QdrantScrollFilters, limit?: number) => Promise<QdrantScrollResult[]>;
+declare const storeFact: (fact: StoreFact, routeInput?: RoutingInput) => Promise<string>;
+declare const supersedeFact: (oldFactId: string, newFactId: string, destinationRef?: DestinationRef, origin?: OperationOrigin) => Promise<void>;
+declare const reinforceFact: (factId: string, currentCount: number, destinationRef?: DestinationRef, origin?: OperationOrigin) => Promise<void>;
+declare const dedupCheck: (content: string, contentHashVal: string, { exactThreshold, supersedeThreshold }?: DedupThresholds, workspaceId?: string, routeInput?: RoutingInput) => Promise<DedupResult>;
 /**
  * Check whether incoming content is similar to any fact previously marked as a
  * bad exemplar (via memory_forget). Returns the top similarity score, or null
@@ -181,10 +203,10 @@ declare const dedupCheck: (content: string, contentHashVal: string, { exactThres
  * No hardcoded vocabulary — purely embedding-similarity based, and the
  * exemplar set grows organically every time a user calls memory_forget.
  */
-declare const badExemplarCheck: (content: string, workspaceId?: string) => Promise<{
+declare const badExemplarCheck: (content: string, workspaceId?: string, routeInput?: RoutingInput) => Promise<{
     score: number;
     exemplarId: string;
     reason?: string;
 } | null>;
-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.d.ts.map