bikky 0.4.5 → 0.4.6

package/CHANGELOG.md

@@ -9,6 +9,34 @@ This project uses npm package versions for release tracking:
 
 ## Unreleased
 
+## 0.4.6
+
+- Added configurable `ignore` rules for memory writes using the same `cwd`, `entity`, `content`, and `metadata` filters as destination routing.
+- Applied ignore checks before MCP writes, daemon writes, relation sidecars, superseding, telemetry upserts, embedding, deduplication, and Qdrant persistence.
+- Documented ignore configuration and added regression coverage for config validation, routing precedence, MCP write paths, daemon writes, telemetry, and local MCP E2E behavior.
+
+## 0.4.5
+
+- Fixed destination routing so daemon provenance and agent metadata no longer influence where unrelated facts are stored.
+- Added regression coverage for non-Bikky facts with Bikky daemon origin metadata.
+- Moved the README top diagram closer to the audience/context section.
+
+## 0.4.4
+
+- Refreshed README positioning and configuration guidance for supported MCP clients, transcript capture, Qdrant storage, and built-in model providers.
+- Added memory quality/usefulness signals and surfaced usefulness data in the UI.
+- Fixed MCP and daemon write routing to use the full memory context consistently.
+- Removed the old Human memory category and filtered internal dashboard memory rows.
+- Added Playwright coverage for memory filters and edge cases.
+
+## 0.4.3
+
+- Fixed daemon destination routing and dynamic config-path handling.
+- Added canonical origin provenance metadata to memory writes.
+- Recommended Portkey as the default cloud inference provider and canonicalized 1024-dimension embedding guidance.
+- Fixed `bikky-ui` browser launches when the server binds to `localhost:0`.
+- Added higher-priority test coverage across core routing, config, and UI behavior.
+
 ## 0.4.2
 
 - Republished the core package from current `main` so the npm package README uses GitHub documentation links instead of stale jsDelivr links.

package/dist/config.d.ts

@@ -119,6 +119,14 @@ export interface Destination {
     /** Routing rules. Omit for a destination that is only reachable by override. */
     match?: DestinationMatch;
 }
+export interface IgnoreRule {
+    /** Stable identifier returned in ignored-write responses and logs. */
+    name?: string;
+    /** Human-readable reason/guidance for why the rule exists. */
+    description?: string;
+    /** Match rules using the same semantics as destination routing. */
+    match: DestinationMatch;
+}
 export type SearchScopeTarget = "routed" | "all" | string | string[];
 export interface SearchScopeDefinition {
     /** Stable scope name that MCP clients can pass as `search_scope`. */
@@ -143,6 +151,8 @@ export interface BikkyConfig {
      * default flag → first entry.
      */
     destinations: Destination[];
+    /** Memory write exclusion rules. First matching rule skips persistence. */
+    ignore: IgnoreRule[];
     /**
      * Default read/search scope. "routed" preserves historical behavior
      * (one destination via routing rules); "all" fans out to every destination;

package/dist/config.js

@@ -55,6 +55,7 @@ const DEFAULTS = {
     qdrant_api_key: null,
     collection: "bikky",
     destinations: [],
+    ignore: [],
     default_search_scope: "routed",
     search_scopes: [],
     aws_profile: null,
@@ -241,6 +242,11 @@ const destinationFileSchema = z.object({
     default: z.boolean().optional(),
     match: destinationMatchSchema.optional(),
 }).passthrough();
+const ignoreRuleFileSchema = z.object({
+    name: z.string().min(1).optional(),
+    description: z.string().optional(),
+    match: destinationMatchSchema,
+}).passthrough();
 const searchScopeTargetSchema = z.union([
     z.string().min(1),
     z.array(z.string().min(1)).min(1),
@@ -255,6 +261,7 @@ const configFileSchema = z.object({
     qdrant_api_key: z.string().nullable().optional(),
     collection: z.string().optional(),
     destinations: z.array(destinationFileSchema).optional(),
+    ignore: z.array(ignoreRuleFileSchema).optional(),
     default_search_scope: searchScopeTargetSchema.optional(),
     search_scopes: z.array(searchScopeDefinitionFileSchema).optional(),
     aws_profile: z.string().nullable().optional(),
@@ -313,6 +320,58 @@ function validateUrlLike(value, pathName, issues) {
         });
     }
 }
+function validateMatchBlock(match, base, issues) {
+    for (const field of ["cwd", "entity", "content"]) {
+        const value = match[field];
+        if (value === undefined)
+            continue;
+        if (!Array.isArray(value)) {
+            issues.push({ severity: "error", path: `${base}.${field}`, message: "must be an array of regex strings" });
+            continue;
+        }
+        value.forEach((pattern, pIdx) => {
+            if (typeof pattern !== "string") {
+                issues.push({ severity: "error", path: `${base}.${field}[${pIdx}]`, message: "must be a string" });
+                return;
+            }
+            try {
+                new RegExp(pattern);
+            }
+            catch (e) {
+                issues.push({
+                    severity: "error",
+                    path: `${base}.${field}[${pIdx}]`,
+                    message: `invalid regex: ${e instanceof Error ? e.message : String(e)}`,
+                });
+            }
+        });
+    }
+    const metadata = childObject(match, "metadata");
+    if (metadata) {
+        for (const [key, value] of Object.entries(metadata)) {
+            if (!Array.isArray(value)) {
+                issues.push({ severity: "error", path: `${base}.metadata.${key}`, message: "must be an array of regex strings" });
+                continue;
+            }
+            value.forEach((pattern, pIdx) => {
+                if (typeof pattern !== "string") {
+                    issues.push({ severity: "error", path: `${base}.metadata.${key}[${pIdx}]`, message: "must be a string" });
+                    return;
+                }
+                try {
+                    new RegExp(pattern);
+                }
+                catch (e) {
+                    issues.push({
+                        severity: "error",
+                        path: `${base}.metadata.${key}[${pIdx}]`,
+                        message: `invalid regex: ${e instanceof Error ? e.message : String(e)}`,
+                    });
+                }
+            });
+        }
+    }
+}
 export function validateConfigObject(raw) {
     const parsed = configFileSchema.safeParse(raw);
     const issues = [];
@@ -368,62 +427,28 @@ export function validateConfigObject(raw) {
                 defaultCount++;
             const match = childObject(entry, "match");
             if (match) {
-                for (const field of ["cwd", "entity", "content"]) {
-                    const value = match[field];
-                    if (value === undefined)
-                        continue;
-                    if (!Array.isArray(value)) {
-                        issues.push({ severity: "error", path: `${base}.match.${field}`, message: "must be an array of regex strings" });
-                        continue;
-                    }
-                    value.forEach((pattern, pIdx) => {
-                        if (typeof pattern !== "string") {
-                            issues.push({ severity: "error", path: `${base}.match.${field}[${pIdx}]`, message: "must be a string" });
-                            return;
-                        }
-                        try {
-                            new RegExp(pattern);
-                        }
-                        catch (e) {
-                            issues.push({
-                                severity: "error",
-                                path: `${base}.match.${field}[${pIdx}]`,
-                                message: `invalid regex: ${e instanceof Error ? e.message : String(e)}`,
-                            });
-                        }
-                    });
-                }
-                const metadata = childObject(match, "metadata");
-                if (metadata) {
-                    for (const [key, value] of Object.entries(metadata)) {
-                        if (!Array.isArray(value)) {
-                            issues.push({ severity: "error", path: `${base}.match.metadata.${key}`, message: "must be an array of regex strings" });
-                            continue;
-                        }
-                        value.forEach((pattern, pIdx) => {
-                            if (typeof pattern !== "string") {
-                                issues.push({ severity: "error", path: `${base}.match.metadata.${key}[${pIdx}]`, message: "must be a string" });
-                                return;
-                            }
-                            try {
-                                new RegExp(pattern);
-                            }
-                            catch (e) {
-                                issues.push({
-                                    severity: "error",
-                                    path: `${base}.match.metadata.${key}[${pIdx}]`,
-                                    message: `invalid regex: ${e instanceof Error ? e.message : String(e)}`,
-                                });
-                            }
-                        });
-                    }
-                }
+                validateMatchBlock(match, `${base}.match`, issues);
             }
         });
         if (defaultCount > 1) {
             issues.push({ severity: "error", path: "destinations", message: `at most one destination may set 'default: true' (found ${defaultCount})` });
         }
     }
+    if (Array.isArray(raw.ignore)) {
+        raw.ignore.forEach((entry, idx) => {
+            const base = `ignore[${idx}]`;
+            if (!isObject(entry)) {
+                issues.push({ severity: "error", path: base, message: "must be an object" });
+                return;
+            }
+            const match = entry.match;
+            if (!isObject(match)) {
+                issues.push({ severity: "error", path: `${base}.match`, message: "must be an object" });
+                return;
+            }
+            validateMatchBlock(match, `${base}.match`, issues);
+        });
+    }
     const destinationNames = new Set();
     if (Array.isArray(raw.destinations)) {
         for (const entry of raw.destinations) {

package/dist/daemon/consolidation.js

@@ -100,11 +100,12 @@ const autoDistill = async (_config, { minSummaries = 5 } = {}) => {
             return { distilled: false };
         const promptStamp = `${DISTILL_PROMPT_DESCRIPTOR.id}@${DISTILL_PROMPT_DESCRIPTOR.version}`;
         // Store distilled patterns
+        let storedPatterns = 0;
         for (const pattern of patterns) {
             if (!pattern.content)
                 continue;
             const hash = createHash("sha256").update(`distilled:${pattern.content}`).digest("hex");
-            await qdrant.storeFact({
+            const storedId = await qdrant.storeFact({
                 content: pattern.content,
                 category: normalizeCategory(pattern.category ?? "engineering"),
                 domain: normalizeDomain(pattern.domain ?? "software_engineering"),
@@ -128,6 +129,12 @@ const autoDistill = async (_config, { minSummaries = 5 } = {}) => {
                     },
                 }),
             }, { destination });
+            if (storedId)
+                storedPatterns++;
+        }
+        if (storedPatterns === 0) {
+            logFn("INFO", `Auto-distill: all ${patterns.length} patterns were ignored by config rules`);
+            return { distilled: false };
         }
         // Supersede the source summaries
         for (const pt of batch) {
@@ -138,8 +145,8 @@ const autoDistill = async (_config, { minSummaries = 5 } = {}) => {
                 metadata: { prompt: promptStamp },
             }));
         }
-        logFn("INFO", `Auto-distill: consolidated ${batch.length} summaries into ${patterns.length} patterns`);
-        return { distilled: true, count: patterns.length };
+        logFn("INFO", `Auto-distill: consolidated ${batch.length} summaries into ${storedPatterns} patterns`);
+        return { distilled: true, count: storedPatterns };
     }
     catch (e) {
         logFn("ERROR", `Auto-distill failed: ${e.message}`);

package/dist/daemon/extraction.js

@@ -446,6 +446,10 @@ const storeFacts = async (facts, sessionId, config, source) => {
         };
         try {
             const dedup = await qdrant.dedupCheck(sanitizedFact.content, hash, undefined, undefined, routeInput);
+            if (dedup.action === "ignore") {
+                logFn("DEBUG", `Extraction: ignoring fact due to config rule '${dedup.ignoreRule ?? "unknown"}': "${sanitizedFact.content.slice(0, 80)}…"`);
+                continue;
+            }
             if (dedup.action === "skip") {
                 // Reinforce existing fact
                 if (dedup.existingId) {
@@ -610,6 +614,8 @@ const storeFacts = async (facts, sessionId, config, source) => {
             };
             if (dedup.action === "supersede" && dedup.existingId) {
                 const newId = await qdrant.storeFact(storePayload, routeInput);
+                if (!newId)
+                    continue;
                 await qdrant.supersedeFact(dedup.existingId, newId, dedup.destination, buildOperationOrigin({
                     interface: "daemon",
                     action: "supersede",
@@ -624,8 +630,9 @@ const storeFacts = async (facts, sessionId, config, source) => {
                 stored++;
             }
             else {
-                await qdrant.storeFact(storePayload, routeInput);
-                stored++;
+                const newId = await qdrant.storeFact(storePayload, routeInput);
+                if (newId)
+                    stored++;
             }
         }
         catch (e) {

package/dist/daemon/qdrant.d.ts

@@ -162,10 +162,11 @@ export interface QdrantScrollFilters {
         direction: "asc" | "desc";
     };
 }
-export type DedupAction = "insert" | "skip" | "supersede";
+export type DedupAction = "insert" | "skip" | "supersede" | "ignore";
 export interface DedupResult {
     action: DedupAction;
     destination?: string;
+    ignoreRule?: string;
     existingId?: string;
     existingCount?: number;
     score?: number;
@@ -190,7 +191,7 @@ declare const activeDestinations: () => Destination[];
 declare const searchFacts: (query: string, filters?: QdrantSearchFilters, limit?: number, destinationRef?: DestinationRef) => Promise<QdrantSearchResult[]>;
 declare const scrollFacts: (filters?: QdrantScrollFilters, limit?: number, destinationRef?: DestinationRef) => Promise<QdrantScrollResult[]>;
 declare const scrollFactsAcrossDestinations: (filters?: QdrantScrollFilters, limit?: number) => Promise<QdrantScrollResult[]>;
-declare const storeFact: (fact: StoreFact, routeInput?: RoutingInput) => Promise<string>;
+declare const storeFact: (fact: StoreFact, routeInput?: RoutingInput) => Promise<string | null>;
 declare const supersedeFact: (oldFactId: string, newFactId: string, destinationRef?: DestinationRef, origin?: OperationOrigin) => Promise<void>;
 declare const reinforceFact: (factId: string, currentCount: number, destinationRef?: DestinationRef, origin?: OperationOrigin) => Promise<void>;
 declare const dedupCheck: (content: string, contentHashVal: string, { exactThreshold, supersedeThreshold }?: DedupThresholds, workspaceId?: string, routeInput?: RoutingInput) => Promise<DedupResult>;

package/dist/daemon/qdrant.js

@@ -11,7 +11,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { getEffectiveDestinations, loadConfig } from "../config.js";
 import { embed, initEmbedding, getEmbeddingConfig } from "../llm/index.js";
 import { QdrantPool } from "../lib/qdrant-pool.js";
-import { buildResolver } from "../routing.js";
+import { buildResolver, findMatchingIgnoreRule } from "../routing.js";
 import { DEFAULT_DOMAIN, QDRANT_INDEXES, categoryForMemorySubtype, layerForMemorySubtype, normalizeCategory, normalizeDomain, normalizeKind, validateMemorySubtype, } from "../mcp/taxonomy.js";
 import { combineRedactions, redactStorageText, } from "../privacy/redaction.js";
 import { buildOperationOrigin } from "../provenance/origin.js";
@@ -395,12 +395,18 @@ const storeFact = async (fact, routeInput) => {
     if (redaction.redacted) {
         payload.redaction = redaction;
     }
-    const destination = resolveDestination(mergeRoutingInputs(routingInputForFact(fact, redactedContent.text, payload.entities, {
+    const writeInput = mergeRoutingInputs(routingInputForFact(fact, redactedContent.text, payload.entities, {
         category: normalizedCategory,
         domain: normalizedDomain,
         kind: normalizedKind,
         ...(normalizedSubtype ? { memory_subtype: normalizedSubtype } : {}),
-    }), routeInput));
+    }), routeInput);
+    const ignored = findMatchingIgnoreRule(writeInput, loadConfig().ignore);
+    if (ignored) {
+        logFn("INFO", `Qdrant: ignored fact write due to ignore rule '${ignored.name}' [${normalizedCategory}] ${redactedContent.text.slice(0, 60)}`);
+        return null;
+    }
+    const destination = resolveDestination(writeInput);
     const vector = await embed(redactedContent.text);
     await qdrantRequest("PUT", `/collections/${destination.collection}/points`, {
         points: [{ id, vector, payload }],
@@ -446,7 +452,13 @@ const reinforceFact = async (factId, currentCount, destinationRef, origin) => {
     logFn("DEBUG", `Qdrant: reinforced fact ${factId} in '${destination.name}'`);
 };
 const dedupCheck = async (content, contentHashVal, { exactThreshold = 0.92, supersedeThreshold = 0.80 } = {}, workspaceId, routeInput) => {
-    const destination = resolveDestination(routeInput ?? { content });
+    const input = mergeRoutingInputs({ content }, routeInput);
+    const ignored = findMatchingIgnoreRule(input, loadConfig().ignore);
+    if (ignored) {
+        logFn("INFO", `Qdrant: ignored dedup/write candidate due to ignore rule '${ignored.name}'`);
+        return { action: "ignore", ignoreRule: ignored.name };
+    }
+    const destination = resolveDestination(input);
     // First: hash-based exact check (fast, no embedding)
     try {
         const must = [

package/dist/daemon/relations.d.ts

@@ -69,7 +69,7 @@ declare const storeRelation: (fromEntity: string, toEntity: string, relationType
         durability?: string;
         directionality_clarity?: string;
     };
-}) => Promise<string>;
+}) => Promise<string | null>;
 declare const tick: (config: BikkyConfig) => Promise<void>;
 /** Reset state (for testing). */
 declare const _reset: () => void;

package/dist/daemon/relations.js

@@ -280,6 +280,10 @@ const storeRelation = async (fromEntity, toEntity, relationType, content, candid
             to: toEntity,
         },
     }, destination ? { destination } : undefined);
+    if (!id) {
+        logFn("INFO", `Relations: ignored ${fromEntity} —[${relationType}]→ ${toEntity} due to ignore rules`);
+        return null;
+    }
     logFn("INFO", `Relations: inferred ${fromEntity} —[${relationType}]→ ${toEntity} (id: ${id})`);
     return id;
 };
@@ -358,12 +362,17 @@ const tick = async (config) => {
                     .update(`daemon-relation:${pairKey(result.from, result.to)}:${result.type}`)
                     .digest("hex");
                 const dedup = await qdrant.dedupCheck(result.content, hash, undefined, undefined, { destination });
+                if (dedup.action === "ignore") {
+                    logFn("DEBUG", `Relations: ignoring ${candidate.entityA}↔${candidate.entityB} due to config rule '${dedup.ignoreRule ?? "unknown"}'`);
+                    continue;
+                }
                 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, destination, { evidence: result.evidence, confidence: result.confidence, inVocabulary: result.inVocabulary, judgment: result.judgment });
-                inferred++;
+                const storedId = await storeRelation(result.from, result.to, result.type, result.content, candidate, destination, { evidence: result.evidence, confidence: result.confidence, inVocabulary: result.inVocabulary, judgment: result.judgment });
+                if (storedId)
+                    inferred++;
             }
             catch (e) {
                 failures++;

package/dist/mcp/tools.js

@@ -6,7 +6,7 @@ import { z } from "zod";
 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";
+import { DestinationNotFoundError, findMatchingIgnoreRule } from "../routing.js";
 import { saveConfig, loadConfig, EXTRACTION_HEALTH_PATH } from "../config.js";
 import { availableSearchScopes, resolveSearchScope, SearchScopeNotFoundError, } from "../search-scope.js";
 import { existsSync, readFileSync } from "node:fs";
@@ -114,6 +114,53 @@ function resolveDestOrError(input) {
         };
     }
 }
+function ignoredWriteResult(tool, match) {
+    return {
+        content: [{ type: "text", text: JSON.stringify({
+                    action: "ignored",
+                    status: "ignored",
+                    ignored: true,
+                    tool,
+                    rule: match.name,
+                    rule_index: match.index,
+                    description: match.rule.description ?? null,
+                    message: `Memory write ignored by config rule '${match.name}'.`,
+                }) }],
+    };
+}
+function ignoreWriteOrError(input, tool) {
+    try {
+        const match = findMatchingIgnoreRule(input, loadConfig().ignore);
+        return match ? { match } : {};
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+            error: {
+                content: [{ type: "text", text: JSON.stringify({
+                            status: "error",
+                            message: `Failed to evaluate ignore rules for ${tool}: ${msg}`,
+                        }, null, 2) }],
+                isError: true,
+            },
+        };
+    }
+}
+function telemetryIgnored(input, subtype) {
+    try {
+        const match = findMatchingIgnoreRule(input, loadConfig().ignore);
+        if (!match)
+            return false;
+        log("INFO", `Skipped ${subtype} write due to ignore rule '${match.name}'`);
+        return true;
+    }
+    catch (e) {
+        log("WARN", `Failed to evaluate ignore rules for ${subtype}: ${e instanceof Error ? e.message : String(e)}`);
+        // Telemetry can include recall queries or feedback notes, so fail closed
+        // rather than risk persisting content that an ignore rule was meant to block.
+        return true;
+    }
+}
 function withDestination(point, destination) {
     return { ...point, _destination: destination };
 }
@@ -167,6 +214,22 @@ async function recordRecallTelemetry(args) {
         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 eventRoutingInput = buildMemoryRoutingInput({
+            cwd: process.cwd(),
+            content: redactedEvent.text,
+            entities,
+            context: {
+                category: categoryForMemorySubtype("recall_event") ?? "system",
+                domain: "software_engineering",
+                kind: "telemetry",
+                memory_subtype: "recall_event",
+                layer: "memory_object",
+                search_scope: args.searchScope.name,
+                destination: dest.name,
+            },
+        });
+        if (telemetryIgnored(eventRoutingInput, "recall_event"))
+            continue;
         const eventPayload = {
             content: redactedEvent.text,
             category: categoryForMemorySubtype("recall_event") ?? "system",
@@ -698,7 +761,7 @@ export function registerTools(mcp) {
             type: redactedRelation.type.text,
             to: redactedRelation.to.text,
         } : null;
-        const resolved = resolveDestOrError(memoryWriteRoutingInput({
+        const writeInput = memoryWriteRoutingInput({
             tool: "memory_store",
             destination,
             content: redactedContent.text,
@@ -719,7 +782,13 @@ export function registerTools(mcp) {
                 review_status,
                 supersedes,
             },
-        }));
+        });
+        const ignored = ignoreWriteOrError(writeInput, "memory_store");
+        if (ignored.error)
+            return ignored.error;
+        if (ignored.match)
+            return ignoredWriteResult("memory_store", ignored.match);
+        const resolved = resolveDestOrError(writeInput);
         if (resolved.error)
             return resolved.error;
         const dest = resolved.dest;
@@ -1514,35 +1583,52 @@ export function registerTools(mcp) {
             });
             // Write a telemetry feedback_event row so the signal is also visible
             // to aggregations and review tooling.
-            const eventId = newId();
             const eventContent = note
                 ? `Fact ${fact_id} marked useful: ${note}`
                 : `Fact ${fact_id} marked useful.`;
             const redactedEvent = redactStorageText(eventContent);
-            const eventPayload = {
+            let eventId = null;
+            const eventInput = buildMemoryRoutingInput({
+                cwd: process.cwd(),
                 content: redactedEvent.text,
-                category: categoryForMemorySubtype("feedback_event") ?? "system",
-                domain: "software_engineering",
-                kind: "telemetry",
-                memory_subtype: "feedback_event",
-                layer: "memory_object",
                 entities: [],
-                origin: feedbackOrigin,
-                confidence: 1.0,
-                importance: 0.3,
-                content_hash: contentHash("feedback_event", `${fact_id}:useful:${now}`),
-                target_fact_id: fact_id,
-                feedback_kind: "useful",
-                created_at: now,
-                updated_at: now,
-            };
-            addRedactionPayload(eventPayload, redactedEvent);
-            try {
-                const eventVector = await embed(redactedEvent.text);
-                await qdrantUpsert(dest, eventId, eventVector, eventPayload);
-            }
-            catch (e) {
-                log("WARN", `Failed to record feedback_event: ${e instanceof Error ? e.message : String(e)}`);
+                context: {
+                    category: categoryForMemorySubtype("feedback_event") ?? "system",
+                    domain: "software_engineering",
+                    kind: "telemetry",
+                    memory_subtype: "feedback_event",
+                    layer: "memory_object",
+                    target_fact_id: fact_id,
+                    feedback_kind: "useful",
+                },
+            });
+            if (!telemetryIgnored(eventInput, "feedback_event")) {
+                eventId = newId();
+                const eventPayload = {
+                    content: redactedEvent.text,
+                    category: categoryForMemorySubtype("feedback_event") ?? "system",
+                    domain: "software_engineering",
+                    kind: "telemetry",
+                    memory_subtype: "feedback_event",
+                    layer: "memory_object",
+                    entities: [],
+                    origin: feedbackOrigin,
+                    confidence: 1.0,
+                    importance: 0.3,
+                    content_hash: contentHash("feedback_event", `${fact_id}:useful:${now}`),
+                    target_fact_id: fact_id,
+                    feedback_kind: "useful",
+                    created_at: now,
+                    updated_at: now,
+                };
+                addRedactionPayload(eventPayload, redactedEvent);
+                try {
+                    const eventVector = await embed(redactedEvent.text);
+                    await qdrantUpsert(dest, eventId, eventVector, eventPayload);
+                }
+                catch (e) {
+                    log("WARN", `Failed to record feedback_event: ${e instanceof Error ? e.message : String(e)}`);
+                }
             }
             return {
                 content: [{ type: "text", text: JSON.stringify({
@@ -1550,7 +1636,7 @@ export function registerTools(mcp) {
                             fact_id,
                             destination: dest.name,
                             useful_count: newCount,
-                            event_id: eventId,
+                            ...(eventId ? { event_id: eventId } : { event_ignored: true }),
                         }) }],
             };
         }
@@ -1591,31 +1677,48 @@ export function registerTools(mcp) {
                 updated_at: now,
                 last_operation_origin: feedbackOrigin,
             });
-            const eventId = newId();
             const eventContent = notes
                 ? `Fact ${fact_id} outcome=${outcome}: ${notes}`
                 : `Fact ${fact_id} outcome=${outcome}.`;
             const redactedEvent = redactStorageText(eventContent);
-            const eventPayload = {
+            let eventId = null;
+            const eventInput = buildMemoryRoutingInput({
+                cwd: process.cwd(),
                 content: redactedEvent.text,
-                category: categoryForMemorySubtype("outcome_event") ?? "system",
-                domain: "software_engineering",
-                kind: "telemetry",
-                memory_subtype: "outcome_event",
-                layer: "memory_object",
                 entities: [],
-                origin: feedbackOrigin,
-                confidence: 1.0,
-                importance: outcome === "wrong" || outcome === "misleading" ? 0.6 : 0.3,
-                content_hash: contentHash("outcome_event", `${fact_id}:${outcome}:${now}`),
-                target_fact_id: fact_id,
-                outcome,
-                created_at: now,
-                updated_at: now,
-            };
-            addRedactionPayload(eventPayload, redactedEvent);
-            const eventVector = await embed(redactedEvent.text);
-            await qdrantUpsert(dest, eventId, eventVector, eventPayload);
+                context: {
+                    category: categoryForMemorySubtype("outcome_event") ?? "system",
+                    domain: "software_engineering",
+                    kind: "telemetry",
+                    memory_subtype: "outcome_event",
+                    layer: "memory_object",
+                    target_fact_id: fact_id,
+                    outcome,
+                },
+            });
+            if (!telemetryIgnored(eventInput, "outcome_event")) {
+                eventId = newId();
+                const eventPayload = {
+                    content: redactedEvent.text,
+                    category: categoryForMemorySubtype("outcome_event") ?? "system",
+                    domain: "software_engineering",
+                    kind: "telemetry",
+                    memory_subtype: "outcome_event",
+                    layer: "memory_object",
+                    entities: [],
+                    origin: feedbackOrigin,
+                    confidence: 1.0,
+                    importance: outcome === "wrong" || outcome === "misleading" ? 0.6 : 0.3,
+                    content_hash: contentHash("outcome_event", `${fact_id}:${outcome}:${now}`),
+                    target_fact_id: fact_id,
+                    outcome,
+                    created_at: now,
+                    updated_at: now,
+                };
+                addRedactionPayload(eventPayload, redactedEvent);
+                const eventVector = await embed(redactedEvent.text);
+                await qdrantUpsert(dest, eventId, eventVector, eventPayload);
+            }
             return {
                 content: [{ type: "text", text: JSON.stringify({
                             status: "outcome_recorded",
@@ -1623,7 +1726,7 @@ export function registerTools(mcp) {
                             destination: dest.name,
                             outcome,
                             [counterField]: counterValue,
-                            event_id: eventId,
+                            ...(eventId ? { event_id: eventId } : { event_ignored: true }),
                         }) }],
             };
         }
@@ -1654,7 +1757,7 @@ export function registerTools(mcp) {
         try {
             const normalizedEntities = (entities ?? []).map((e) => e.trim().toLowerCase()).filter(Boolean);
             const redactedContent = redactStorageText(content);
-            const resolved = resolveDestOrError(memoryWriteRoutingInput({
+            const writeInput = memoryWriteRoutingInput({
                 tool: "memory_session_summary",
                 destination,
                 content: redactedContent.text,
@@ -1670,7 +1773,13 @@ export function registerTools(mcp) {
                     task_key,
                     repo,
                 },
-            }));
+            });
+            const ignored = ignoreWriteOrError(writeInput, "memory_session_summary");
+            if (ignored.error)
+                return ignored.error;
+            if (ignored.match)
+                return ignoredWriteResult("memory_session_summary", ignored.match);
+            const resolved = resolveDestOrError(writeInput);
             if (resolved.error)
                 return resolved.error;
             const dest = resolved.dest;
@@ -1751,7 +1860,7 @@ export function registerTools(mcp) {
         try {
             const normalizedEntities = entities.map((e) => e.trim().toLowerCase()).filter(Boolean);
             const redactedContent = redactStorageText(content);
-            const resolved = resolveDestOrError(memoryWriteRoutingInput({
+            const writeInput = memoryWriteRoutingInput({
                 tool: "memory_distill",
                 destination,
                 content: redactedContent.text,
@@ -1766,7 +1875,13 @@ export function registerTools(mcp) {
                     repo,
                     supersedes,
                 },
-            }));
+            });
+            const ignored = ignoreWriteOrError(writeInput, "memory_distill");
+            if (ignored.error)
+                return ignored.error;
+            if (ignored.match)
+                return ignoredWriteResult("memory_distill", ignored.match);
+            const resolved = resolveDestOrError(writeInput);
             if (resolved.error)
                 return resolved.error;
             const dest = resolved.dest;
@@ -1949,9 +2064,37 @@ export function registerTools(mcp) {
             const { dest, point } = located;
             const origPayload = point.payload;
             const redactedCorrected = redactStorageText(corrected_content);
+            const origCategory = normalizeCategory(origPayload?.category ?? DEFAULT_CATEGORY);
+            const origDomain = normalizeDomain(origPayload?.domain ?? DEFAULT_DOMAIN);
+            const origKind = normalizeKind(origPayload?.kind ?? "fact");
+            const correctedEntities = origPayload?.entities ?? [];
+            const writeInput = memoryWriteRoutingInput({
+                tool: "memory_review",
+                destination: dest.name,
+                content: redactedCorrected.text,
+                entities: correctedEntities,
+                metadata: origPayload?.metadata,
+                context: {
+                    category: origCategory,
+                    domain: origDomain,
+                    kind: origKind,
+                    memory_subtype: origPayload?.memory_subtype,
+                    layer: origPayload?.layer,
+                    episode_id: origPayload?.episode_id,
+                    workstream_key: origPayload?.workstream_key,
+                    task_key: origPayload?.task_key,
+                    repo: origPayload?.repo,
+                    branch: origPayload?.branch,
+                    corrected_from: fact_id,
+                },
+            });
+            const ignored = ignoreWriteOrError(writeInput, "memory_review");
+            if (ignored.error)
+                return ignored.error;
+            if (ignored.match)
+                return ignoredWriteResult("memory_review", ignored.match);
             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",
@@ -1961,8 +2104,8 @@ export function registerTools(mcp) {
             const correctedPayload = {
                 content: redactedCorrected.text,
                 category: origCategory,
-                domain: normalizeDomain(origPayload?.domain ?? DEFAULT_DOMAIN),
-                kind: normalizeKind(origPayload?.kind ?? "fact"),
+                domain: origDomain,
+                kind: origKind,
                 ...(origPayload?.memory_subtype ? { memory_subtype: origPayload.memory_subtype } : {}),
                 ...(origPayload?.layer ? { layer: origPayload.layer } : {}),
                 ...(origPayload?.episode_id ? { episode_id: origPayload.episode_id } : {}),
@@ -1970,7 +2113,7 @@ export function registerTools(mcp) {
                 ...(origPayload?.task_key ? { task_key: origPayload.task_key } : {}),
                 ...(origPayload?.repo ? { repo: origPayload.repo } : {}),
                 ...(origPayload?.branch ? { branch: origPayload.branch } : {}),
-                entities: origPayload?.entities ?? [],
+                entities: correctedEntities,
                 origin: correctOrigin,
                 confidence: 0.95,
                 importance: origPayload?.importance ?? 0.5,

package/dist/routing.d.ts

@@ -15,7 +15,7 @@
  *
  * Pure: no I/O, no globals. Easy to unit test.
  */
-import type { Destination } from "./config.js";
+import type { Destination, DestinationMatch, IgnoreRule } from "./config.js";
 export interface RoutingInput {
     /** Explicit destination name override. Throws if it doesn't match a destination. */
     destination?: string | null;
@@ -36,6 +36,13 @@ export declare class DestinationNotFoundError extends Error {
 export declare class NoDestinationsConfiguredError extends Error {
     constructor();
 }
+export interface IgnoreMatch {
+    rule: IgnoreRule;
+    index: number;
+    name: string;
+}
+export declare function routingInputMatches(match: DestinationMatch | undefined, input: RoutingInput): boolean;
+export declare function findMatchingIgnoreRule(input: RoutingInput, ignoreRules: ReadonlyArray<IgnoreRule>): IgnoreMatch | null;
 /**
  * Resolve a destination from caller input + a (pre-loaded) list of destinations.
  *

package/dist/routing.js

@@ -69,6 +69,21 @@ function destinationMatches(compiled, input) {
     }
     return false;
 }
+export function routingInputMatches(match, input) {
+    return destinationMatches(compileMatch(match), input);
+}
+export function findMatchingIgnoreRule(input, ignoreRules) {
+    for (const [index, rule] of ignoreRules.entries()) {
+        if (routingInputMatches(rule.match, input)) {
+            return {
+                rule,
+                index,
+                name: rule.name?.trim() || `ignore[${index}]`,
+            };
+        }
+    }
+    return null;
+}
 function pickFallback(destinations) {
     const explicit = destinations.find((d) => d.default === true);
     if (explicit)

package/docs/configuration.md

@@ -362,6 +362,39 @@ Matching details:
 - Read/search tools also accept `search_scope`; call `memory_search_scopes` or `get_setup_status` to see available scopes and descriptions.
 - All destinations share one embedding provider, so every destination collection must use the same vector dimensions.
 
+### Ignore rules
+
+Use top-level `ignore` rules when certain memories should not be stored at all. Ignore rules use the same `match` block shape as destination routing (`cwd`, `entity`, `content`, and `metadata` regex arrays), and memory-write `content` matching sees the same flattened memory context used by destination routing.
+
+Ignore rules run before destination resolution, embedding, deduplication, superseding, relation sidecars, telemetry upserts, and Qdrant writes. They also take precedence over explicit `destination` overrides, so an ignored topic cannot be stored by selecting a destination manually.
+
+```jsonc
+{
+  "ignore": [
+    {
+      "name": "personal-topics",
+      "description": "Do not persist personal-topic memories.",
+      "match": {
+        "entity": ["^[Rr]esume$"],
+        "content": ["\\b[Rr]esume\\b"],
+        "metadata": { "repo": ["^private/"] }
+      }
+    }
+  ]
+}
+```
+
+When an MCP write tool is ignored, it returns a structured non-error response such as:
+
+```json
+{
+  "action": "ignored",
+  "status": "ignored",
+  "ignored": true,
+  "rule": "personal-topics"
+}
+```
+
 Migrating from `workspace_id` pre-v0.4:
 
 - Existing top-level `qdrant_url`, `qdrant_api_key`, and `collection` configs still work as a single synthesized destination.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bikky",
-  "version": "0.4.5",
+  "version": "0.4.6",
   "description": "Shared memory for AI coding sessions — MCP server + background daemon",
   "type": "module",
   "license": "AGPL-3.0-or-later",