@hilbras/remembra 3.6.0 → 3.8.0

package/dist/redact.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Content redaction filter for PII (audit Phase 8).
+ *
+ * Opt-in: REMEMBRA_REDACT=1|true|yes. Applied at the service ingest layer
+ * (memory_store + every digest item/merge) so raw PII never reaches disk,
+ * embeddings, or export snapshots.
+ *
+ * Design notes:
+ * - Patterns run most-specific first: cards before phones, prefixes before
+ *   generic long tokens — each match is replaced by a typed placeholder so
+ *   downstream text stays readable ("<EMAIL> confirmed the deploy").
+ * - Cards must pass the Luhn check — digit soup that is not a valid card
+ *   number stays untouched (false positives here would be worse than misses).
+ * - Phone matching requires separators and 10–15 digits, so dates
+ *   (2026-09-23 → 8 digits) and versions (3.6.0) never match.
+ * - Redaction is IRREVERSIBLE by design: the original bytes are not kept
+ *   anywhere (including in the LLM-visible transcript only at extraction —
+ *   see docs/security.md).
+ */
+export type RedactionKind = "email" | "ssn" | "card" | "phone" | "secret";
+export interface RedactionResult {
+    text: string;
+    counts: Partial<Record<RedactionKind, number>>;
+    changed: boolean;
+}
+export declare function redactionEnabled(): boolean;
+/** Redact PII patterns out of text, returning what was found. */
+export declare function redact(text: string): RedactionResult;
+/** Redact a tag list (tags are short, but emails/secrets do sneak in). */
+export declare function redactTags(tags: string[]): {
+    tags: string[];
+    counts: Partial<Record<RedactionKind, number>>;
+};

package/dist/redact.js

@@ -0,0 +1,104 @@
+/**
+ * Content redaction filter for PII (audit Phase 8).
+ *
+ * Opt-in: REMEMBRA_REDACT=1|true|yes. Applied at the service ingest layer
+ * (memory_store + every digest item/merge) so raw PII never reaches disk,
+ * embeddings, or export snapshots.
+ *
+ * Design notes:
+ * - Patterns run most-specific first: cards before phones, prefixes before
+ *   generic long tokens — each match is replaced by a typed placeholder so
+ *   downstream text stays readable ("<EMAIL> confirmed the deploy").
+ * - Cards must pass the Luhn check — digit soup that is not a valid card
+ *   number stays untouched (false positives here would be worse than misses).
+ * - Phone matching requires separators and 10–15 digits, so dates
+ *   (2026-09-23 → 8 digits) and versions (3.6.0) never match.
+ * - Redaction is IRREVERSIBLE by design: the original bytes are not kept
+ *   anywhere (including in the LLM-visible transcript only at extraction —
+ *   see docs/security.md).
+ */
+export function redactionEnabled() {
+    const v = (process.env.REMEMBRA_REDACT ?? "").toLowerCase();
+    return v === "1" || v === "true" || v === "yes";
+}
+/** Luhn mod-10 — rejects digit groups that merely look card-shaped. */
+function luhnOk(digits) {
+    let sum = 0;
+    let alt = false;
+    for (let i = digits.length - 1; i >= 0; i--) {
+        let d = digits.charCodeAt(i) - 48;
+        if (alt) {
+            d *= 2;
+            if (d > 9)
+                d -= 9;
+        }
+        sum += d;
+        alt = !alt;
+    }
+    return sum % 10 === 0;
+}
+// Order matters: specific formats first.
+const RULES = [
+    { kind: "email", pattern: /\b[\w.+-]+@[\w-]+(?:\.[\w-]+)+\b/g },
+    { kind: "ssn", pattern: /\b\d{3}-\d{2}-\d{4}\b/g },
+    {
+        // 13–19 digits, optionally grouped by spaces/dashes: `4111 1111 1111 1111`
+        kind: "card",
+        pattern: /\b(?:\d[ -]?){12,18}\d\b/g,
+        accept: (m) => luhnOk(m.replace(/[ -]/g, "")),
+    },
+    {
+        // Requires separators AND 10–15 total digits (dates/versions excluded).
+        // Lookbehind keeps the match at the token start (a leading `+` is not a
+        // word boundary); the paren form consumes its own `)`.
+        kind: "phone",
+        pattern: /(?<=^|\s)(?:\+\d{1,3}[ .-]?)?(?:\(\d{2,4}\)[ .-]?|\d{2,4}[ .-])\d{3,4}[ .-]\d{3,4}\b/g,
+        accept: (m) => {
+            const digits = m.replace(/\D/g, "").length;
+            return digits >= 10 && digits <= 15;
+        },
+    },
+    // Provider token shapes: OpenAI sk-..., GitHub ghp_/gho_/github_pat-, AWS AKIA…,
+    // Slack xoxb-, GitLab glpat-, generic <prefix><32+ chars>.
+    {
+        kind: "secret",
+        pattern: /\b(?:sk|pk|rk|ghp|gho|ghs|xoxb|xoxp|glpat)[-_][A-Za-z0-9_-]{16,}\b|\bAKIA[0-9A-Z]{16}\b|\bghu_[A-Za-z0-9]{20,}\b|github_pat_[A-Za-z0-9_]{20,}\b/g,
+    },
+    {
+        // High-entropy blob: 40+ unbroken base64/hex-ish chars (keys, hashes).
+        // UUIDs are 36 chars with dashes; English words never reach 40.
+        kind: "secret",
+        pattern: /\b[A-Za-z0-9+/_-]{40,}\b/g,
+        accept: (m) => !/^[\w-]+$/.test(m) || /[0-9]/.test(m), // require a digit: skips megawords
+    },
+];
+/** Redact PII patterns out of text, returning what was found. */
+export function redact(text) {
+    const counts = {};
+    let out = text;
+    for (const rule of RULES) {
+        out = out.replace(rule.pattern, (match) => {
+            if (rule.accept && !rule.accept(match))
+                return match;
+            counts[rule.kind] = (counts[rule.kind] ?? 0) + 1;
+            return `<${rule.kind.toUpperCase()}>`;
+        });
+    }
+    return { text: out, counts, changed: Object.keys(counts).length > 0 };
+}
+/** Redact a tag list (tags are short, but emails/secrets do sneak in). */
+export function redactTags(tags) {
+    const merged = {};
+    let changed = false;
+    const out = tags.map((t) => {
+        const r = redact(t);
+        for (const [k, v] of Object.entries(r.counts)) {
+            merged[k] = (merged[k] ?? 0) + v;
+        }
+        if (r.changed)
+            changed = true;
+        return r.text;
+    });
+    return { tags: out, counts: changed ? merged : {} };
+}
+//# sourceMappingURL=redact.js.map

package/dist/redact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redact.js","sourceRoot":"","sources":["../src/redact.ts"],"names":[],"mappings":"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"}

package/dist/service.d.ts

@@ -38,6 +38,8 @@ interface ServiceDeps {
     archiveAfterDays?: number;
     /** Archived memory older than this gets auto-deleted. Default 365. */
     archiveTtlDays?: number;
+    /** Force the PII redaction filter on/off (default: REMEMBRA_REDACT env). */
+    redact?: boolean;
 }
 /**
  * Transport-agnostic handlers. Both the MCP tools and the HTTP API
@@ -51,6 +53,7 @@ export declare class MemoryService {
     private readonly decayIntervalMs;
     private readonly archiveAfterDays;
     private readonly archiveTtlDays;
+    private readonly redactOn;
     private lastDecayRun;
     private decayRunning;
     constructor(db: MemoryBackend, deps?: ServiceDeps);
@@ -89,6 +92,78 @@ export declare class MemoryService {
         ok: boolean;
         text: string;
     }>;
+    /** Fetch one memory with its links resolved (audit Phase 8: graph view). */
+    get(id: string): Promise<{
+        memory: Memory;
+        related: ({
+            id: string;
+            type: "fact" | "decision" | "role" | "history";
+            scope: string;
+            content: string;
+        } | {
+            id: string;
+            missing: true;
+        })[];
+        backlinks: {
+            id: string;
+            type: "fact" | "decision" | "role" | "history";
+            scope: string;
+            content: string;
+        }[];
+        text: string;
+    }>;
+    /**
+     * Manage directed links between memories (audit Phase 8: relationship
+     * graph). Targets are validated on add; backlinks are derived at read
+     * time, so one write keeps the edge consistent.
+     */
+    relate(input: unknown): Promise<{
+        id: string;
+        related: string[];
+        added: string[];
+        removed: string[];
+        text: string;
+    }>;
+    /**
+     * Version history with line diffs (audit Phase 8: diff/history view).
+     * Newest first; each past version carries a unified diff against its
+     * predecessor (the current version diffs against the newest snapshot).
+     */
+    history(input: unknown): Promise<{
+        id: string;
+        versions: {
+            current?: true;
+            file?: string;
+            at?: string;
+            snapshotAt?: string;
+            content: string;
+            diff: string;
+        }[];
+        text: string;
+    }>;
+    /**
+     * Redact a content+tags pair, emitting metrics + a log event when anything
+     * was found. Returns null when disabled or clean (callers keep originals).
+     */
+    private redactPair;
+    /** PII redaction of a store input (audit Phase 8). */
+    private applyRedaction;
+    /** Readiness probe (audit Phase 7): can the backend actually be read? */
+    health(): Promise<{
+        status: "ok" | "unready";
+        version: string;
+        uptime_s: number;
+        storage: string;
+        cache?: {
+            size: number;
+            capacity: number;
+        };
+    }>;
+    /** Parse-cache stats when the backend exposes them (file backend does). */
+    storageStats(): {
+        size: number;
+        capacity: number;
+    } | null;
     /**
      * Session digest (v2) with contradiction-merge (v3):
      * extract worth-keeping memories, skip exact duplicates, and let the LLM

package/dist/service.js

@@ -1,7 +1,14 @@
 import { search } from "./retrieval.js";
 import { StoreInput, SnapshotInput, SNAPSHOT_FORMAT, SCHEMA_VERSION } from "./types.js";
-import { RemembraError, inputError } from "./errors.js";
+import { RemembraError, inputError, errorLabel } from "./errors.js";
 import { resolveEmbeddingProvider, embedText, cosine } from "./embeddings.js";
+import { logEvent } from "./log.js";
+import { metrics } from "./metrics.js";
+import { VERSION } from "./version.js";
+import { performance } from "node:perf_hooks";
+import { redact, redactTags, redactionEnabled } from "./redact.js";
+import { unifiedDiff } from "./diff.js";
+import { RelateInput, HistoryInput } from "./types.js";
 import { resolveLlmProvider, extractMemories, resolveMerge, } from "./llm.js";
 /**
  * Transport-agnostic handlers. Both the MCP tools and the HTTP API
@@ -15,6 +22,7 @@ export class MemoryService {
     decayIntervalMs;
     archiveAfterDays;
     archiveTtlDays;
+    redactOn;
     lastDecayRun = 0;
     decayRunning = false;
     constructor(db, deps = {}) {
@@ -29,6 +37,7 @@ export class MemoryService {
         this.decayIntervalMs = deps.decayIntervalMs ?? 3_600_000; // 1h
         this.archiveAfterDays = deps.archiveAfterDays ?? Number(process.env.REMEMBRA_ARCHIVE_AFTER_DAYS ?? 90);
         this.archiveTtlDays = deps.archiveTtlDays ?? Number(process.env.REMEMBRA_ARCHIVE_TTL_DAYS ?? 365);
+        this.redactOn = deps.redact ?? redactionEnabled();
     }
     get embeddingsEnabled() {
         return this.embedFn !== undefined;
@@ -41,7 +50,7 @@ export class MemoryService {
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            console.error(`Remembra: embedding failed (${msg.slice(0, 200)}); continuing without`);
+            logEvent("warn", "embedding_failed", { error: msg.slice(0, 200) }, `Remembra: embedding failed (${msg.slice(0, 200)}); continuing without`);
             return undefined;
         }
     }
@@ -53,10 +62,15 @@ export class MemoryService {
         catch (err) {
             throw inputError(err, "INVALID_INPUT");
         }
+        // PII redaction (audit Phase 8, opt-in REMEMBRA_REDACT): before embed,
+        // before disk, before export — raw patterns never leave this process.
+        if (this.redactOn)
+            parsed = this.applyRedaction(parsed);
         const embedding = await this.maybeEmbed(parsed.content);
         const memory = await this.db.store(parsed, embedding, {
             provenance: opts?.provenance ?? "explicit",
         });
+        metrics.inc("remembra_stores_total");
         return {
             id: memory.id,
             message: `Stored ${memory.type} memory ${memory.id} (scope: ${memory.scope})`,
@@ -64,14 +78,28 @@ export class MemoryService {
         };
     }
     async search(q) {
+        const t0 = performance.now();
         let queryVec = null;
         if (q.query && this.embedFn)
             queryVec = (await this.maybeEmbed(q.query)) ?? null;
         const results = search(await this.db.all(), q, queryVec);
+        const durationMs = performance.now() - t0;
+        // Observability (audit Phase 7): counters + hygiene-first query logging —
+        // raw query text only under REMEMBRA_DEBUG (same rule as the root path).
+        metrics.inc("remembra_searches_total");
+        metrics.observe("remembra_search_duration_seconds", durationMs / 1000);
+        logEvent("info", "search", {
+            scope: q.scope,
+            terms: (q.query ?? "").split(/\s+/).filter((t) => t.length > 1).length,
+            results: results.length,
+            limit: q.limit,
+            duration_ms: Math.round(durationMs * 10) / 10,
+            ...(process.env.REMEMBRA_DEBUG && q.query ? { query: q.query } : {}),
+        });
         // Refresh decay clocks for memories that surfaced (fire-and-forget).
         for (const m of results)
             this.db.touch(m.id).catch((err) => {
-                console.error(`Remembra: touch failed (${m.id}): ${String(err).slice(0, 150)}`);
+                logEvent("warn", "touch_failed", { id: m.id, error: String(err).slice(0, 150) }, `Remembra: touch failed (${m.id}): ${String(err).slice(0, 150)}`);
             });
         // Opportunistic decay pass, debounced (decision v3-Q1: piggyback on search).
         this.maybeRunDecay();
@@ -117,6 +145,173 @@ export class MemoryService {
         const ok = await this.db.forget(id);
         return { ok, text: ok ? `Deleted memory ${id}.` : `No memory with id ${id}.` };
     }
+    /** Fetch one memory with its links resolved (audit Phase 8: graph view). */
+    async get(id) {
+        const memory = await this.db.get(id);
+        if (!memory)
+            throw new RemembraError("NOT_FOUND", `No memory with id ${id}`);
+        const all = await this.db.all(true);
+        const brief = (m) => ({
+            id: m.id,
+            type: m.type,
+            scope: m.scope,
+            content: m.content.split("\n")[0],
+        });
+        const related = (memory.related ?? []).map((rid) => {
+            const target = all.find((m) => m.id === rid);
+            return target ? brief(target) : { id: rid, missing: true };
+        });
+        const backlinks = all.filter((m) => m.id !== id && (m.related ?? []).includes(id)).map(brief);
+        const meta = `${memory.type} (scope: ${memory.scope}, importance: ${memory.importance}` +
+            `${memory.confidence !== undefined ? `, confidence: ${memory.confidence}` : ""})`;
+        const text = `[${memory.id}] ${meta}\n${memory.content}` +
+            (related.length ? `\n\nRelated: ${related.map((r) => r.id).join(", ")}` : "") +
+            (backlinks.length ? `\nReferenced by: ${backlinks.map((b) => b.id).join(", ")}` : "");
+        return { memory, related, backlinks, text };
+    }
+    /**
+     * Manage directed links between memories (audit Phase 8: relationship
+     * graph). Targets are validated on add; backlinks are derived at read
+     * time, so one write keeps the edge consistent.
+     */
+    async relate(input) {
+        let parsed;
+        try {
+            parsed = RelateInput.parse(input);
+        }
+        catch (err) {
+            throw inputError(err, "INVALID_INPUT");
+        }
+        const memory = await this.db.get(parsed.id);
+        if (!memory)
+            throw new RemembraError("NOT_FOUND", `No memory with id ${parsed.id}`);
+        if (parsed.related.includes(parsed.id)) {
+            throw new RemembraError("INVALID_INPUT", "a memory cannot be related to itself");
+        }
+        if (parsed.action === "add") {
+            const missing = [];
+            for (const rid of parsed.related) {
+                if (!(await this.db.get(rid)))
+                    missing.push(rid);
+            }
+            if (missing.length > 0) {
+                throw new RemembraError("NOT_FOUND", `related target(s) not found: ${missing.join(", ")}`);
+            }
+        }
+        const current = memory.related ?? [];
+        const added = parsed.action === "add" ? parsed.related.filter((r) => !current.includes(r)) : [];
+        const removed = parsed.action === "remove" ? current.filter((r) => parsed.related.includes(r)) : [];
+        let next = parsed.action === "add" ? [...current, ...added] : current.filter((r) => !parsed.related.includes(r));
+        if (added.length === 0 && removed.length === 0) {
+            next = current; // no-op: don't churn updatedAt for an idempotent call
+        }
+        else {
+            await this.db.update({ ...memory, related: next });
+            metrics.inc("remembra_relate_total", { action: parsed.action });
+        }
+        const verb = parsed.action === "add" ? "Linked" : "Unlinked";
+        const changed = parsed.action === "add" ? added : removed;
+        const text = changed.length > 0
+            ? `${verb} ${parsed.id} ${parsed.action === "add" ? "→" : "⇁"} ${changed.join(", ")}`
+            : `No change: ${parsed.id} links unchanged (${next.length} total)`;
+        return { id: parsed.id, related: next, added, removed, text };
+    }
+    /**
+     * Version history with line diffs (audit Phase 8: diff/history view).
+     * Newest first; each past version carries a unified diff against its
+     * predecessor (the current version diffs against the newest snapshot).
+     */
+    async history(input) {
+        let parsed;
+        try {
+            parsed = HistoryInput.parse(input);
+        }
+        catch (err) {
+            throw inputError(err, "INVALID_INPUT");
+        }
+        const memory = await this.db.get(parsed.id);
+        if (!memory)
+            throw new RemembraError("NOT_FOUND", `No memory with id ${parsed.id}`);
+        const entries = (await this.db.history?.(parsed.id)) ?? [];
+        const kept = entries.slice(0, parsed.limit ?? entries.length);
+        const chain = [
+            { base: { current: true, at: memory.updatedAt }, content: memory.content },
+            ...kept.map((e) => ({
+                base: { file: e.file, at: e.at, snapshotAt: e.snapshotAt },
+                content: e.content,
+            })),
+        ];
+        const versions = chain.map((v, i) => {
+            const older = chain[i + 1];
+            const diff = older
+                ? unifiedDiff(older.content, v.content, older.base.at ?? "older", v.base.at ?? "current")
+                : "";
+            return { ...v.base, content: v.content, diff };
+        });
+        const lines = [`History for ${parsed.id} — ${versions.length} version(s), newest first:`];
+        for (const v of versions) {
+            const label = v.current
+                ? "current"
+                : `superseded ${v.snapshotAt?.slice(0, 19) ?? "?"} (was current: ${v.at?.slice(0, 19) ?? "?"})`;
+            lines.push("", `# ${label} — ${v.content.split("\n")[0]}`);
+            if (v.diff)
+                lines.push(v.diff.trimEnd());
+        }
+        return { id: parsed.id, versions, text: lines.join("\n") };
+    }
+    /**
+     * Redact a content+tags pair, emitting metrics + a log event when anything
+     * was found. Returns null when disabled or clean (callers keep originals).
+     */
+    redactPair(content, tags) {
+        if (!this.redactOn)
+            return null;
+        const c = redact(content);
+        const t = redactTags(tags);
+        const counts = {};
+        for (const [k, v] of Object.entries(c.counts))
+            counts[k] = v;
+        for (const [k, v] of Object.entries(t.counts)) {
+            counts[k] = (counts[k] ?? 0) + v;
+        }
+        if (Object.keys(counts).length === 0)
+            return null;
+        for (const [kind, n] of Object.entries(counts)) {
+            if (n)
+                metrics.inc("remembra_redactions_total", { kind }, n);
+        }
+        logEvent("info", "redacted", { ...counts }, `Remembra: redacted PII at ingest (${JSON.stringify(counts)})`);
+        return { content: c.text, tags: t.tags };
+    }
+    /** PII redaction of a store input (audit Phase 8). */
+    applyRedaction(parsed) {
+        const clean = this.redactPair(parsed.content, parsed.tags);
+        if (!clean)
+            return parsed;
+        return { ...parsed, content: clean.content, tags: clean.tags };
+    }
+    /** Readiness probe (audit Phase 7): can the backend actually be read? */
+    async health() {
+        let storage = "ok";
+        try {
+            await this.db.all();
+        }
+        catch (err) {
+            storage = errorLabel(err);
+        }
+        const cache = this.storageStats();
+        return {
+            status: storage === "ok" ? "ok" : "unready",
+            version: VERSION,
+            uptime_s: Math.round(process.uptime()),
+            storage,
+            ...(cache ? { cache } : {}),
+        };
+    }
+    /** Parse-cache stats when the backend exposes them (file backend does). */
+    storageStats() {
+        return this.db.cacheStats?.() ?? null;
+    }
     /**
      * Session digest (v2) with contradiction-merge (v3):
      * extract worth-keeping memories, skip exact duplicates, and let the LLM
@@ -126,9 +321,23 @@ export class MemoryService {
      * read the same active set and double-store duplicates.
      */
     async digest(opts) {
+        const t0 = performance.now();
         const run = this.digestLock.then(() => this.doDigest(opts));
         this.digestLock = run.then(() => undefined, () => undefined);
-        return run;
+        const observe = () => {
+            metrics.observe("remembra_digest_duration_seconds", (performance.now() - t0) / 1000);
+        };
+        return run.then((res) => {
+            metrics.inc("remembra_digests_total");
+            metrics.inc("remembra_digest_items_total", { result: "stored" }, res.stored.length);
+            metrics.inc("remembra_digest_items_total", { result: "skipped" }, res.skippedDuplicates);
+            metrics.inc("remembra_digest_items_total", { result: "merged" }, res.merged);
+            observe();
+            return res;
+        }, (err) => {
+            observe();
+            throw err;
+        });
     }
     digestLock = Promise.resolve();
     async doDigest(opts) {
@@ -146,7 +355,13 @@ export class MemoryService {
         const stored = [];
         let skippedDuplicates = 0;
         let merged = 0;
-        for (const item of extracted) {
+        for (const extractedItem of extracted) {
+            // PII redaction at the digest boundary: extraction LLM sees the raw
+            // transcript (it must, to understand it) — storage never does.
+            const clean = this.redactPair(extractedItem.content, extractedItem.tags);
+            const item = clean
+                ? { ...extractedItem, content: clean.content, tags: clean.tags }
+                : extractedItem;
             const scope = item.scope ?? opts.scope ?? "global";
             const key = dedupKey(item.type, item.content, scope);
             // Exact duplicate → skip (or revive if it had decayed).
@@ -195,7 +410,7 @@ export class MemoryService {
                     });
                 }
                 catch (err) {
-                    console.error(`Remembra: merge LLM failed (${String(err).slice(0, 150)}); storing fresh`);
+                    logEvent("warn", "merge_llm_failed", { error: String(err).slice(0, 150) }, `Remembra: merge LLM failed (${String(err).slice(0, 150)}); storing fresh`);
                     decision = { action: "store" };
                 }
                 if (decision.action === "skip") {
@@ -205,13 +420,17 @@ export class MemoryService {
                 if (decision.action === "merge") {
                     const now = new Date().toISOString().slice(0, 10);
                     const old = candidate.content.split("\n")[0];
-                    const content = `${decision.content}\n\n> superseded (${now}): ${old}`;
-                    const embedding = await this.maybeEmbed(decision.content);
+                    const cleanMerged = this.redactPair(decision.content, []) ?? {
+                        content: decision.content,
+                        tags: [],
+                    };
+                    const content = `${cleanMerged.content}\n\n> superseded (${now}): ${old}`;
+                    const embedding = await this.maybeEmbed(cleanMerged.content);
                     await this.db.update({ ...candidate, content, embedding, source: opts.source ?? candidate.source });
                     merged++;
                     // Re-index dedup set against the new content.
                     seen.delete(dedupKey(candidate.type, candidate.content, candidate.scope));
-                    seen.add(dedupKey(candidate.type, decision.content, candidate.scope));
+                    seen.add(dedupKey(candidate.type, cleanMerged.content, candidate.scope));
                     continue;
                 }
                 // action: "store" → fall through and store fresh
@@ -224,6 +443,7 @@ export class MemoryService {
                 tags: item.tags,
                 importance: item.importance,
                 source: opts.source,
+                confidence: item.confidence,
             }, { provenance: "auto" });
             stored.push(memory);
             active.push(memory); // so later items in this batch dedup against it
@@ -339,7 +559,7 @@ export class MemoryService {
         this.lastDecayRun = Date.now();
         this.decayRunning = true;
         this.decayPass()
-            .catch((err) => console.error("Remembra: decay pass failed:", err))
+            .catch((err) => logEvent("warn", "decay_failed", { error: String(err).slice(0, 200) }, `Remembra: decay pass failed: ${err instanceof Error ? err.message : String(err)}`))
             .finally(() => {
             this.decayRunning = false;
         });