bikky 0.4.2 → 0.4.4

package/dist/daemon/quality-rollups.js

@@ -0,0 +1,378 @@
+/**
+ * Backend aggregation for memory quality telemetry.
+ */
+import { createHash } from "node:crypto";
+import { contentHash, computeEffectiveConfidence } from "../mcp/helpers.js";
+import { categoryForMemorySubtype, layerForMemorySubtype } from "../mcp/taxonomy.js";
+import { buildOperationOrigin } from "../provenance/origin.js";
+import { readMaintenanceState, recordMaintenanceRun, shouldRunMaintenance, } from "./maintenance-state.js";
+import * as qdrant from "./qdrant.js";
+const SCROLL_LIMIT = 256;
+const ROLLUP_TYPE = "latest";
+const JOB_NAME = "memory_quality_rollups";
+let logFn = () => { };
+const defaultDeps = {
+    isReady: qdrant.isReady,
+    activeDestinations: qdrant.activeDestinations,
+    qdrantRequest: qdrant.qdrantRequest,
+    embed: qdrant.embed,
+};
+export const setLogger = (fn) => {
+    logFn = fn;
+};
+const nonEmptyString = (value) => {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+};
+const numberValue = (value) => (typeof value === "number" && Number.isFinite(value) ? value : 0);
+const stringArray = (value) => (Array.isArray(value)
+    ? value.map((item) => nonEmptyString(item)).filter((item) => item !== null)
+    : []);
+const stableUuid = (input) => {
+    const hash = createHash("sha256").update(input).digest("hex");
+    return [
+        hash.slice(0, 8),
+        hash.slice(8, 12),
+        hash.slice(12, 16),
+        hash.slice(16, 20),
+        hash.slice(20, 32),
+    ].join("-");
+};
+const completePayload = (payload) => ({
+    ...payload,
+    content: payload.content ?? "",
+    category: payload.category ?? "engineering",
+    domain: payload.domain ?? "software_engineering",
+    kind: payload.kind ?? "fact",
+    memory_subtype: payload.memory_subtype ?? null,
+    entities: payload.entities ?? [],
+    confidence: typeof payload.confidence === "number" ? payload.confidence : 0.7,
+    content_hash: payload.content_hash ?? "",
+    reinforcement_count: payload.reinforcement_count ?? 1,
+    last_reinforced_at: payload.last_reinforced_at ?? payload.created_at ?? "",
+    superseded_by: payload.superseded_by ?? null,
+    superseded_at: payload.superseded_at ?? null,
+    created_at: payload.created_at ?? "",
+    updated_at: payload.updated_at ?? payload.created_at ?? "",
+});
+const daysBetween = (now, iso) => {
+    if (!iso)
+        return 0;
+    const timestamp = Date.parse(iso);
+    if (!Number.isFinite(timestamp))
+        return 0;
+    return Math.max(0, (now.getTime() - timestamp) / 86_400_000);
+};
+const isFactStale = (payload, now, thresholdDays) => {
+    const activity = payload.last_verified_at ?? payload.last_reinforced_at ?? payload.created_at;
+    if (!activity)
+        return false;
+    return daysBetween(now, activity) > thresholdDays;
+};
+const scopesForFact = (fact) => {
+    const scopes = [{ type: "destination", value: fact.destination }];
+    const add = (type, value) => {
+        const normalized = nonEmptyString(value);
+        if (normalized)
+            scopes.push({ type, value: normalized });
+    };
+    add("repo", fact.payload.repo);
+    add("workstream_key", fact.payload.workstream_key);
+    add("task_key", fact.payload.task_key);
+    for (const entity of fact.payload.entities ?? [])
+        add("entity", entity);
+    add("origin_user", fact.payload.origin?.user?.id);
+    add("origin_agent", fact.payload.origin?.agent?.id);
+    const seen = new Set();
+    return scopes.filter((scope) => {
+        const key = `${scope.type}\0${scope.value}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+};
+const rollupKey = (destination, scope) => `${destination}\0${scope.type}\0${scope.value}`;
+const getRollup = (rollups, destination, scope, generatedAt) => {
+    const key = rollupKey(destination, scope);
+    const existing = rollups.get(key);
+    if (existing)
+        return existing;
+    const created = {
+        destination,
+        scope_type: scope.type,
+        scope_value: scope.value,
+        active_fact_count: 0,
+        recall_count: 0,
+        useful_count: 0,
+        misleading_count: 0,
+        wrong_count: 0,
+        stale_count: 0,
+        low_confidence_count: 0,
+        generated_at: generatedAt,
+        sourceFactIds: new Set(),
+        sourceEventIds: new Set(),
+    };
+    rollups.set(key, created);
+    return created;
+};
+const addEventSignal = (rollups, scopes, destination, generatedAt, eventId, update) => {
+    for (const scope of scopes) {
+        const rollup = getRollup(rollups, destination, scope, generatedAt);
+        update(rollup);
+        rollup.sourceEventIds.add(eventId);
+    }
+};
+export const buildQualityRollups = (input) => {
+    const now = input.generatedAt ?? new Date();
+    const generatedAt = now.toISOString();
+    const staleThresholdDays = input.staleThresholdDays ?? 30;
+    const lowConfidenceThreshold = input.lowConfidenceThreshold ?? 0.6;
+    const factsById = new Map(input.facts.map((fact) => [fact.id, fact]));
+    const scopesByFactId = new Map(input.facts.map((fact) => [fact.id, scopesForFact(fact)]));
+    const rollups = new Map();
+    for (const fact of input.facts) {
+        const payload = completePayload(fact.payload);
+        const scopes = scopesByFactId.get(fact.id) ?? [];
+        for (const scope of scopes) {
+            const rollup = getRollup(rollups, fact.destination, scope, generatedAt);
+            rollup.active_fact_count++;
+            rollup.recall_count += numberValue(payload.recall_count);
+            rollup.useful_count += numberValue(payload.useful_count ?? payload.useful_feedback_count);
+            if (isFactStale(payload, now, staleThresholdDays))
+                rollup.stale_count++;
+            if (computeEffectiveConfidence(payload) < lowConfidenceThreshold)
+                rollup.low_confidence_count++;
+            rollup.sourceFactIds.add(fact.id);
+        }
+    }
+    for (const event of input.events ?? []) {
+        const subtype = event.payload.memory_subtype;
+        if (subtype === "recall_event") {
+            for (const factId of stringArray(event.payload.returned_fact_ids)) {
+                const fact = factsById.get(factId);
+                if (!fact || typeof fact.payload.recall_count === "number")
+                    continue;
+                addEventSignal(rollups, scopesByFactId.get(factId) ?? [], fact.destination, generatedAt, event.id, (rollup) => { rollup.recall_count++; });
+            }
+            continue;
+        }
+        const targetFactId = nonEmptyString(event.payload.target_fact_id);
+        if (!targetFactId)
+            continue;
+        const targetFact = factsById.get(targetFactId);
+        if (!targetFact)
+            continue;
+        const targetScopes = scopesByFactId.get(targetFactId) ?? [];
+        if (subtype === "feedback_event" && event.payload.feedback_kind === "useful") {
+            if (typeof targetFact.payload.useful_count === "number" || typeof targetFact.payload.useful_feedback_count === "number") {
+                continue;
+            }
+            addEventSignal(rollups, targetScopes, targetFact.destination, generatedAt, event.id, (rollup) => { rollup.useful_count++; });
+            continue;
+        }
+        if (subtype === "outcome_event" && (event.payload.outcome === "misleading" || event.payload.outcome === "wrong")) {
+            addEventSignal(rollups, targetScopes, targetFact.destination, generatedAt, event.id, (rollup) => {
+                if (event.payload.outcome === "misleading")
+                    rollup.misleading_count++;
+                if (event.payload.outcome === "wrong")
+                    rollup.wrong_count++;
+            });
+        }
+    }
+    return [...rollups.values()]
+        .map((rollup) => ({
+        destination: rollup.destination,
+        scope_type: rollup.scope_type,
+        scope_value: rollup.scope_value,
+        active_fact_count: rollup.active_fact_count,
+        recall_count: rollup.recall_count,
+        useful_count: rollup.useful_count,
+        misleading_count: rollup.misleading_count,
+        wrong_count: rollup.wrong_count,
+        stale_count: rollup.stale_count,
+        low_confidence_count: rollup.low_confidence_count,
+        generated_at: rollup.generated_at,
+        source_fact_ids: [...rollup.sourceFactIds].sort().slice(0, 100),
+        source_event_ids: [...rollup.sourceEventIds].sort().slice(0, 100),
+    }))
+        .sort((a, b) => `${a.scope_type}:${a.scope_value}`.localeCompare(`${b.scope_type}:${b.scope_value}`));
+};
+const scrollAllPoints = async (deps, destination, filter) => {
+    const points = [];
+    let offset;
+    do {
+        const body = {
+            filter,
+            limit: SCROLL_LIMIT,
+            with_payload: true,
+            ...(offset !== undefined && offset !== null ? { offset } : {}),
+        };
+        const response = await deps.qdrantRequest("POST", `/collections/${destination.collection}/points/scroll`, body, destination);
+        for (const point of response.result?.points ?? []) {
+            points.push({
+                id: point.id,
+                destination: destination.name,
+                payload: (point.payload ?? {}),
+            });
+        }
+        offset = response.result?.next_page_offset;
+    } while (offset !== undefined && offset !== null);
+    return points;
+};
+const fetchQualityInputs = async (deps, destination) => {
+    const facts = await scrollAllPoints(deps, destination, {
+        must: [{ is_null: { key: "superseded_by" } }],
+        must_not: [{ key: "kind", match: { any: ["telemetry", "entity_type"] } }],
+    });
+    const events = await scrollAllPoints(deps, destination, {
+        must: [
+            { key: "kind", match: { value: "telemetry" } },
+            { key: "memory_subtype", match: { any: ["feedback_event", "outcome_event", "recall_event"] } },
+        ],
+    });
+    return { facts, events };
+};
+const rollupContent = (rollup) => (`Memory quality rollup for ${rollup.scope_type}:${rollup.scope_value}: ` +
+    `${rollup.active_fact_count} active facts, ${rollup.recall_count} recalls, ` +
+    `${rollup.useful_count} useful, ${rollup.misleading_count} misleading, ` +
+    `${rollup.wrong_count} wrong, ${rollup.stale_count} stale, ` +
+    `${rollup.low_confidence_count} low-confidence.`);
+const rollupId = (rollup) => stableUuid(`aggregate_rollup:${ROLLUP_TYPE}:${rollup.destination}:${rollup.scope_type}:${rollup.scope_value}`);
+const rollupPayload = (config, rollup) => {
+    const content = rollupContent(rollup);
+    return {
+        content,
+        category: categoryForMemorySubtype("aggregate_rollup") ?? "system",
+        domain: "software_engineering",
+        kind: "telemetry",
+        memory_subtype: "aggregate_rollup",
+        layer: layerForMemorySubtype("aggregate_rollup") ?? "workspace",
+        entities: rollup.scope_type === "entity" ? [rollup.scope_value.toLowerCase()] : [],
+        origin: buildOperationOrigin({
+            config,
+            interface: "daemon",
+            action: "aggregate",
+            subsystem: "memory_quality_rollups",
+            metadata: {
+                destination: rollup.destination,
+                scope_type: rollup.scope_type,
+                scope_value: rollup.scope_value,
+            },
+        }),
+        confidence: 1.0,
+        importance: 0.4,
+        content_hash: contentHash("aggregate_rollup", `${ROLLUP_TYPE}:${rollup.destination}:${rollup.scope_type}:${rollup.scope_value}`),
+        reinforcement_count: 1,
+        last_reinforced_at: rollup.generated_at,
+        superseded_by: null,
+        superseded_at: null,
+        created_at: rollup.generated_at,
+        updated_at: rollup.generated_at,
+        rollup_type: ROLLUP_TYPE,
+        rollup_generated_at: rollup.generated_at,
+        rollup_window_end: rollup.generated_at,
+        scope_type: rollup.scope_type,
+        scope_value: rollup.scope_value,
+        active_fact_count: rollup.active_fact_count,
+        recall_count: rollup.recall_count,
+        useful_count: rollup.useful_count,
+        misleading_count: rollup.misleading_count,
+        wrong_count: rollup.wrong_count,
+        stale_count: rollup.stale_count,
+        low_confidence_count: rollup.low_confidence_count,
+        source_fact_ids: rollup.source_fact_ids,
+        source_event_ids: rollup.source_event_ids,
+        metadata: {
+            generated_by: "memory_quality_rollups",
+            rollup_type: ROLLUP_TYPE,
+        },
+    };
+};
+const upsertRollup = async (config, deps, destination, rollup) => {
+    const payload = rollupPayload(config, rollup);
+    const vector = await deps.embed(String(payload.content));
+    await deps.qdrantRequest("PUT", `/collections/${destination.collection}/points`, {
+        points: [{ id: rollupId(rollup), vector, payload }],
+    }, destination);
+};
+export const aggregateMemoryQualitySignals = async (config, deps = defaultDeps) => {
+    const destinations = deps.activeDestinations();
+    const generatedAt = new Date();
+    const maxScopes = config.daemon.memory_quality_rollups_max_scopes_per_run ?? 100;
+    let factsSeen = 0;
+    let eventsSeen = 0;
+    let rollupsUpserted = 0;
+    let scopesCapped = false;
+    for (const destination of destinations) {
+        const { facts, events } = await fetchQualityInputs(deps, destination);
+        factsSeen += facts.length;
+        eventsSeen += events.length;
+        const rollups = buildQualityRollups({
+            facts,
+            events,
+            generatedAt,
+            staleThresholdDays: config.daemon.staleness_threshold_days,
+            lowConfidenceThreshold: config.daemon.memory_quality_rollups_low_confidence_threshold,
+        });
+        const selectedRollups = rollups.slice(0, maxScopes);
+        scopesCapped ||= rollups.length > selectedRollups.length;
+        for (const rollup of selectedRollups) {
+            await upsertRollup(config, deps, destination, rollup);
+            rollupsUpserted++;
+        }
+    }
+    return {
+        destinations_seen: destinations.length,
+        facts_seen: factsSeen,
+        events_seen: eventsSeen,
+        rollups_upserted: rollupsUpserted,
+        scopes_capped: scopesCapped,
+    };
+};
+export const tick = async (config, deps = defaultDeps) => {
+    if (!config.daemon.memory_quality_rollups_enabled)
+        return;
+    if (!deps.isReady())
+        return;
+    const now = new Date();
+    const nowIso = now.toISOString();
+    const state = readMaintenanceState(logFn);
+    const job = state.jobs.memory_quality_rollups;
+    const intervalSec = config.daemon.memory_quality_rollups_interval_sec ?? 3600;
+    if (!shouldRunMaintenance(now, job.last_run_at, intervalSec))
+        return;
+    try {
+        const result = await aggregateMemoryQualitySignals(config, deps);
+        recordMaintenanceRun(JOB_NAME, {
+            job: JOB_NAME,
+            ran_at: nowIso,
+            status: result.facts_seen === 0 ? "skipped" : "success",
+            candidates_seen: result.facts_seen + result.events_seen,
+            llm_calls: 0,
+            accepted: result.rollups_upserted,
+            deterministic: result.rollups_upserted,
+            skipped_reason: result.facts_seen === 0
+                ? "no_active_facts"
+                : result.scopes_capped
+                    ? "max_scopes_per_run_reached"
+                    : undefined,
+        }, { cursorUpdatedAt: nowIso }, logFn);
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : String(e);
+        logFn("ERROR", `Memory quality rollups failed: ${message}`);
+        recordMaintenanceRun(JOB_NAME, {
+            job: JOB_NAME,
+            ran_at: nowIso,
+            status: "error",
+            candidates_seen: 0,
+            llm_calls: 0,
+            accepted: 0,
+            error: message,
+        }, {}, logFn);
+    }
+};
+//# sourceMappingURL=quality-rollups.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");
@@ -252,15 +255,23 @@ const storeRelation = async (fromEntity, toEntity, relationType, content, candid
     }
     const id = await qdrant.storeFact({
         content,
-        category: "human",
+        category: "engineering",
         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

package/dist/daemon/session-index.js

@@ -8,6 +8,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { CAPTURE_POLICY_VERSION, DEFAULT_CAPTURE_CONTEXT, PROMPT_VERSIONS } from "./capture-policy.js";
 import * as qdrant from "./qdrant.js";
 import { combineRedactions, redactStorageText, } from "../privacy/redaction.js";
+import { buildOperationOrigin } from "../provenance/origin.js";
 const contentHash = (text) => createHash("sha256").update(`session-index:${text}`).digest("hex");
 export const buildSessionIndexDraft = (input) => {
     const episodeIds = input.episodeResults
@@ -48,6 +49,16 @@ export const buildSessionIndexPayload = (input) => {
     const redactedEntities = input.draft.entities.map((entity) => redactStorageText(entity, input.redactionOptions));
     const redaction = combineRedactions([redactedContent, ...redactedEntities]);
     const existingPayload = input.existing?.payload ?? {};
+    const operationOrigin = input.origin ?? buildOperationOrigin({
+        interface: "daemon",
+        action: input.existing ? "update" : "create",
+        subsystem: "session_index",
+        config: input.config,
+        metadata: {
+            session_id: input.sessionId,
+            event_count: input.eventCount,
+        },
+    });
     const payload = {
         ...existingPayload,
         content: redactedContent.text,
@@ -57,9 +68,9 @@ export const buildSessionIndexPayload = (input) => {
         memory_subtype: "session_index",
         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),
@@ -93,24 +104,38 @@ export const buildSessionIndexPayload = (input) => {
     }
     return { payload, redaction };
 };
-const findExistingSessionIndex = async (sessionId, scope) => {
-    const result = await qdrant.qdrantRequest("POST", `/collections/${qdrant.collection}/points/scroll`, {
+const findExistingSessionIndex = async (sessionId, scope, destination) => {
+    const collection = qdrant.collectionForDestination(destination);
+    const result = await qdrant.qdrantRequest("POST", `/collections/${collection}/points/scroll`, {
         filter: buildSessionIndexFilter(sessionId, scope),
         limit: 1,
         with_payload: true,
-    });
+    }, destination);
     return result.result?.points?.[0] ?? null;
 };
 export const updateSessionIndex = async (input) => {
     if (input.episodeResults.length === 0) {
         return { action: "skipped", reason: "no_episode_results" };
     }
-    const existing = await findExistingSessionIndex(input.sessionId, input.scope);
     const draft = buildSessionIndexDraft({
         sessionId: input.sessionId,
         eventCount: input.eventCount,
         episodeResults: input.episodeResults,
     });
+    const destination = input.destination
+        ?? input.episodeResults.find((result) => result.destination)?.destination
+        ?? qdrant.resolveDestination({
+            content: draft.content,
+            entities: draft.entities,
+            metadata: {
+                session_id: input.sessionId,
+                memory_subtype: "session_index",
+                kind: "summary",
+                origin_interface: "daemon",
+                origin_agent_type: "daemon",
+            },
+        }).name;
+    const existing = await findExistingSessionIndex(input.sessionId, input.scope, destination);
     const now = new Date().toISOString();
     const { payload } = buildSessionIndexPayload({
         draft,
@@ -119,6 +144,7 @@ export const updateSessionIndex = async (input) => {
         now,
         existing,
         eventCount: input.eventCount,
+        config: input.config,
         redactionOptions: {
             enabled: true,
             redactPii: false,
@@ -126,9 +152,10 @@ export const updateSessionIndex = async (input) => {
     });
     const vector = await qdrant.embed(String(payload.content));
     const factId = existing?.id ?? randomUUID();
-    await qdrant.qdrantRequest("PUT", `/collections/${qdrant.collection}/points`, {
+    const collection = qdrant.collectionForDestination(destination);
+    await qdrant.qdrantRequest("PUT", `/collections/${collection}/points`, {
         points: [{ id: factId, vector, payload }],
-    });
-    return { action: existing ? "updated" : "stored", factId };
+    }, destination);
+    return { action: existing ? "updated" : "stored", factId, destination };
 };
 //# sourceMappingURL=session-index.js.map