bikky 0.4.2 → 0.4.4

package/dist/mcp/tools.js

@@ -3,7 +3,7 @@
  */
 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 { STALENESS_DAYS, THRESHOLD_DUPLICATE, THRESHOLD_RELATED, QDRANT_INDEXES, categoryValues, categoryEnumDescription, domainValues, domainEnumDescription, kindValues, kindEnumDescription, memorySubtypeValues, memorySubtypeEnumDescription, DEFAULT_CATEGORY, DEFAULT_DOMAIN, DEFAULT_KIND, 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, 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";
@@ -11,8 +11,9 @@ import { saveConfig, loadConfig, EXTRACTION_HEALTH_PATH } from "../config.js";
 import { availableSearchScopes, resolveSearchScope, SearchScopeNotFoundError, } from "../search-scope.js";
 import { existsSync, readFileSync } from "node:fs";
 import { inspectWatcherPaths, formatIssue, repairSuspiciousWatcherPaths } from "../daemon/watcher-health.js";
-import { normalizeActorId, resolveActorIdentity } from "../provenance/actor.js";
+import { buildOperationOrigin } from "../provenance/origin.js";
 import { addRedactionPayload, combineRedactions, redactStorageText, } from "../privacy/redaction.js";
+import { buildMemoryRoutingInput } from "../routing-context.js";
 // ---------------------------------------------------------------------------
 // Runtime state
 // ---------------------------------------------------------------------------
@@ -31,6 +32,19 @@ function nowISO() {
 function newId() {
     return crypto.randomUUID();
 }
+function outcomeCounterField(outcome) {
+    if (outcome === "useful")
+        return "useful_count";
+    if (outcome === "misleading")
+        return "misleading_count";
+    if (outcome === "wrong")
+        return "wrong_count";
+    return "irrelevant_count";
+}
+function payloadCounter(payload, field) {
+    const value = payload[field];
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
 // Build a RoutingInput from the standard memory-tool fields.
 function routingInput(args) {
     return {
@@ -41,6 +55,37 @@ function routingInput(args) {
         metadata: args.metadata,
     };
 }
+function compactMetadata(values) {
+    const metadata = {};
+    for (const [key, value] of Object.entries(values)) {
+        if (value === undefined || value === null)
+            continue;
+        metadata[key] = value;
+    }
+    return metadata;
+}
+function memoryWriteRoutingInput(args) {
+    const relationMetadata = args.relation ? {
+        from_entity: args.relation.from,
+        relation_type: args.relation.type,
+        to_entity: args.relation.to,
+    } : {};
+    return buildMemoryRoutingInput({
+        destination: args.destination,
+        cwd: process.cwd(),
+        content: args.content,
+        entities: args.entities,
+        metadata: args.metadata,
+        context: compactMetadata({
+            origin_interface: "mcp",
+            origin_action: "create",
+            origin_tool: args.tool,
+            ...(args.context ?? {}),
+            ...relationMetadata,
+        }),
+        extraContent: args.relation ? [args.relation] : [],
+    });
+}
 // 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) {
@@ -82,6 +127,77 @@ function formatScopedFact(point, includeDestination) {
     const formatted = formatFact(point);
     return includeDestination ? `[${point._destination.name}] ${formatted}` : formatted;
 }
+async function recordRecallTelemetry(args) {
+    const now = nowISO();
+    const byDestination = new Map();
+    for (const point of args.ranked) {
+        const existing = byDestination.get(point._destination.name);
+        if (existing) {
+            existing.points.push(point);
+        }
+        else {
+            byDestination.set(point._destination.name, { dest: point._destination, points: [point] });
+        }
+    }
+    for (const { dest, points } of byDestination.values()) {
+        const returnedFactIds = points.map((point) => point.id);
+        const recallOrigin = mcpOrigin({
+            action: "recall",
+            tool: "memory_recall",
+            metadata: {
+                destination: dest.name,
+                result_count: points.length,
+                search_scope: args.searchScope.name,
+            },
+        });
+        for (const point of points) {
+            const currentCount = point.payload.recall_count ?? 0;
+            try {
+                await qdrantSetPayload(dest, [point.id], {
+                    recall_count: currentCount + 1,
+                    last_recalled_at: now,
+                    updated_at: now,
+                    last_operation_origin: recallOrigin,
+                });
+            }
+            catch (e) {
+                log("WARN", `Failed to update recall_count for ${point.id}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        const entities = [...new Set(points.flatMap((point) => point.payload.entities ?? []))].slice(0, 25);
+        const eventContent = `Recall returned ${points.length} fact(s) from ${dest.name}: ${args.redactedQuery.text}`;
+        const redactedEvent = redactStorageText(eventContent);
+        const eventPayload = {
+            content: redactedEvent.text,
+            category: categoryForMemorySubtype("recall_event") ?? "system",
+            domain: "software_engineering",
+            kind: "telemetry",
+            memory_subtype: "recall_event",
+            layer: "memory_object",
+            entities,
+            origin: recallOrigin,
+            confidence: 1.0,
+            importance: 0.3,
+            content_hash: contentHash("recall_event", `${dest.name}:${returnedFactIds.join(",")}:${now}`),
+            recall_query: args.redactedQuery.text,
+            returned_fact_ids: returnedFactIds,
+            result_count: points.length,
+            search_scope: args.searchScope.name,
+            searched_destinations: args.searchedDestinations,
+            failed_destinations: args.failedDestinations.map((failure) => `${failure.destination}: ${failure.error}`),
+            created_at: now,
+            updated_at: now,
+        };
+        addRedactionPayload(eventPayload, redactedEvent);
+        try {
+            const eventVector = await embed(redactedEvent.text);
+            await qdrantUpsert(dest, newId(), eventVector, eventPayload);
+        }
+        catch (e) {
+            log("WARN", `Failed to record recall_event: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+}
 function resolveSearchScopeOrError(args) {
     if (args.destination && args.search_scope !== undefined) {
         return {
@@ -126,21 +242,17 @@ function resolveSearchScopeOrError(args) {
         };
     }
 }
-// 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) {
-        const metadata = payload["metadata"] && typeof payload["metadata"] === "object" && !Array.isArray(payload["metadata"])
-            ? payload["metadata"]
-            : {};
-        metadata["actor_label"] = actor.actor_label;
-        if (actor.source)
-            metadata["actor_source"] = actor.source;
-        payload["metadata"] = metadata;
-    }
+function mcpOrigin(input) {
+    return buildOperationOrigin({
+        interface: "mcp",
+        agentType: "coding_agent",
+        action: input.action,
+        tool: input.tool,
+        outcome: input.outcome,
+        config: loadConfig(),
+        cwd: process.cwd(),
+        metadata: input.metadata,
+    });
 }
 async function getPointForWrite(dest, factId) {
     const existing = await qdrantGetPoints(dest, [factId]);
@@ -198,9 +310,8 @@ function buildMemoryNudge() {
     // session typically produces. The agent picks the best fit.
     return `🧠 Memory nudge: No memory_store calls in ${mins} minutes. ` +
         "Reflect on what's worth persisting:\n" +
-        "  • engineering — codebase maps, architecture, infra, ops, troubleshooting?\n" +
+        "  • engineering — codebase maps, architecture, infra, ops, troubleshooting, preferences, ownership, working agreements, activity events?\n" +
         "  • product — requirements, decisions, workflows, roadmap, metrics, market insight?\n" +
-        "  • human — preferences, owners, working agreements, durable activity events?\n" +
         "  • system — session, episode, workstream, or quality-rollup memory?\n" +
         "If yes, call memory_store now so future sessions inherit the knowledge.";
 }
@@ -524,14 +635,12 @@ export function registerTools(mcp) {
         memory_subtype: z.enum(memorySubtypeValues()).optional().describe(memorySubtypeEnumDescription()),
         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)."),
         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 fact relates to (e.g. 'bikky-dev/bikky')."),
         branch: z.string().optional().describe("Branch or working surface (e.g. 'main', 'feat/x')."),
         review_status: z.enum(["candidate", "reviewed", "approved", "rejected"]).optional().describe("Review lifecycle status. candidate=auto-extracted (daemon), reviewed=human-checked, approved=human-confirmed, rejected=incorrect. Agents normally leave this unset."),
-        source: z.enum(sourceValues()).default(DEFAULT_SOURCE).describe(sourceEnumDescription()),
         confidence: z.number().min(0).max(1).default(0.9).describe("How certain you are this fact is correct (0.0-1.0). Default 0.9. Lower (~0.6) for inferred or unverified facts."),
         importance: z.number().min(0).max(1).optional().describe("How important this fact is for future recall (0.0-1.0). Defaults to 0.5 if omitted. ≥0.8 surfaces in session briefings."),
         supersedes: z.string().optional().describe("ID of an existing fact that this one replaces. The old fact is marked superseded and excluded from recall. Use this when a fact is updated; use memory_forget when a fact was simply wrong."),
@@ -541,22 +650,12 @@ 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: _workspace_id, destination, 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, episode_id, workstream_key, task_key, repo, branch, review_status, confidence, importance, supersedes, relation, metadata, }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         lastStoreTime = Date.now();
         const now = nowISO();
-        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;
         try {
@@ -599,6 +698,44 @@ export function registerTools(mcp) {
             type: redactedRelation.type.text,
             to: redactedRelation.to.text,
         } : null;
+        const resolved = resolveDestOrError(memoryWriteRoutingInput({
+            tool: "memory_store",
+            destination,
+            content: redactedContent.text,
+            entities: normalizedEntities,
+            metadata,
+            relation: sanitizedRelation,
+            context: {
+                category: normalizedCategory,
+                domain: normalizedDomain,
+                kind: normalizedKind,
+                memory_subtype: normalizedSubtype,
+                layer: normalizedLayer,
+                episode_id,
+                workstream_key,
+                task_key,
+                repo,
+                branch,
+                review_status,
+                supersedes,
+            },
+        }));
+        if (resolved.error)
+            return resolved.error;
+        const dest = resolved.dest;
+        const createOrigin = mcpOrigin({
+            action: "create",
+            tool: "memory_store",
+            metadata: {
+                destination: dest.name,
+                category: normalizedCategory,
+                kind: normalizedKind,
+                ...(normalizedSubtype ? { memory_subtype: normalizedSubtype } : {}),
+                ...(task_key ? { task_key } : {}),
+                ...(repo ? { repo } : {}),
+                ...(branch ? { branch } : {}),
+            },
+        });
         // 1. Exact dedup via content hash
         try {
             const hashFilter = buildFilter({}) ?? { must: [] };
@@ -612,6 +749,12 @@ export function registerTools(mcp) {
                     reinforcement_count: count,
                     last_reinforced_at: now,
                     updated_at: now,
+                    last_operation_origin: mcpOrigin({
+                        action: "reinforce",
+                        tool: "memory_store",
+                        outcome: "exact_duplicate",
+                        metadata: { destination: dest.name, fact_id: point.id },
+                    }),
                 });
                 return {
                     content: [{ type: "text", text: JSON.stringify({
@@ -647,6 +790,12 @@ export function registerTools(mcp) {
                         reinforcement_count: count,
                         last_reinforced_at: now,
                         updated_at: now,
+                        last_operation_origin: mcpOrigin({
+                            action: "reinforce",
+                            tool: "memory_store",
+                            outcome: "semantic_duplicate",
+                            metadata: { destination: dest.name, fact_id: point.id, similarity: topScore },
+                        }),
                     });
                     return {
                         content: [{ type: "text", text: JSON.stringify({
@@ -700,6 +849,12 @@ export function registerTools(mcp) {
                 await qdrantSetPayload(dest, [supersedes], {
                     superseded_by: factId,
                     superseded_at: now,
+                    updated_at: now,
+                    last_operation_origin: mcpOrigin({
+                        action: "supersede",
+                        tool: "memory_store",
+                        metadata: { destination: dest.name, new_fact_id: factId },
+                    }),
                 });
             }
             catch (e) {
@@ -713,7 +868,7 @@ export function registerTools(mcp) {
             domain: normalizedDomain,
             kind: normalizedKind,
             entities: normalizedEntities,
-            source,
+            origin: createOrigin,
             confidence,
             importance: importance ?? 0.5,
             content_hash: hash,
@@ -745,7 +900,6 @@ export function registerTools(mcp) {
         }
         if (review_status)
             payload["review_status"] = review_status;
-        addActorPayload(payload, actor);
         addRedactionPayload(payload, factRedactionSummary);
         await qdrantUpsert(dest, factId, vector, payload);
         // 7. Insert relation point if provided
@@ -761,7 +915,15 @@ export function registerTools(mcp) {
                 kind: "relation",
                 layer: "memory_object",
                 entities: [sanitizedRelation.from.toLowerCase(), sanitizedRelation.to.toLowerCase()],
-                source,
+                origin: mcpOrigin({
+                    action: "create",
+                    tool: "memory_store",
+                    metadata: {
+                        destination: dest.name,
+                        parent_fact_id: factId,
+                        relation_type: sanitizedRelation.type.toLowerCase(),
+                    },
+                }),
                 confidence,
                 content_hash: contentHash("relation", relContent),
                 reinforcement_count: 1,
@@ -774,7 +936,6 @@ export function registerTools(mcp) {
                 relation_type: sanitizedRelation.type.toLowerCase(),
                 to_entity: sanitizedRelation.to.toLowerCase(),
             };
-            addActorPayload(relPayload, actor);
             addRedactionPayload(relPayload, relationRedactionSummary);
             await qdrantUpsert(dest, relationId, relVector, relPayload);
         }
@@ -782,9 +943,8 @@ export function registerTools(mcp) {
             action: "inserted",
             fact_id: factId,
             destination: dest.name,
+            origin: createOrigin,
         };
-        if (actor.actor_id)
-            result["actor_id"] = actor.actor_id;
         if (relationId)
             result["relation_id"] = relationId;
         if (redactionSummary.redacted)
@@ -819,7 +979,9 @@ export function registerTools(mcp) {
         workspace_id: z.string().optional().describe("[Removed in v0.4.0] No-op."),
         destination: z.string().optional().describe("Optional legacy single-destination override. Do not combine with search_scope. Prefer search_scope for routed/all/list search."),
         search_scope: searchScopeSchema.describe("Optional read/search scope. Accepts 'routed', 'all', a destination name, a configured scope name, a comma-separated destination list, or an array of destination names. Omit to use config.default_search_scope."),
-        actor_id: z.string().optional().describe("Filter to facts captured by or associated with this stable actor identity. Optional."),
+        origin_user_id: z.string().optional().describe("Filter to facts whose creation origin.user.id matches this value. Optional."),
+        origin_agent_id: z.string().optional().describe("Filter to facts whose creation origin.agent.id matches this value. Optional."),
+        origin_interface: z.enum(["mcp", "daemon", "ui", "api", "cli", "system"]).optional().describe("Filter to facts created through this origin interface. Optional."),
         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."),
@@ -834,13 +996,12 @@ 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: _workspace_id, destination, search_scope, actor_id, include_legacy_workspace: _include_legacy_workspace, entity, episode_id, workstream_key, task_key, repo, branch, review_status, since, until, limit, graph_depth, output_format, metadata_filter, }) => {
+    }, async ({ query, category, domain, kind, memory_subtype, workspace_id: _workspace_id, destination, search_scope, origin_user_id, origin_agent_id, origin_interface, 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 scopeResolved = resolveSearchScopeOrError({
             destination,
             search_scope,
@@ -873,7 +1034,9 @@ export function registerTools(mcp) {
             domain: domain ? normalizeDomain(domain) : undefined,
             kind: normalizedKind,
             memory_subtype: normalizedSubtype,
-            actor_id: actorFilter.actor_id,
+            origin_user_id,
+            origin_agent_id,
+            origin_interface,
             entity,
             episode_id,
             workstream_key,
@@ -947,6 +1110,13 @@ export function registerTools(mcp) {
             .map((r) => ({ ...r, _combinedScore: computeCombinedScore(r) }))
             .sort((a, b) => b._combinedScore - a._combinedScore)
             .slice(0, effectiveLimit);
+        await recordRecallTelemetry({
+            ranked,
+            redactedQuery,
+            searchScope,
+            searchedDestinations,
+            failedDestinations,
+        });
         const includeDestination = searchScope.destinations.length > 1 || searchScope.name === "all";
         const lines = ranked.map((r) => formatScopedFact(r, includeDestination));
         const related = { points: [], errors: [] };
@@ -1239,6 +1409,11 @@ export function registerTools(mcp) {
                 superseded_by: `forgotten:${redactedReason.text}`,
                 superseded_at: now,
                 updated_at: now,
+                last_operation_origin: mcpOrigin({
+                    action: "forget",
+                    tool: "memory_forget",
+                    metadata: { destination: dest.name, fact_id },
+                }),
                 // Mark this fact's vector as a bad-exemplar centroid: future
                 // candidates with high cosine similarity will be auto-flagged
                 // for review. Forgotten facts keep their original vector — the
@@ -1284,6 +1459,11 @@ export function registerTools(mcp) {
                 last_reinforced_at: now,
                 verification_count: newCount,
                 updated_at: now,
+                last_operation_origin: mcpOrigin({
+                    action: "verify",
+                    tool: "memory_verify",
+                    metadata: { destination: dest.name, fact_id },
+                }),
             });
             return {
                 content: [{ type: "text", text: JSON.stringify({
@@ -1318,13 +1498,19 @@ export function registerTools(mcp) {
             if (!located)
                 return notFoundResult(fact_id);
             const { dest, point } = located;
-            const actor = resolveActorIdentity({ config: loadConfig() });
             const currentCount = point.payload.useful_count ?? 0;
             const newCount = currentCount + 1;
+            const feedbackOrigin = mcpOrigin({
+                action: "feedback",
+                tool: "memory_mark_useful",
+                outcome: "useful",
+                metadata: { destination: dest.name, fact_id },
+            });
             await qdrantSetPayload(dest, [fact_id], {
                 useful_count: newCount,
                 last_useful_at: now,
                 updated_at: now,
+                last_operation_origin: feedbackOrigin,
             });
             // Write a telemetry feedback_event row so the signal is also visible
             // to aggregations and review tooling.
@@ -1341,7 +1527,7 @@ export function registerTools(mcp) {
                 memory_subtype: "feedback_event",
                 layer: "memory_object",
                 entities: [],
-                source: "agent",
+                origin: feedbackOrigin,
                 confidence: 1.0,
                 importance: 0.3,
                 content_hash: contentHash("feedback_event", `${fact_id}:useful:${now}`),
@@ -1350,7 +1536,6 @@ export function registerTools(mcp) {
                 created_at: now,
                 updated_at: now,
             };
-            addActorPayload(eventPayload, actor);
             addRedactionPayload(eventPayload, redactedEvent);
             try {
                 const eventVector = await embed(redactedEvent.text);
@@ -1392,8 +1577,20 @@ export function registerTools(mcp) {
             const located = await locatePoint(fact_id);
             if (!located)
                 return notFoundResult(fact_id);
-            const { dest } = located;
-            const actor = resolveActorIdentity({ config: loadConfig() });
+            const { dest, point } = located;
+            const counterField = outcomeCounterField(outcome);
+            const counterValue = payloadCounter(point.payload, counterField) + 1;
+            const feedbackOrigin = mcpOrigin({
+                action: "feedback",
+                tool: "memory_report_outcome",
+                outcome,
+                metadata: { destination: dest.name, fact_id },
+            });
+            await qdrantSetPayload(dest, [fact_id], {
+                [counterField]: counterValue,
+                updated_at: now,
+                last_operation_origin: feedbackOrigin,
+            });
             const eventId = newId();
             const eventContent = notes
                 ? `Fact ${fact_id} outcome=${outcome}: ${notes}`
@@ -1407,7 +1604,7 @@ export function registerTools(mcp) {
                 memory_subtype: "outcome_event",
                 layer: "memory_object",
                 entities: [],
-                source: "agent",
+                origin: feedbackOrigin,
                 confidence: 1.0,
                 importance: outcome === "wrong" || outcome === "misleading" ? 0.6 : 0.3,
                 content_hash: contentHash("outcome_event", `${fact_id}:${outcome}:${now}`),
@@ -1416,7 +1613,6 @@ export function registerTools(mcp) {
                 created_at: now,
                 updated_at: now,
             };
-            addActorPayload(eventPayload, actor);
             addRedactionPayload(eventPayload, redactedEvent);
             const eventVector = await embed(redactedEvent.text);
             await qdrantUpsert(dest, eventId, eventVector, eventPayload);
@@ -1426,6 +1622,7 @@ export function registerTools(mcp) {
                             fact_id,
                             destination: dest.name,
                             outcome,
+                            [counterField]: counterValue,
                             event_id: eventId,
                         }) }],
             };
@@ -1437,7 +1634,7 @@ export function registerTools(mcp) {
     // ── memory_session_summary ──────────────────────────────────────────────
     mcp.tool("memory_session_summary", [
         "Persist a compact summary of the current session — what got done, what decisions were made, what's still open.",
-        "Stored as kind='summary', memory_subtype='session_index', source='agent'. Keep it short (target 30-80 words). Future sessions retrieve these via memory_recall to bootstrap context faster than re-reading the original transcript.",
+        "Stored as kind='summary', memory_subtype='session_index' with canonical origin metadata. Keep it short (target 30-80 words). Future sessions retrieve these via memory_recall to bootstrap context faster than re-reading the original transcript.",
         "Call this near session close (or at major milestone boundaries) when the work is meaningful enough to want a future agent to inherit. Skip for trivial single-question sessions.",
     ].join(" "), {
         content: z.string().describe("The summary text. Atomic, self-contained, 30-80 words ideally. Should answer: what was the goal, what did we do, what remains?"),
@@ -1448,27 +1645,48 @@ export function registerTools(mcp) {
         repo: z.string().optional().describe("Repository or project surface this summary relates to."),
         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: _workspace_id, destination, actor_id }) => {
+    }, async ({ content, entities, episode_id, workstream_key, task_key, repo, workspace_id: _workspace_id, destination }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         lastStoreTime = Date.now();
         const now = nowISO();
         try {
-            const resolved = resolveDestOrError(routingInput({
+            const normalizedEntities = (entities ?? []).map((e) => e.trim().toLowerCase()).filter(Boolean);
+            const redactedContent = redactStorageText(content);
+            const resolved = resolveDestOrError(memoryWriteRoutingInput({
+                tool: "memory_session_summary",
                 destination,
-                content,
-                entities: entities ?? [],
+                content: redactedContent.text,
+                entities: normalizedEntities,
+                context: {
+                    category: categoryForMemorySubtype("session_index") ?? "system",
+                    domain: "software_engineering",
+                    kind: "summary",
+                    memory_subtype: "session_index",
+                    layer: layerForMemorySubtype("session_index") ?? "episode",
+                    episode_id,
+                    workstream_key,
+                    task_key,
+                    repo,
+                },
             }));
             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();
-            const redactedContent = redactStorageText(content);
             const vector = await embed(redactedContent.text);
+            const origin = mcpOrigin({
+                action: "create",
+                tool: "memory_session_summary",
+                metadata: {
+                    destination: dest.name,
+                    ...(episode_id ? { episode_id } : {}),
+                    ...(workstream_key ? { workstream_key } : {}),
+                    ...(task_key ? { task_key } : {}),
+                    ...(repo ? { repo } : {}),
+                },
+            });
             const payload = {
                 content: redactedContent.text,
                 category: categoryForMemorySubtype("session_index") ?? "system",
@@ -1477,7 +1695,7 @@ export function registerTools(mcp) {
                 memory_subtype: "session_index",
                 layer: layerForMemorySubtype("session_index") ?? "episode",
                 entities: normalizedEntities,
-                source: "agent",
+                origin,
                 confidence: 0.9,
                 importance: 0.6,
                 content_hash: contentHash("summary", redactedContent.text),
@@ -1496,7 +1714,6 @@ export function registerTools(mcp) {
                 payload["task_key"] = task_key;
             if (repo)
                 payload["repo"] = repo;
-            addActorPayload(payload, actor);
             addRedactionPayload(payload, redactedContent);
             await qdrantUpsert(dest, summaryId, vector, payload);
             return {
@@ -1504,7 +1721,7 @@ export function registerTools(mcp) {
                             status: "summary_stored",
                             summary_id: summaryId,
                             destination: dest.name,
-                            actor_id: actor.actor_id,
+                            origin,
                         }) }],
             };
         }
@@ -1515,7 +1732,7 @@ export function registerTools(mcp) {
     // ── memory_distill ──────────────────────────────────────────────────────
     mcp.tool("memory_distill", [
         "Persist a distilled convention — a reusable learning, pattern, or runbook synthesized from multiple prior memories.",
-        "Stored as kind='distilled', memory_subtype='convention', source='agent'. Use this when you've noticed a pattern across several prior facts/sessions that's worth surfacing as its own atomic learning. The new memory will rank above raw facts in semantic recall because distilled patterns are higher-signal.",
+        "Stored as kind='distilled', memory_subtype='convention' with canonical origin metadata. Use this when you've noticed a pattern across several prior facts/sessions that's worth surfacing as its own atomic learning. The new memory will rank above raw facts in semantic recall because distilled patterns are higher-signal.",
         "Provide 'supersedes' if this distillation replaces an earlier convention. The original stays in storage but is excluded from recall.",
     ].join(" "), {
         content: z.string().describe("One-sentence reusable convention or pattern. Should be self-contained and applicable beyond a single situation."),
@@ -1525,27 +1742,46 @@ export function registerTools(mcp) {
         repo: z.string().optional().describe("Repository or project surface this learning applies to."),
         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: _workspace_id, destination, actor_id }) => {
+    }, async ({ content, entities, supersedes, task_key, repo, workspace_id: _workspace_id, destination }) => {
         const guard = requireReady();
         if (guard)
             return guard;
         lastStoreTime = Date.now();
         const now = nowISO();
         try {
-            const resolved = resolveDestOrError(routingInput({
+            const normalizedEntities = entities.map((e) => e.trim().toLowerCase()).filter(Boolean);
+            const redactedContent = redactStorageText(content);
+            const resolved = resolveDestOrError(memoryWriteRoutingInput({
+                tool: "memory_distill",
                 destination,
-                content,
-                entities,
+                content: redactedContent.text,
+                entities: normalizedEntities,
+                context: {
+                    category: categoryForMemorySubtype("convention") ?? "engineering",
+                    domain: "software_engineering",
+                    kind: "distilled",
+                    memory_subtype: "convention",
+                    layer: layerForMemorySubtype("convention") ?? "domain",
+                    task_key,
+                    repo,
+                    supersedes,
+                },
             }));
             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);
+            const origin = mcpOrigin({
+                action: "create",
+                tool: "memory_distill",
+                metadata: {
+                    destination: dest.name,
+                    ...(task_key ? { task_key } : {}),
+                    ...(repo ? { repo } : {}),
+                    ...(supersedes ? { supersedes } : {}),
+                },
+            });
             if (supersedes) {
                 // Supersede may live in a different destination — locate it.
                 const located = await locatePoint(supersedes);
@@ -1554,6 +1790,12 @@ export function registerTools(mcp) {
                 await qdrantSetPayload(located.dest, [supersedes], {
                     superseded_by: distilledId,
                     superseded_at: now,
+                    updated_at: now,
+                    last_operation_origin: mcpOrigin({
+                        action: "supersede",
+                        tool: "memory_distill",
+                        metadata: { destination: located.dest.name, new_fact_id: distilledId },
+                    }),
                 });
             }
             const payload = {
@@ -1564,7 +1806,7 @@ export function registerTools(mcp) {
                 memory_subtype: "convention",
                 layer: layerForMemorySubtype("convention") ?? "domain",
                 entities: normalizedEntities,
-                source: "agent",
+                origin,
                 confidence: 0.9,
                 importance: 0.7,
                 content_hash: contentHash("distilled", redactedContent.text),
@@ -1579,7 +1821,6 @@ export function registerTools(mcp) {
                 payload["task_key"] = task_key;
             if (repo)
                 payload["repo"] = repo;
-            addActorPayload(payload, actor);
             addRedactionPayload(payload, redactedContent);
             await qdrantUpsert(dest, distilledId, vector, payload);
             return {
@@ -1588,7 +1829,7 @@ export function registerTools(mcp) {
                             distilled_id: distilledId,
                             destination: dest.name,
                             supersedes: supersedes ?? null,
-                            actor_id: actor.actor_id,
+                            origin,
                         }) }],
             };
         }
@@ -1598,8 +1839,8 @@ export function registerTools(mcp) {
     });
     // ── memory_review ───────────────────────────────────────────────────────
     mcp.tool("memory_review", [
-        "Triage facts that were captured automatically by Bikky (source='system').",
-        "Only useful when the daemon is running and capturing memories from logs/transcripts; otherwise this returns an empty list. Supports four actions: list (default — show recent system-captured facts), approve (mark verified), reject (mark superseded with reason), correct (replace with edited content as a new fact).",
+        "Triage facts that were captured automatically by Bikky (origin.interface='daemon' or legacy source='system').",
+        "Only useful when the daemon is running and capturing memories from logs/transcripts; otherwise this returns an empty list. Supports four actions: list (default — show recent daemon/system-captured facts), approve (mark verified), reject (mark superseded with reason), correct (replace with edited content as a new fact).",
     ].join(" "), {
         limit: z.number().optional().default(10).describe("Max facts to return when action=list (default 10)."),
         action: z.enum(["list", "approve", "reject", "correct"]).optional().default("list").describe("What to do. list = show recent system-captured facts (default). approve = confirm a fact is correct (bumps verification count). reject = mark a fact as wrong (requires 'reason'). correct = supersede with an edited version (requires 'corrected_content')."),
@@ -1616,7 +1857,14 @@ export function registerTools(mcp) {
             // List spans all destinations.
             const destinations = listDestinations();
             const allPoints = [];
-            const filter = { must: [{ key: "source", match: { any: ["system", "daemon"] } }] };
+            const filter = {
+                must: [],
+                should: [
+                    { key: "origin.interface", match: { value: "daemon" } },
+                    { key: "origin.agent.type", match: { any: ["daemon", "system"] } },
+                    { key: "source", match: { any: ["system", "daemon"] } },
+                ],
+            };
             for (const dest of destinations) {
                 try {
                     const result = await qdrantScroll(dest, filter, (limit ?? 10) * 2);
@@ -1654,6 +1902,12 @@ export function registerTools(mcp) {
                 last_verified_at: now,
                 verification_count: currentCount + 1,
                 updated_at: now,
+                last_operation_origin: mcpOrigin({
+                    action: "review",
+                    tool: "memory_review",
+                    outcome: "approved",
+                    metadata: { destination: dest.name, fact_id },
+                }),
             });
             return { content: [{ type: "text", text: JSON.stringify({ status: "approved", fact_id, destination: dest.name }) }] };
         }
@@ -1670,6 +1924,12 @@ export function registerTools(mcp) {
                 superseded_by: `rejected:${redactedReason.text}`,
                 superseded_at: now,
                 updated_at: now,
+                last_operation_origin: mcpOrigin({
+                    action: "review",
+                    tool: "memory_review",
+                    outcome: "rejected",
+                    metadata: { destination: dest.name, fact_id },
+                }),
             });
             return { content: [{ type: "text", text: JSON.stringify({
                             status: "rejected",
@@ -1689,11 +1949,15 @@ export function registerTools(mcp) {
             const { dest, point } = located;
             const origPayload = point.payload;
             const redactedCorrected = redactStorageText(corrected_content);
-            const actor = resolveActorIdentity({ config: loadConfig() });
             const vector = await embed(redactedCorrected.text);
             const correctedId = crypto.randomUUID();
             const origCategory = normalizeCategory(origPayload?.category ?? DEFAULT_CATEGORY);
             const hash = contentHash(origCategory, redactedCorrected.text);
+            const correctOrigin = mcpOrigin({
+                action: "correct",
+                tool: "memory_review",
+                metadata: { destination: dest.name, corrected_from: fact_id },
+            });
             const correctedPayload = {
                 content: redactedCorrected.text,
                 category: origCategory,
@@ -1707,7 +1971,7 @@ export function registerTools(mcp) {
                 ...(origPayload?.repo ? { repo: origPayload.repo } : {}),
                 ...(origPayload?.branch ? { branch: origPayload.branch } : {}),
                 entities: origPayload?.entities ?? [],
-                source: "user",
+                origin: correctOrigin,
                 confidence: 0.95,
                 importance: origPayload?.importance ?? 0.5,
                 content_hash: hash,
@@ -1719,13 +1983,18 @@ export function registerTools(mcp) {
                 updated_at: now,
                 metadata: { ...(origPayload?.metadata ?? {}), corrected_from: fact_id },
             };
-            addActorPayload(correctedPayload, actor);
             addRedactionPayload(correctedPayload, redactedCorrected);
             await qdrantUpsert(dest, correctedId, vector, correctedPayload);
             await qdrantSetPayload(dest, [fact_id], {
                 superseded_by: correctedId,
                 superseded_at: now,
                 updated_at: now,
+                last_operation_origin: mcpOrigin({
+                    action: "supersede",
+                    tool: "memory_review",
+                    outcome: "corrected",
+                    metadata: { destination: dest.name, 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 }) }] };
         }
@@ -1745,7 +2014,7 @@ export function registerTools(mcp) {
             try {
                 const staleThreshold = new Date(Date.now() - STALENESS_DAYS * 86400000).toISOString();
                 const staleFilter = { must: [] };
-                staleFilter.must.push({ key: "category", match: { any: ["engineering", "product", "human", "system"] } });
+                staleFilter.must.push({ key: "category", match: { any: ["engineering", "product", "system"] } });
                 staleFilter.should = [
                     { key: "last_reinforced_at", range: { lte: staleThreshold } },
                     { is_null: { key: "last_reinforced_at" } },
@@ -1784,10 +2053,9 @@ export function registerTools(mcp) {
             }
         }
         sections.push("🔍 Reflect: think about the LAST 10 minutes of work and answer in your head:\n" +
-            "  1. Did you touch engineering context: code, infra, ops, access, troubleshooting, or conventions?\n" +
+            "  1. Did you touch engineering context: code, infra, ops, access, troubleshooting, conventions, preferences, ownership, working agreements, or durable activity events?\n" +
             "  2. Did you capture product context: a requirement, decision, workflow, roadmap item, metric, or market insight?\n" +
-            "  3. Did you learn human context: a preference, owner, working agreement, person profile, or durable activity event?\n" +
-            "  4. Did the work produce system context: session, episode, workstream, recall, feedback, outcome, or rollup state?\n" +
+            "  3. Did the work produce system context: session, episode, workstream, recall, feedback, outcome, or rollup state?\n" +
             "If any answer is yes, call memory_store now — one atomic fact per item, with category/domain/entities.");
         return { content: [{ type: "text", text: sections.join("\n\n") }] };
     });