bikky 0.4.3 → 0.4.4

package/dist/mcp/taxonomy.js

@@ -22,13 +22,6 @@ export const CATEGORIES = {
             "Activation should be measured by whether agents successfully reuse recalled memory.",
         ],
     },
-    human: {
-        description: "Human context: explicit preferences, people and roles, ownership, working agreements, and durable actor-action activity events.",
-        examples: [
-            "Saber prefers concise implementation plans before code changes.",
-            "Alex approved PR #85 for merge.",
-        ],
-    },
     system: {
         description: "System context: Bikky-owned lifecycle memory, session indexes, episodes, workstreams, recall/feedback/outcome telemetry, and aggregate rollups.",
         examples: [
@@ -47,7 +40,6 @@ export const DOMAINS = {
         defaultCategories: [
             "engineering",
             "product",
-            "human",
             "system",
         ],
     },
@@ -55,7 +47,7 @@ export const DOMAINS = {
         description: "Product direction, positioning, roadmap tradeoffs, customer problems, metrics, and market learning.",
         defaultCategories: [
             "product",
-            "human",
+            "engineering",
             "system",
         ],
     },
@@ -63,7 +55,7 @@ export const DOMAINS = {
         description: "Business process, vendors, finance, legal/admin operations, recurring procedures, and ownership.",
         defaultCategories: [
             "product",
-            "human",
+            "engineering",
             "system",
         ],
     },
@@ -78,7 +70,7 @@ export const DOMAINS = {
     personal_productivity: {
         description: "Individual productivity, habits, planning preferences, reminders, and personal operating context.",
         defaultCategories: [
-            "human",
+            "engineering",
             "product",
             "system",
         ],
@@ -195,11 +187,11 @@ export const MEMORY_SUBTYPE_DEFAULT_CATEGORY = {
     success_metric: "product",
     market_insight: "product",
     troubleshooting_gotcha: "engineering",
-    preference: "human",
-    person_profile: "human",
-    ownership_note: "human",
-    working_agreement: "human",
-    activity_event: "human",
+    preference: "engineering",
+    person_profile: "engineering",
+    ownership_note: "engineering",
+    working_agreement: "engineering",
+    activity_event: "engineering",
     session_index: "system",
     episode: "system",
     workstream: "system",
@@ -267,19 +259,18 @@ export const DECAY_HALF_LIFE = {
     // Software-engineering defaults.
     "engineering.software_engineering": 120,
     "product.software_engineering": 120,
-    "human.software_engineering": 180,
     "system.software_engineering": 45,
     // Other domain profiles.
+    "engineering.product_strategy": 180,
     "product.product_strategy": 180,
-    "human.product_strategy": 180,
     "system.product_strategy": 60,
+    "engineering.business_operations": 180,
     "product.business_operations": 120,
-    "human.business_operations": 180,
     "system.business_operations": 90,
     "product.research": 120,
     "engineering.research": 120,
     "system.research": 90,
-    "human.personal_productivity": 180,
+    "engineering.personal_productivity": 180,
     "product.personal_productivity": 90,
     "system.personal_productivity": 45,
 };
@@ -329,6 +320,22 @@ export const QDRANT_INDEXES = [
     { field_name: "superseded", field_schema: "bool" },
     { field_name: "superseded_by", field_schema: "keyword" },
     { field_name: "is_bad_exemplar", field_schema: "bool" },
+    { field_name: "target_fact_id", field_schema: "keyword" },
+    { field_name: "feedback_kind", field_schema: "keyword" },
+    { field_name: "outcome", field_schema: "keyword" },
+    { field_name: "result_count", field_schema: "integer" },
+    { field_name: "scope_type", field_schema: "keyword" },
+    { field_name: "scope_value", field_schema: "keyword" },
+    { field_name: "rollup_type", field_schema: "keyword" },
+    { field_name: "rollup_generated_at", field_schema: "datetime" },
+    { field_name: "active_fact_count", field_schema: "integer" },
+    { field_name: "useful_count", field_schema: "integer" },
+    { field_name: "not_useful_count", field_schema: "integer" },
+    { field_name: "misleading_count", field_schema: "integer" },
+    { field_name: "wrong_count", field_schema: "integer" },
+    { field_name: "irrelevant_count", field_schema: "integer" },
+    { field_name: "stale_count", field_schema: "integer" },
+    { field_name: "low_confidence_count", field_schema: "integer" },
     { field_name: "useful_feedback_count", field_schema: "integer" },
     { field_name: "not_useful_feedback_count", field_schema: "integer" },
     { field_name: "recall_count", field_schema: "integer" },
@@ -358,16 +365,6 @@ export function normalizeCategory(category) {
         normalized.includes("customer") ||
         normalized === "projects")
         return "product";
-    if (normalized.includes("human") ||
-        normalized.includes("people") ||
-        normalized.includes("person") ||
-        normalized.includes("owner") ||
-        normalized.includes("team") ||
-        normalized.includes("preference") ||
-        normalized.includes("agreement") ||
-        normalized.includes("activity") ||
-        normalized.includes("actor"))
-        return "human";
     if (normalized.includes("system") ||
         normalized.includes("session") ||
         normalized.includes("episode") ||
@@ -385,7 +382,16 @@ export function normalizeCategory(category) {
         normalized.includes("code") ||
         normalized.includes("architecture") ||
         normalized.includes("troubleshoot") ||
-        normalized.includes("observation"))
+        normalized.includes("observation") ||
+        normalized.includes("human") ||
+        normalized.includes("people") ||
+        normalized.includes("person") ||
+        normalized.includes("owner") ||
+        normalized.includes("team") ||
+        normalized.includes("preference") ||
+        normalized.includes("agreement") ||
+        normalized.includes("activity") ||
+        normalized.includes("actor"))
         return "engineering";
     return DEFAULT_CATEGORY;
 }
@@ -514,15 +520,6 @@ export function getDecayHalfLife(input) {
         rawCategory.includes("market") ||
         rawCategory.includes("customer") ||
         rawCategory === "projects" ||
-        rawCategory.includes("human") ||
-        rawCategory.includes("people") ||
-        rawCategory.includes("person") ||
-        rawCategory.includes("owner") ||
-        rawCategory.includes("team") ||
-        rawCategory.includes("preference") ||
-        rawCategory.includes("agreement") ||
-        rawCategory.includes("activity") ||
-        rawCategory.includes("actor") ||
         rawCategory.includes("system") ||
         rawCategory.includes("session") ||
         rawCategory.includes("episode") ||
@@ -539,7 +536,16 @@ export function getDecayHalfLife(input) {
         rawCategory.includes("code") ||
         rawCategory.includes("architecture") ||
         rawCategory.includes("troubleshoot") ||
-        rawCategory.includes("observation");
+        rawCategory.includes("observation") ||
+        rawCategory.includes("human") ||
+        rawCategory.includes("people") ||
+        rawCategory.includes("person") ||
+        rawCategory.includes("owner") ||
+        rawCategory.includes("team") ||
+        rawCategory.includes("preference") ||
+        rawCategory.includes("agreement") ||
+        rawCategory.includes("activity") ||
+        rawCategory.includes("actor");
     if (categoryWasProvided && !categoryIsKnown) {
         return DECAY_DEFAULT_HALF_LIFE;
     }

package/dist/mcp/tools.js

@@ -13,6 +13,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { inspectWatcherPaths, formatIssue, repairSuspiciousWatcherPaths } from "../daemon/watcher-health.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 {
@@ -194,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.";
 }
@@ -541,15 +656,6 @@ export function registerTools(mcp) {
             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 normalizedKind = normalizeKind(kind);
         let normalizedSubtype = null;
         try {
@@ -592,6 +698,31 @@ 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",
@@ -979,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: [] };
@@ -1439,7 +1577,9 @@ export function registerTools(mcp) {
             const located = await locatePoint(fact_id);
             if (!located)
                 return notFoundResult(fact_id);
-            const { dest } = located;
+            const { dest, point } = located;
+            const counterField = outcomeCounterField(outcome);
+            const counterValue = payloadCounter(point.payload, counterField) + 1;
             const feedbackOrigin = mcpOrigin({
                 action: "feedback",
                 tool: "memory_report_outcome",
@@ -1447,6 +1587,7 @@ export function registerTools(mcp) {
                 metadata: { destination: dest.name, fact_id },
             });
             await qdrantSetPayload(dest, [fact_id], {
+                [counterField]: counterValue,
                 updated_at: now,
                 last_operation_origin: feedbackOrigin,
             });
@@ -1481,6 +1622,7 @@ export function registerTools(mcp) {
                             fact_id,
                             destination: dest.name,
                             outcome,
+                            [counterField]: counterValue,
                             event_id: eventId,
                         }) }],
             };
@@ -1510,17 +1652,29 @@ export function registerTools(mcp) {
         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 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",
@@ -1595,17 +1749,28 @@ export function registerTools(mcp) {
         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 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",
@@ -1849,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" } },
@@ -1888,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") }] };
     });

package/dist/mcp/types.d.ts

@@ -87,8 +87,16 @@ export interface FactPayload {
     verification_count?: number;
     useful_count?: number;
     not_useful_count?: number;
+    useful_feedback_count?: number;
+    not_useful_feedback_count?: number;
+    misleading_count?: number;
+    wrong_count?: number;
+    irrelevant_count?: number;
+    last_useful_at?: string;
     last_used_at?: string;
     last_feedback_at?: string;
+    recall_count?: number;
+    last_recalled_at?: string;
     superseded_by: string | null;
     superseded_at: string | null;
     created_at: string;
@@ -139,9 +147,24 @@ export interface FactPayload {
     event_session_id?: string;
     recall_query?: string;
     returned_fact_ids?: string[];
+    result_count?: number;
+    search_scope?: string;
+    searched_destinations?: string[];
+    failed_destinations?: string[];
+    target_fact_id?: string;
     feedback_note?: string;
+    feedback_kind?: string;
     outcome?: string;
     outcome_summary?: string;
+    scope_type?: string;
+    scope_value?: string;
+    rollup_type?: string;
+    rollup_generated_at?: string;
+    rollup_window_start?: string;
+    rollup_window_end?: string;
+    active_fact_count?: number;
+    stale_count?: number;
+    low_confidence_count?: number;
 }
 export interface FilterParams {
     category?: string;

package/dist/prompts/brief.d.ts

@@ -6,7 +6,7 @@
  */
 import { type PromptDescriptor, type RenderedPrompt } from "./index.js";
 export declare const BRIEF_PROMPT_DESCRIPTOR: PromptDescriptor;
-declare const ALLOWED_HEADINGS: readonly ["Engineering", "Product", "Human", "System"];
+declare const ALLOWED_HEADINGS: readonly ["Engineering", "Product", "System"];
 export interface BriefInput {
     /** ISO date string injected into the brief header. */
     generatedAt: string;
@@ -14,6 +14,6 @@ export interface BriefInput {
     sections: Partial<Record<(typeof ALLOWED_HEADINGS)[number], string[]>>;
 }
 export declare const briefPrompt: (input: BriefInput) => RenderedPrompt;
-export declare const ALLOWED_BRIEF_HEADINGS: readonly ["Engineering", "Product", "Human", "System"];
+export declare const ALLOWED_BRIEF_HEADINGS: readonly ["Engineering", "Product", "System"];
 export {};
 //# sourceMappingURL=brief.d.ts.map

package/dist/prompts/brief.js

@@ -12,7 +12,6 @@ export const BRIEF_PROMPT_DESCRIPTOR = {
 const ALLOWED_HEADINGS = [
     "Engineering",
     "Product",
-    "Human",
     "System",
 ];
 const SYSTEM_TEMPLATE = (allowedHeadings) => `<role>

package/dist/prompts/extraction.js

@@ -12,13 +12,18 @@ export const EXTRACTION_PROMPT_DESCRIPTOR = {
 const SUBTYPE_REASONING = `## Subtype reasoning (think step-by-step BEFORE picking memory_subtype)
 For each candidate fact, walk these four top-level categories first, then pick the most concrete memory_subtype:
 
-  ENGINEERING — how the software is built and operated:
+  ENGINEERING — how the software is built and operated, including collaboration preferences:
     codebase_map      → file paths, symbols, modules, repo structure
     architecture_decision → engineering/system design choice with rationale
     infra_topology    → clusters, services, queues, datastores, regions
     access_pattern    → roles, permissions, auth flows, approval gates
     operational_procedure  → runbook / deploy / rollout / maintenance / incident steps
     troubleshooting_gotcha → stable failure mode, debugging quirk, surprising behaviour
+    preference             → explicit style, tooling, or interaction preference
+    person_profile         → durable role, expertise, person/team context
+    ownership_note         → owner, approver, escalation path, accountability
+    working_agreement      → collaboration norm or operating rule
+    activity_event         → explicit actor-action-object event with durable project value
     convention             → produced by distillation, not this extraction prompt
 
   PRODUCT — what the product should be and how it succeeds:
@@ -30,13 +35,6 @@ For each candidate fact, walk these four top-level categories first, then pick t
     success_metric         → KPI, adoption/retention/quality metric, evaluation target
     market_insight         → audience, customer/community feedback, competitor/GTM insight
 
-  HUMAN — durable people, preferences, and collaboration context:
-    preference             → explicit style, tooling, or interaction preference
-    person_profile         → durable role, expertise, person/team context
-    ownership_note         → owner, approver, escalation path, accountability
-    working_agreement      → collaboration norm or operating rule
-    activity_event         → explicit actor-action-object event with durable project value
-
 Disambiguation rules (apply in order; first match wins):
   R1. If the fact describes a *failure* or *workaround* → troubleshooting_gotcha (NOT operational_procedure).
   R2. If the fact names *files / modules / symbols* → codebase_map (NOT infra_topology).
@@ -62,7 +60,7 @@ Example 2 — codebase vs infra:
 Example 3 — domain_rule vs preference:
   TEXT: "I prefer kebab-case branch names; it's just my style."
   → memory_subtype: preference (R6: 'I prefer' + 'my style')
-  → subtype_reason: "Personal style → Human → R6 wins → preference."
+  → subtype_reason: "Personal style → Engineering → R6 wins → preference."
 
 Example 4 — product vs engineering decision:
   TEXT: "We decided the memory page should show categories and subtype chips directly because a sub-tab layer made the ontology feel confusing."
@@ -72,7 +70,7 @@ Example 4 — product vs engineering decision:
 Example 5 — durable activity event:
   TEXT: "Saber merged PR #85 after approving the subtype UX copy changes."
   → memory_subtype: activity_event (R7: actor + durable state-changing action + object)
-  → subtype_reason: "Actor-action-object event tied to a PR → Human → R7 wins → activity_event."`;
+  → subtype_reason: "Actor-action-object event tied to a PR → Engineering → R7 wins → activity_event."`;
 const SELF_JUDGMENT = `## Self-judgment (think step-by-step BEFORE emitting each fact)
 
 For every candidate fact, judge it on three axes. The verifier downstream USES these values, so be honest — bad self-judgment costs the fact its place in memory.
@@ -218,7 +216,7 @@ If nothing passes the quality gate, return: {"facts": []}`;
 const buildSystem = () => {
     return [
         "<role>",
-        "You are Bikky's knowledge-extraction agent for open-source coding agents. You read session transcripts and emit durable Engineering, Product, Human, and System-aligned facts that help a future agent continue useful work.",
+        "You are Bikky's knowledge-extraction agent for open-source coding agents. You read session transcripts and emit durable Engineering, Product, and System-aligned facts that help a future agent continue useful work.",
         "</role>",
         "",
         "<task>",

package/dist/provenance/origin.d.ts

@@ -2,7 +2,7 @@ import type { BikkyConfig } from "../config.js";
 export type OriginIdentityType = "user" | "coding_agent" | "daemon" | "ui" | "api" | "cli" | "docs" | "system" | "unknown";
 export type OriginIdentitySource = "config" | "shell" | "git" | "env" | "hostname";
 export type OriginInterface = "mcp" | "daemon" | "ui" | "api" | "cli" | "system";
-export type OriginAction = "create" | "update" | "delete" | "verify" | "forget" | "review" | "correct" | "reinforce" | "supersede" | "feedback";
+export type OriginAction = "create" | "update" | "delete" | "verify" | "forget" | "review" | "correct" | "reinforce" | "supersede" | "recall" | "aggregate" | "feedback";
 export type OriginMetadataValue = string | number | boolean | null;
 export interface OriginIdentity {
     type: OriginIdentityType;

package/dist/routing-context.d.ts

@@ -0,0 +1,16 @@
+import type { RoutingInput } from "./routing.js";
+type RoutingMetadata = Record<string, unknown>;
+export interface MemoryRoutingInput {
+    destination?: string | null;
+    cwd?: string;
+    content?: string | null;
+    entities?: ReadonlyArray<string>;
+    metadata?: RoutingMetadata | null;
+    context?: RoutingMetadata | null;
+    extraContent?: ReadonlyArray<unknown>;
+}
+export declare const routingText: (values: ReadonlyArray<unknown>) => string;
+export declare const buildMemoryRoutingInput: (input: MemoryRoutingInput) => RoutingInput;
+export declare const mergeRoutingInputs: (base: RoutingInput, override?: RoutingInput) => RoutingInput;
+export {};
+//# sourceMappingURL=routing-context.d.ts.map