@modusensus/dsh-mneme 0.4.5 → 0.4.6

package/src/dream.js

@@ -199,11 +199,13 @@ function buildRecordReceipts({ runId, committed, snapshot, policyEpoch }) {
  * accumulation covers both the real protocol ({type:"text-delta", index, text})
  * and looser test doubles ({type:"text-delta", text}); a terminal error/abort
  * surfaces as undefined. The caller decides how to treat an empty result.
+ * `onUsage` (optional, Bug8) receives any usage chunk for token accounting.
  */
-async function streamText(ctx, options) {
+async function streamText(ctx, options, onUsage) {
   let text = "";
   for await (const chunk of ctx.llm.stream(options)) {
     if (chunk.type === "text-delta" && typeof chunk.text === "string") text += chunk.text;
+    if (chunk.type === "usage" && typeof onUsage === "function") onUsage(chunk);
     if (chunk.type === "finish" && (chunk.reason?.kind === "error" || chunk.reason?.kind === "aborted")) {
       return undefined;
     }
@@ -211,6 +213,66 @@ async function streamText(ctx, options) {
   return text;
 }
 
+/**
+ * Bug8: wrap a background LLM call so its token/time/status are recorded in the
+ * llm_audit_logs table. Best-effort bookkeeping: a failure to WRITE the audit
+ * row is swallowed (never blocks the LLM call), while a failure of the call
+ * itself is captured as status='error' and re-thrown so the caller keeps its
+ * existing error path. `spec` carries the static metadata (trigger_source,
+ * operation_type, model_id, related_memory_ids); `body(reportUsage)` performs
+ * the actual stream consumption and is handed a usage reporter for the chunks.
+ */
+async function runAuditedLlm(ctx, service, config, spec, body) {
+  const audit = config?.llmAudit;
+  if (audit?.enabled === false || typeof service?.saveLlmAudit !== "function") return body(() => {});
+  const startedAt = Date.now();
+  const timestamp = new Date(startedAt).toISOString();
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let status = "success";
+  let errorMessage = null;
+  let result;
+  try {
+    result = await body((usage) => {
+      if (!usage) return;
+      const i = usage.input_tokens ?? usage.inputTokens ?? usage.prompt_tokens ?? usage.promptTokens;
+      const o = usage.output_tokens ?? usage.outputTokens ?? usage.completion_tokens ?? usage.completionTokens;
+      if (Number.isFinite(i)) inputTokens = i;
+      if (Number.isFinite(o)) outputTokens = o;
+    });
+    if (result === undefined) {
+      // stream aborted/errored: the caller treats undefined as a failed run;
+      // record it as error here so the audit shows the truth.
+      status = "error";
+      errorMessage = errorMessage ?? "llm stream aborted or errored";
+    }
+    return result;
+  } catch (error) {
+    status = "error";
+    errorMessage = String(error?.message ?? error);
+    throw error;
+  } finally {
+    try {
+      service.saveLlmAudit({
+        timestamp,
+        trigger_source: spec.triggerSource,
+        operation_type: spec.operationType,
+        model_id: spec.modelId,
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: inputTokens + outputTokens,
+        cost_usd: 0,
+        duration_ms: Date.now() - startedAt,
+        status,
+        error_message: errorMessage,
+        related_memory_ids: spec.relatedMemoryIds ?? []
+      });
+    } catch (auditError) {
+      ctx.logger?.warn?.(`dsh-mneme: llm audit write failed: ${String(auditError)}`);
+    }
+  }
+}
+
 /**
  * Resolve the LLM route: agent default model (deployment) first, plugin config
  * (dreamProvider/dreamModel) as fallback. Falls through to undefined when no
@@ -487,7 +549,15 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
       : CONSOLIDATION_PROMPT;
     let decisionText;
     try {
-      decisionText = await streamText(ctx, {
+      // Bug8: the consolidation call is audited (tokens/time/status). A throw
+      // re-propagates to the catch below; an aborted stream returns undefined
+      // and is treated as a failed run after the check below.
+      decisionText = await runAuditedLlm(ctx, service, config, {
+        triggerSource: "autoDream",
+        operationType: "dream_consolidate",
+        modelId: `${route.provider}:${route.model}`,
+        relatedMemoryIds: [...snapshot.keys()]
+      }, (reportUsage) => streamText(ctx, {
         provider: route.provider,
         model: route.model,
         purpose: "compaction",
@@ -499,7 +569,7 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           { role: "system", content: [{ type: "text", text: consolidationPrompt }] },
           { role: "user", content: [{ type: "text", text: listText }] }
         ]
-      });
+      }, reportUsage));
     } catch (error) {
       logger?.warn?.(`dsh-mneme dream: consolidation llm call failed: ${String(error)}`);
       return finish({ ok: false, error: "llm failed", summary: false });
@@ -637,7 +707,13 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
     // a failed run; summary:false marks a run that produced no summary.
     let summaryText;
     try {
-      summaryText = await streamText(ctx, {
+      // Bug8: the summary call is audited too (operation dream_summarize).
+      summaryText = await runAuditedLlm(ctx, service, config, {
+        triggerSource: "autoDream",
+        operationType: "dream_summarize",
+        modelId: `${route.provider}:${route.model}`,
+        relatedMemoryIds: []
+      }, (reportUsage) => streamText(ctx, {
         provider: route.provider,
         model: route.model,
         purpose: "compaction",
@@ -649,14 +725,18 @@ export function createDreamScheduler({ onRun, thresholdCount = 10, thresholdChar
           { role: "system", content: [{ type: "text", text: SUMMARY_PROMPT }] },
           { role: "user", content: [{ type: "text", text: service.all().filter((m) => !m.archived && m.type !== "summary").map((m) => `- ${m.title}: ${m.content}`).join("\n") }] }
         ]
-      });
+      }, reportUsage));
     } catch (error) {
       logger?.warn?.(`dsh-mneme dream: summary llm call failed: ${String(error)}`);
       return finish({ ok: false, error: "llm failed", applied, decisions: auditDecisions, outcome, frozen: frozenCount, summary: false });
     }
     let summaryStored = false;
     if (summaryText !== undefined && summaryText.trim()) {
-      service.saveWithDedupe({ type: "summary", title: "记忆库总览", content: summaryText.trim(), importance: 5, source: "dream" });
+      // Bug5 carve-out: the library overview is regenerated every run, so it
+      // must REPLACE the previous overview (not append — that would grow the
+      // summary unboundedly). `_overwrite` still archives the old overview into
+      // content_history before replacing it.
+      service.saveWithDedupe({ type: "summary", title: "记忆库总览", content: summaryText.trim(), importance: 5, source: "dream", _overwrite: true });
       summaryStored = true;
       // Re-embed the fresh summary so the index stays in sync with the store.
       if (semantic?.embedder && semantic?.vectorIndex) {

package/src/embedding.js

@@ -4,6 +4,20 @@
 // proxy) and any provider exposing the standard embeddings API.
 const DEFAULT_TIMEOUT_MS = 15000;
 
+/** djb2 — stable, fast fingerprint for a provider/model string. Mirrors the
+ *  hash used by the local embedders so all backends share one fingerprint
+ *  format (model#hex) for vector_meta consistency checks. */
+function hashString(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = ((h << 5) + h + s.charCodeAt(i)) >>> 0;
+  return h.toString(16);
+}
+
+/** Full provider+model fingerprint used for index-consistency checks. */
+function modelHashOf(model) {
+  return `${model}#${hashString(model)}`;
+}
+
 /** Normalize a configured baseUrl into the full embeddings endpoint URL. */
 function embeddingsUrl(baseUrl) {
   const base = String(baseUrl ?? "").trim().replace(/\/+$/, "");
@@ -50,8 +64,23 @@ export async function embedText({ baseUrl, apiKey, model }, text) {
  * Embedder bound to the current settings + store: on each write it re-embeds
  * the row's title+content and stores the vector. Failures are swallowed so a
  * flaky embedding endpoint never breaks memory writes.
+ *
+ * `vectorIndex` (optional) is the vector_meta fingerprint holder: after any
+ * successful embed the model that produced the vectors is recorded, so the
+ * index can detect drift and the auto-reindex backfill knows what to rebuild.
  */
-export function createEmbedder({ store, settings, logger }) {
+export function createEmbedder({ store, settings, logger, vectorIndex }) {
+  // Dimension of the most recent successful embed, exposed for fingerprinting.
+  let _dimension = 0;
+
+  /** Record the producing model fingerprint in vector_meta (best-effort). */
+  function markModel(cfg, dimension) {
+    if (!vectorIndex || typeof vectorIndex.markModel !== "function") return;
+    try {
+      vectorIndex.markModel(modelHashOf(cfg.model), dimension);
+    } catch { /* metadata write is best-effort */ }
+  }
+
   async function embedFor(id, title, content) {
     const cfg = settings.getVectorConfig();
     if (!cfg?.enabled || !cfg.baseUrl || !cfg.apiKey || !cfg.model) return;
@@ -59,6 +88,10 @@ export function createEmbedder({ store, settings, logger }) {
     const vector = await embedText(cfg, text);
     if (vector) {
       store.setEmbedding(id, vector);
+      _dimension = vector.length;
+      // Bug3: record which model produced the current vectors so the index can
+      // detect drift and skip a redundant backfill when nothing changed.
+      markModel(cfg, vector.length);
       logger?.info?.(`[dsh-mneme] embedded memory ${id} (dim=${vector.length})`);
     }
   }
@@ -74,7 +107,29 @@ export function createEmbedder({ store, settings, logger }) {
     async embed(query) {
       const cfg = settings.getVectorConfig();
       if (!cfg?.enabled || !cfg.baseUrl || !cfg.apiKey || !cfg.model) return null;
-      return embedText(cfg, query);
+      const vector = await embedText(cfg, query);
+      if (vector) _dimension = vector.length;
+      return vector;
+    },
+
+    // Bug1: single-text adapter. Local/ollama embedders expose embedSingle
+    // natively; the legacy OpenAI-compatible client only has embed. This
+    // adapter unifies the interface so vector-index rebuildIndex (which guards
+    // on `typeof embedder.embedSingle === "function"`) accepts this embedder.
+    async embedSingle(text) {
+      if (typeof this.embed === "function") return this.embed(text);
+      return null;
+    },
+
+    /** Model fingerprint (model#hex), or undefined when not configured. */
+    get modelHash() {
+      const cfg = settings.getVectorConfig();
+      return cfg?.enabled && cfg.model ? modelHashOf(cfg.model) : undefined;
+    },
+
+    /** Dimension of the last successful embed (0 when never embedded). */
+    get dimension() {
+      return _dimension || undefined;
     },
 
     /** Batch re-index rows still missing an embedding. */
@@ -88,9 +143,11 @@ export function createEmbedder({ store, settings, logger }) {
         const vector = await embedText(cfg, text);
         if (vector) {
           store.setEmbedding(row.id, vector);
+          _dimension = vector.length;
           indexed++;
         }
       }
+      if (indexed > 0) markModel(cfg, _dimension || undefined);
       return { indexed, skipped: rows.length - indexed };
     }
   };

package/src/index.js

@@ -43,6 +43,15 @@ export const apply = (ctx, config) => {
   try {
     store.deleteOldFailures(new Date(Date.now() - 90 * 86400000).toISOString());
   } catch { /* non-fatal */ }
+  // Bug8: enforce llm_audit_logs retention on boot (config.llmAudit.retentionDays,
+  // default 90). Best-effort like the failure prune — the audit trail is
+  // bookkeeping and a failed purge must never block plugin boot.
+  try {
+    if (cfg.llmAudit?.enabled !== false) {
+      const retentionMs = Number.isInteger(cfg.llmAudit?.retentionDays) ? cfg.llmAudit.retentionDays : 90;
+      store.deleteOldLlmAudits(new Date(Date.now() - retentionMs * 86400000).toISOString());
+    }
+  } catch { /* non-fatal */ }
   const mirror = createMirror(memoryDir);
   const service = createService({ store, mirror, config: cfg, logger: ctx.logger });
 
@@ -99,7 +108,9 @@ export const apply = (ctx, config) => {
   let embedder = null;
   let reranker = null;
   if (cfg.embedProvider === "openai") {
-    embedder = createEmbedder({ store, settings, logger: ctx.logger });
+    // vectorIndex is passed so the legacy OpenAI embedder records the producing
+    // model fingerprint after each successful embed (Bug3).
+    embedder = createEmbedder({ store, settings, logger: ctx.logger, vectorIndex });
     service.setEmbedder(embedder);
     // legacy OpenAI embedder is immediately usable
     applyHumanEdits();
@@ -155,6 +166,62 @@ export const apply = (ctx, config) => {
     }
   }
 
+  // Bug2: lazy auto-backfill of missing embeddings on boot. When the vector API
+  // is configured and rows still lack an embedding (e.g. written before vector
+  // search was enabled) AND the vector_meta fingerprint is absent or stale, the
+  // index is rebuilt in the background after a short delay. Gated on
+  // cfg.autoReindexOnBoot; rate-limited in small batches so a large backlog
+  // never floods the provider. Failures degrade silently — search stays keyword.
+  function scheduleAutoReindex() {
+    if (cfg.autoReindexOnBoot === false) return;
+    const attempt = (tries) => {
+      try {
+        if (!embedder || typeof embedder.embedSingle !== "function") return;
+        if ("ready" in embedder && embedder.ready !== true) {
+          // Local/ollama embedders init asynchronously; give them a moment
+          // before giving up on this boot (next boot retries).
+          if (tries > 0) setTimeout(() => attempt(tries - 1), 2000);
+          return;
+        }
+        if (!store.needsEmbedding(1).length) return; // nothing to backfill
+        // Model fingerprint gate: vectors already produced by the same model
+        // mean there is no drift and no rebuild needed.
+        const current = embedder.modelHash;
+        if (current && vectorIndex.modelHash?.() === current) return;
+        const BATCH = 10;
+        const MAX_TOTAL = 500; // bound boot-time work
+        (async () => {
+          let indexed = 0;
+          for (let done = 0; done < MAX_TOTAL;) {
+            const rows = store.needsEmbedding(BATCH);
+            if (!rows.length) break;
+            for (const row of rows) {
+              try {
+                const text = [row.title, row.content].filter(Boolean).join("\n");
+                const vector = await embedder.embedSingle(text);
+                if (vector?.length) {
+                  store.setEmbedding(row.id, vector);
+                  indexed++;
+                }
+              } catch { /* skip the bad row */ }
+            }
+            done += rows.length;
+            // Rate limit: space out batches so the provider is not hammered.
+            if (store.needsEmbedding(1).length) await new Promise((r) => setTimeout(r, 200));
+          }
+          if (indexed > 0 && current) vectorIndex.markModel?.(current, embedder.dimension);
+          ctx.logger?.info?.(`[dsh-mneme] auto-reindex backfilled ${indexed} embeddings on boot`);
+        })().catch((error) => {
+          ctx.logger?.warn?.(`[dsh-mneme] auto-reindex failed: ${String(error)}`);
+        });
+      } catch (error) {
+        ctx.logger?.warn?.(`[dsh-mneme] auto-reindex failed: ${String(error)}`);
+      }
+    };
+    setTimeout(() => attempt(5), 5000);
+  }
+  scheduleAutoReindex();
+
   // Custom commands: register persisted commands into the DSH command registry
   // on boot; add/remove re-register live through the API.
   let commands = null;

package/src/inject.js

@@ -1,21 +1,88 @@
+// Best-effort extraction of the current user's latest message text from the
+// live session, for semantic-first injection (Bug4). The system-prompt
+// interpolator renders synchronously, so this walks the already-materialized
+// session event log (same event shape summarize.js consumes) and returns the
+// most recent human message. Any failure degrades to "" — the injector then
+// falls back to the legacy rule-based pick, never breaking the render.
+function lastUserQuery(ctx) {
+  try {
+    const events = ctx?.agent?.session?.events;
+    if (!Array.isArray(events) || events.length === 0) return "";
+    for (let i = events.length - 1; i >= 0; i--) {
+      const event = events[i];
+      if (event?.type !== "user/message") continue;
+      const kind = event.data?.source?.kind;
+      if (kind !== undefined && kind !== "user") continue;
+      const parts = event.data?.content;
+      if (!Array.isArray(parts) || parts.length === 0) continue;
+      return parts
+        .map((p) => (typeof p === "string" ? p : p?.text ?? ""))
+        .filter(Boolean)
+        .join("\n")
+        .slice(0, 500);
+    }
+  } catch { /* session internals unavailable: degrade to no query */ }
+  return "";
+}
+
 export function createInjector(ctx, service, settings, config) {
   const maxItems = config.maxInjectedItems ?? 5;
   const threshold = config.importanceThreshold ?? 3;
 
+  // Bug6: bound the injected memory block. Each entry's content is truncated to
+  // MAX_CONTENT chars (trailing `…`); the whole block gets a MAX_BLOCK budget
+  // and an entry that would exceed it collapses to its title only, so a long
+  // memory can never push the injected context past a few thousand chars.
+  const MAX_CONTENT = 300;
+  const MAX_BLOCK = 1500;
+
   function render(candidates) {
     if (!candidates.length) return "";
-    const lines = ["[记忆库] 来自 dsh-mneme 的跨会话记忆（用户偏好与高优先级项目/决策）："];
+    const header = "[记忆库] 来自 dsh-mneme 的跨会话记忆（用户偏好与高优先级项目/决策）：";
+    const lines = [header];
+    let budget = MAX_BLOCK - header.length;
     for (const m of candidates) {
       // Epistemic trust (v0.4.5): when enabled, measured observations are
       // flagged so the agent can weigh them above guesses/opinions.
       const verified = config.trustEpistemicWeighting === true && m.epistemic_status === "observation"
         ? "[verified] "
         : "";
-      lines.push(`- [${m.type}] ${verified}${m.title}（重要性 ${m.importance}）：${m.content}`);
+      const title = `${m.title}（重要性 ${m.importance}）`;
+      let content = String(m.content ?? "");
+      if (content.length > MAX_CONTENT) content = `${content.slice(0, MAX_CONTENT)}…`;
+      const full = `- [${m.type}] ${verified}${title}：${content}`;
+      if (budget - full.length >= 0) {
+        lines.push(full);
+        budget -= full.length;
+      } else {
+        lines.push(`- [${m.type}] ${verified}${title}`);
+      }
     }
     return lines.join("\n");
   }
 
+  // Bug4: the system-prompt render is synchronous, so the semantic query vector
+  // must be prefetched asynchronously and cached for the next assembly. The
+  // first render after a new user message may still fall back to the rule-based
+  // pick; later assemblies in the same session reuse the cached vector. Bounded
+  // cache (cap 8, drop oldest) so a long session never grows it unbounded.
+  const QUERY_VECTOR_CACHE_MAX = 8;
+  const queryVectorCache = new Map();
+  let lastPrefetched = "";
+
+  function prefetchQueryVector(query) {
+    if (!query || query === lastPrefetched || queryVectorCache.has(query)) return;
+    lastPrefetched = query;
+    service.embedQuery(query).then((vec) => {
+      if (Array.isArray(vec) && vec.length) {
+        queryVectorCache.set(query, vec);
+        if (queryVectorCache.size > QUERY_VECTOR_CACHE_MAX) {
+          queryVectorCache.delete(queryVectorCache.keys().next().value);
+        }
+      }
+    }).catch(() => { /* prefetch is best-effort */ });
+  }
+
   // User profile + rules: injected ahead of the memory block because they are
   // always-relevant instructions the agent should follow every turn.
   function renderUserSettings() {
@@ -32,8 +99,15 @@ export function createInjector(ctx, service, settings, config) {
     ctx.systemPrompt.context({
       name: "memory",
       order: 90,
-      text: () => {
-        const candidates = service.injectCandidates({ maxItems, threshold });
+      text: (ctx) => {
+        // Bug4: pass the latest user query so injection prefers semantically
+        // relevant memories; lastUserQuery is best-effort (empty → legacy).
+        // The query vector is prefetched asynchronously (cached) because the
+        // render itself must stay synchronous.
+        const query = lastUserQuery(ctx);
+        if (query) prefetchQueryVector(query);
+        const queryVector = queryVectorCache.get(query);
+        const candidates = service.injectCandidates({ query, queryVector, maxItems, threshold });
         return render(candidates);
       }
     }),
@@ -45,6 +119,7 @@ export function createInjector(ctx, service, settings, config) {
   ];
 
   return () => {
+    queryVectorCache.clear();
     for (const dispose of disposers) {
       if (typeof dispose === "function") dispose();
     }

package/src/quality-filter.js

@@ -0,0 +1,123 @@
+// Rule-based memory quality filter (Bug7). Pure + total: no shared state, no
+// async, no external calls, so it can be unit-tested in isolation and wired
+// into the writer without any I/O or store access.
+//
+// evaluateMemoryQuality scores a memory 0-100 and tags low-value signals. The
+// writer then decides (config.memoryQualityFilter):
+//   score >= degradeThreshold (60)     → stored normally
+//   archiveThreshold (30) <= score < 60 → quality_score persisted; the
+//     injection sort re-ranks by importance * quality_score/100 (degraded)
+//   score < archiveThreshold (30)      → archived + tagged low_quality (still
+//     recallable via explicit search, just never auto-injected)
+//
+// Signals and their deductions from the base 100:
+//   meta                meta-memory vocabulary (the memory talks about the
+//                       memory system itself, not the user's world)    −45
+//   self_referential    title/content mentions its own type label      −15
+//   short_content       content shorter than minContentLength          −80
+//   repetitive          dedup ratio (unique chars / total) < 0.3       −50
+//   duplicate           bigram similarity to a recent memory > 0.85    −80
+//
+// The meta signal alone lands a well-formed memory in the degraded band
+// (30..60) — it is still stored and searchable, just demoted in injection.
+// Reaching the archive band (< 30) needs a degenerate body (short, repetitive
+// or near-duplicated) or stacked signals.
+
+export const META_MEMORY_RE =
+  /记忆|mneme|recall|inject|上下文|token|prompt|系统指令|作为AI|作为助手|我需要记住|总结一下刚才/;
+
+// Own-type labels, used for self-reference detection (the English type value
+// the AI writers emit plus the Chinese equivalent a human would type).
+const TYPE_LABELS = {
+  preference: ["preference", "偏好"],
+  project: ["project", "项目"],
+  decision: ["decision", "决策", "决定"],
+  history: ["history", "历史", "事件"],
+  summary: ["summary", "总结", "摘要", "总览"],
+  pattern: ["pattern", "模式", "规律"]
+};
+
+/** Normalized bigram-overlap similarity in [0,1]; 0 for tiny/empty inputs. */
+export function textSimilarity(a, b) {
+  const bigrams = (s) => {
+    const set = new Set();
+    const t = String(s).replace(/\s+/g, "");
+    for (let i = 0; i < t.length - 1; i++) set.add(t.slice(i, i + 2));
+    return set;
+  };
+  const A = bigrams(a);
+  const B = bigrams(b);
+  if (!A.size || !B.size) return 0;
+  let inter = 0;
+  for (const g of A) if (B.has(g)) inter++;
+  return inter / Math.min(A.size, B.size);
+}
+
+/** Fraction of characters that are unique (dedup ratio in [0,1]). */
+export function dedupRatio(text) {
+  const t = String(text);
+  if (!t.length) return 0;
+  return new Set(t).size / t.length;
+}
+
+/**
+ * Score a memory's quality. `recentContents` (optional) is the list of recent
+ * memory contents used for near-duplicate detection; when omitted the duplicate
+ * signal is skipped. Never throws: every input is coerced defensively.
+ * @param {object} memory  { type, title, content }
+ * @param {object} [options]
+ * @param {number} [options.minContentLength=10]
+ * @param {string[]} [options.recentContents]  up to ~20 recent contents
+ * @returns {{score: number, tags: string[], reason: string}}
+ */
+export function evaluateMemoryQuality(memory, options = {}) {
+  const minContentLength = options.minContentLength ?? 10;
+  const recentContents = Array.isArray(options.recentContents) ? options.recentContents : [];
+  const title = String(memory?.title ?? "");
+  const content = String(memory?.content ?? "");
+  const text = `${title}\n${content}`;
+  const trimmed = content.trim();
+  const tags = [];
+  const reasons = [];
+  let score = 100;
+
+  if (META_MEMORY_RE.test(text)) {
+    score -= 45;
+    tags.push("meta");
+    reasons.push("meta-memory vocabulary");
+  }
+
+  const labels = TYPE_LABELS[memory?.type];
+  if (labels && labels.some((l) => text.includes(l))) {
+    score -= 15;
+    tags.push("self_referential");
+    reasons.push("mentions its own type");
+  }
+
+  if (minContentLength > 0 && trimmed.length < minContentLength) {
+    score -= 80;
+    tags.push("short_content");
+    reasons.push(`content shorter than ${minContentLength} chars`);
+  }
+
+  if (trimmed.length > 0 && dedupRatio(trimmed) < 0.3) {
+    score -= 50;
+    tags.push("repetitive");
+    reasons.push("repetitive content");
+  }
+
+  if (recentContents.length > 0 && trimmed.length > 0) {
+    for (const other of recentContents) {
+      if (textSimilarity(trimmed, other) > 0.85) {
+        score -= 80;
+        tags.push("duplicate");
+        reasons.push("near-duplicate of a recent memory");
+        break;
+      }
+    }
+  }
+
+  score = Math.max(0, Math.min(100, Math.round(score)));
+  if (score < 30) tags.push("low_quality");
+  return { score, tags: [...new Set(tags)], reason: reasons.length ? reasons.join("; ") : "ok" };
+}