@modusensus/dsh-mneme 0.4.4 → 0.4.6

package/src/store.js

@@ -12,7 +12,9 @@ CREATE TABLE IF NOT EXISTS memories (
   forgotten   INTEGER NOT NULL DEFAULT 0,
   archived    INTEGER NOT NULL DEFAULT 0,
   source      TEXT,
+  content_history TEXT,
   embedding   TEXT,
+  epistemic_status TEXT NOT NULL DEFAULT 'subjective',
   last_accessed_at  TEXT,
   _full_content     TEXT,
   created_at  TEXT NOT NULL,
@@ -61,6 +63,29 @@ CREATE TABLE IF NOT EXISTS recall_runs (
 CREATE INDEX IF NOT EXISTS idx_recall_runs_created ON recall_runs(created_at);
 CREATE INDEX IF NOT EXISTS idx_recall_runs_query ON recall_runs(query);
 
+-- recall_evals: retrieval evaluation/test snapshots, kept SEPARATE from the
+-- recall_runs production audit so test runs never inflate the production trail.
+-- One row per evaluateRetrieval call that opted into persistence
+-- (config.evalPersistTestResults): the query, the expected ids the operator
+-- marked relevant, the actual ids retrieval returned, and the computed
+-- metrics (precision/recall/mrr). recall_run_id optionally links to the
+-- recall_runs audit row that captured the same retrieval scene (null when the
+-- eval did not also record a run). Bookkeeping like the other audit tables: it
+-- never triggers write hooks.
+CREATE TABLE IF NOT EXISTS recall_evals (
+  id            TEXT PRIMARY KEY,
+  recall_run_id TEXT,                -- FK → recall_runs.id (optional linkage)
+  query         TEXT NOT NULL,
+  expected_ids  TEXT NOT NULL,       -- JSON: relevant ids expected by the evaluator
+  actual_ids    TEXT NOT NULL,       -- JSON: ids actually retrieved
+  metrics       TEXT NOT NULL,       -- JSON: { precision, recall, mrr, hit_count }
+  eval_type     TEXT NOT NULL DEFAULT 'manual',
+  created_at    TEXT NOT NULL,
+  FOREIGN KEY (recall_run_id) REFERENCES recall_runs(id)
+);
+CREATE INDEX IF NOT EXISTS idx_recall_evals_created ON recall_evals(created_at);
+CREATE INDEX IF NOT EXISTS idx_recall_evals_run ON recall_evals(recall_run_id);
+
 -- failure_memories: records user corrections / reflection failures. Captures
 -- what a memory was (actual) vs what the user changed it to (expected)
 -- so later reflection passes can mine recurring correction patterns.
@@ -122,6 +147,31 @@ CREATE TABLE IF NOT EXISTS conflict_pending (
 );
 CREATE INDEX IF NOT EXISTS idx_conflict_pending_unresolved ON conflict_pending(resolved_at);
 
+-- llm_audit_logs: every background LLM call (autoDream consolidation + summary,
+-- autoSummarize compression) is recorded here — tokens in/out, duration, status
+-- and the trigger that caused it (Bug8). Failures are captured as status='error'
+-- and never block the calling feature. retentionDays is enforced by a boot-time
+-- purge (deleteOldLlmAudits). Bookkeeping like the other audit tables: it never
+-- triggers write hooks.
+CREATE TABLE IF NOT EXISTS llm_audit_logs (
+  id                INTEGER PRIMARY KEY AUTOINCREMENT,
+  timestamp         TEXT NOT NULL,
+  trigger_source    TEXT NOT NULL,          -- autoDream | autoSummarize | manual ...
+  operation_type    TEXT NOT NULL,          -- dream_consolidate | dream_summarize | summarize_compress ...
+  model_id          TEXT NOT NULL,
+  input_tokens      INTEGER NOT NULL DEFAULT 0,
+  output_tokens     INTEGER NOT NULL DEFAULT 0,
+  total_tokens      INTEGER NOT NULL DEFAULT 0,
+  cost_usd          REAL NOT NULL DEFAULT 0,
+  duration_ms       INTEGER NOT NULL DEFAULT 0,
+  status            TEXT NOT NULL,          -- success | error | skipped
+  error_message     TEXT,
+  related_memory_ids TEXT,                  -- JSON: ids the call operated on
+  metadata          TEXT                    -- JSON: free-form extras
+);
+CREATE INDEX IF NOT EXISTS idx_llm_audit_timestamp ON llm_audit_logs(timestamp);
+CREATE INDEX IF NOT EXISTS idx_llm_audit_source ON llm_audit_logs(trigger_source);
+
 -- entity gene (v0.3.0): named entities mentioned across memories, with
 -- time-boxed attributes (valid_from → valid_until) and typed relations.
 -- Attributes follow the snapshot style: saveAttr invalidates the previous
@@ -191,6 +241,48 @@ CREATE TABLE IF NOT EXISTS mirror_state (
 
 const TYPES = new Set(["preference", "project", "decision", "history", "summary", "pattern"]);
 
+// Epistemic status: what kind of evidence a memory rests on. Defaults to
+// 'subjective' so legacy rows (and rows without any signal) stay compatible.
+const EPISTEMIC_STATUSES = new Set(["observation", "subjective", "inferred"]);
+// Rule-based inference markers, checked in priority order (observation >
+// inferred > subjective). The default fallback is 'subjective'.
+const OBSERVATION_RE = /实测|观察到|观测|测得|测量|结果表明|数据显示|实验|统计|结果/;
+const INFERRED_RE = /推断|推测出|推导|推论|由此可|据此|综上|意味着|所以|因此/;
+const SUBJECTIVE_RE = /我推测|我猜|我觉得|我感觉|可能|大概|也许|认为|猜想|似乎|猜测|感觉/;
+
+/**
+ * Heuristically infer a memory's epistemic status from its content (and the
+ * AI-generated types). summary/pattern entries are always 'inferred' (derived
+ * from other memories); otherwise content markers decide. Pure rule-based, so
+ * it never throws and always returns a value in EPISTEMIC_STATUSES.
+ */
+function inferEpistemicStatus(memory) {
+  if (memory.type === "summary" || memory.type === "pattern") return "inferred";
+  const text = `${memory.title ?? ""} ${memory.content ?? ""}`;
+  if (OBSERVATION_RE.test(text)) return "observation";
+  if (INFERRED_RE.test(text)) return "inferred";
+  if (SUBJECTIVE_RE.test(text)) return "subjective";
+  return "subjective";
+}
+
+/** Resolve a requested epistemic_status: explicit valid value wins, otherwise
+ *  re-infer from (possibly updated) content. Never returns an invalid value. */
+function resolveEpistemicStatus(memory, patch) {
+  if (patch?.epistemic_status !== undefined) {
+    return EPISTEMIC_STATUSES.has(patch.epistemic_status) ? patch.epistemic_status : "subjective";
+  }
+  // Re-infer whenever any signal that feeds the heuristic changed: content
+  // (marker words), title (marker words), or type (summary/pattern are always
+  // inferred). Otherwise keep the stored status.
+  const changed = ["content", "title", "type"].some(
+    (k) => patch?.[k] !== undefined && patch[k] !== memory?.[k]
+  );
+  if (changed) {
+    return inferEpistemicStatus({ ...memory, ...patch });
+  }
+  return memory?.epistemic_status ?? "subjective";
+}
+
 // Per-type mirror sync receipts (peer blocker 4): a type is either committed
 // (file written + fence applied), failed (last sync round errored for it), or
 // pending (still owed a write).
@@ -229,6 +321,9 @@ function toRow(row) {
     forgotten: row.forgotten === 1,
     archived: row.archived === 1,
     source: row.source ?? undefined,
+    content_history: parseJsonArray(row.content_history),
+    quality_score: row.quality_score !== null && row.quality_score !== undefined ? Number(row.quality_score) : undefined,
+    epistemic_status: row.epistemic_status ?? "subjective",
     created_at: row.created_at,
     updated_at: row.updated_at,
     last_accessed_at: row.last_accessed_at ?? undefined,
@@ -305,6 +400,24 @@ function toRecallRun(row) {
   };
 }
 
+function toRecallEval(row) {
+  if (!row) return undefined;
+  let metrics;
+  if (row.metrics != null) {
+    try { metrics = JSON.parse(row.metrics); } catch { metrics = undefined; }
+  }
+  return {
+    id: row.id,
+    recall_run_id: row.recall_run_id ?? undefined,
+    query: row.query,
+    expected_ids: parseJsonArray(row.expected_ids),
+    actual_ids: parseJsonArray(row.actual_ids),
+    metrics,
+    eval_type: row.eval_type,
+    created_at: row.created_at
+  };
+}
+
 function toEntity(row) {
   if (!row) return undefined;
   return {
@@ -354,6 +467,34 @@ function toRelation(row) {
   };
 }
 
+function toLlmAudit(row) {
+  if (!row) return undefined;
+  let metadata;
+  if (row.metadata != null) {
+    try {
+      metadata = JSON.parse(row.metadata);
+    } catch {
+      metadata = row.metadata;
+    }
+  }
+  return {
+    id: row.id,
+    timestamp: row.timestamp,
+    trigger_source: row.trigger_source,
+    operation_type: row.operation_type,
+    model_id: row.model_id,
+    input_tokens: row.input_tokens,
+    output_tokens: row.output_tokens,
+    total_tokens: row.total_tokens,
+    cost_usd: row.cost_usd,
+    duration_ms: row.duration_ms,
+    status: row.status,
+    error_message: row.error_message ?? undefined,
+    related_memory_ids: parseJsonArray(row.related_memory_ids),
+    metadata
+  };
+}
+
 function toMirrorState(row) {
   if (!row) {
     return {
@@ -421,6 +562,15 @@ export function createStore(path) {
   if (!columns.includes("_full_content")) {
     db.exec("ALTER TABLE memories ADD COLUMN _full_content TEXT");
   }
+  if (!columns.includes("epistemic_status")) {
+    db.exec("ALTER TABLE memories ADD COLUMN epistemic_status TEXT NOT NULL DEFAULT 'subjective'");
+  }
+  if (!columns.includes("content_history")) {
+    db.exec("ALTER TABLE memories ADD COLUMN content_history TEXT");
+  }
+  if (!columns.includes("quality_score")) {
+    db.exec("ALTER TABLE memories ADD COLUMN quality_score REAL");
+  }
 
   // Legacy dream_runs without policy_epoch → backfill with the default epoch.
   const dreamCols = db.prepare("PRAGMA table_info(dream_runs)").all().map((c) => c.name);
@@ -512,11 +662,31 @@ export function createStore(path) {
     const embedding = Array.isArray(memory.embedding) && memory.embedding.length
       ? JSON.stringify(memory.embedding)
       : null;
+    // Explicit valid status wins; otherwise infer from content/type. Falls back
+    // to 'subjective' (the column default) so legacy callers never break.
+    const epistemicStatus = EPISTEMIC_STATUSES.has(memory.epistemic_status)
+      ? memory.epistemic_status
+      : inferEpistemicStatus(memory);
     runAtomically(() => {
       db.prepare(
-        `INSERT INTO memories (id, type, title, content, tags, importance, forgotten, source, embedding, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?)`
-      ).run(id, type, memory.title, memory.content, tags, importance, memory.source ?? null, embedding, now, now);
+        `INSERT INTO memories (id, type, title, content, tags, importance, forgotten, archived, source, content_history, quality_score, embedding, epistemic_status, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?)`
+      ).run(
+        id,
+        type,
+        memory.title,
+        memory.content,
+        tags,
+        importance,
+        memory.archived ? 1 : 0,
+        memory.source ?? null,
+        JSON.stringify(memory.content_history ?? []),
+        Number.isFinite(memory.quality_score) ? memory.quality_score : null,
+        embedding,
+        epistemicStatus,
+        now,
+        now
+      );
       // desired generation bumped in the same transaction as the write: once
       // this commits, generation > applied_generation, so a crash right after
       // (before syncMirror) is caught by recoverMirror on restart (peer
@@ -538,9 +708,16 @@ export function createStore(path) {
     const embedding = patch.embedding !== undefined
       ? (Array.isArray(patch.embedding) && patch.embedding.length ? JSON.stringify(patch.embedding) : null)
       : existing.embedding ?? null;
+    const epistemicStatus = resolveEpistemicStatus(existing, patch);
+    const contentHistory = Array.isArray(patch.content_history)
+      ? JSON.stringify(patch.content_history)
+      : (Array.isArray(existing.content_history) ? JSON.stringify(existing.content_history) : null);
+    const qualityScore = patch.quality_score !== undefined && Number.isFinite(patch.quality_score)
+      ? patch.quality_score
+      : (existing.quality_score ?? null);
     runAtomically(() => {
       db.prepare(
-        `UPDATE memories SET type=?, title=?, content=?, tags=?, importance=?, source=?, embedding=?, updated_at=? WHERE id=?`
+        `UPDATE memories SET type=?, title=?, content=?, tags=?, importance=?, source=?, content_history=?, quality_score=?, embedding=?, epistemic_status=?, updated_at=? WHERE id=?`
       ).run(
         type,
         patch.title ?? existing.title,
@@ -548,7 +725,10 @@ export function createStore(path) {
         JSON.stringify(patch.tags ?? existing.tags),
         Number.isInteger(patch.importance) ? patch.importance : existing.importance,
         patch.source !== undefined ? patch.source : (existing.source ?? null),
+        contentHistory,
+        qualityScore,
         embedding,
+        epistemicStatus,
         now,
         id
       );
@@ -588,6 +768,13 @@ export function createStore(path) {
     const embedding = patch.embedding !== undefined
       ? (Array.isArray(patch.embedding) && patch.embedding.length ? JSON.stringify(patch.embedding) : null)
       : existing.embedding ?? null;
+    const epistemicStatus = resolveEpistemicStatus(existing, patch);
+    const contentHistory = Array.isArray(patch.content_history)
+      ? JSON.stringify(patch.content_history)
+      : (Array.isArray(existing.content_history) ? JSON.stringify(existing.content_history) : null);
+    const qualityScore = patch.quality_score !== undefined && Number.isFinite(patch.quality_score)
+      ? patch.quality_score
+      : (existing.quality_score ?? null);
     // The CAS UPDATE and the desired-generation bump must commit together (audit
     // peer A): if the UPDATE autocommits first and the process dies before the
     // increment, the store is mutated while generation == applied_generation and
@@ -597,7 +784,7 @@ export function createStore(path) {
     let applied = false;
     runAtomically(() => {
       const result = db.prepare(
-        `UPDATE memories SET type=?, title=?, content=?, tags=?, importance=?, source=?, embedding=?, updated_at=?
+        `UPDATE memories SET type=?, title=?, content=?, tags=?, importance=?, source=?, content_history=?, quality_score=?, embedding=?, epistemic_status=?, updated_at=?
          WHERE id=? AND updated_at=?`
       ).run(
         type,
@@ -606,7 +793,10 @@ export function createStore(path) {
         JSON.stringify(patch.tags ?? existing.tags),
         Number.isInteger(patch.importance) ? patch.importance : existing.importance,
         patch.source !== undefined ? patch.source : (existing.source ?? null),
+        contentHistory,
+        qualityScore,
         embedding,
+        epistemicStatus,
         now,
         id,
         expectedUpdatedAt
@@ -1001,6 +1191,169 @@ export function createStore(path) {
     return rows.map(toRecallRun);
   }
 
+  // --- recall evaluation trail (方案 B: separate from the production audit) -
+
+  /**
+   * Persist one retrieval-evaluation snapshot into recall_evals — the test/eval
+   * sibling of recall_runs, deliberately stored apart so eval snapshots never
+   * inflate the production recall audit. Like the other audit tables this is
+   * bookkeeping: it never triggers write hooks. Writes are idempotent on id
+   * (replay overwrites, never duplicates), matching saveRecallRun. recall_run_id
+   * optionally links the eval to the recall_runs row that captured the same
+   * retrieval scene (FK-referenced, null when no run was recorded).
+   */
+  function saveRecallEval(evalRow) {
+    const id = evalRow.id ?? randomUUID();
+    db.prepare(
+      `INSERT INTO recall_evals (id, recall_run_id, query, expected_ids, actual_ids, metrics, eval_type, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         recall_run_id=excluded.recall_run_id, query=excluded.query,
+         expected_ids=excluded.expected_ids, actual_ids=excluded.actual_ids,
+         metrics=excluded.metrics, eval_type=excluded.eval_type,
+         created_at=excluded.created_at`
+    ).run(
+      id,
+      evalRow.recall_run_id ?? null,
+      evalRow.query,
+      JSON.stringify(evalRow.expected_ids ?? []),
+      JSON.stringify(evalRow.actual_ids ?? []),
+      JSON.stringify(evalRow.metrics ?? {}),
+      evalRow.eval_type ?? "manual",
+      evalRow.created_at ?? nowIso()
+    );
+    return getRecallEval(id);
+  }
+
+  function getRecallEval(id) {
+    const row = db.prepare("SELECT * FROM recall_evals WHERE id = ?").get(id);
+    return toRecallEval(row);
+  }
+
+  function listRecallEvals({ limit = 50, offset = 0, query } = {}) {
+    const { limit: lim, offset: off } = sanitizePage(limit, offset, 50);
+    const clauses = [];
+    const params = [];
+    if (query) {
+      clauses.push("query LIKE ? ESCAPE '\\'");
+      params.push(`%${escapeLike(String(query))}%`);
+    }
+    const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = db.prepare(
+      `SELECT * FROM recall_evals ${where} ORDER BY created_at DESC, id LIMIT ? OFFSET ?`
+    ).all(...params, lim, off);
+    return rows.map(toRecallEval);
+  }
+
+  // --- llm audit trail (Bug8) ---------------------------------------------
+
+  /**
+   * Persist one LLM audit row (a background call's token/time/status receipt).
+   * Bookkeeping like the other audit tables: it never triggers write hooks, so
+   * recording a call can never loop back into the scheduler that made it. The
+   * call itself is wrapped so a failure is captured (status='error') instead of
+   * blocking the feature — only a throwing saveLlmAudit is swallowed, never the
+   * LLM call.
+   */
+  function saveLlmAudit(entry) {
+    const now = nowIso();
+    const inTokens = Number.isFinite(entry.input_tokens) ? entry.input_tokens : 0;
+    const outTokens = Number.isFinite(entry.output_tokens) ? entry.output_tokens : 0;
+    db.prepare(
+      `INSERT INTO llm_audit_logs (timestamp, trigger_source, operation_type, model_id,
+        input_tokens, output_tokens, total_tokens, cost_usd, duration_ms, status,
+        error_message, related_memory_ids, metadata)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      entry.timestamp ?? now,
+      entry.trigger_source,
+      entry.operation_type,
+      entry.model_id,
+      inTokens,
+      outTokens,
+      Number.isFinite(entry.total_tokens) ? entry.total_tokens : inTokens + outTokens,
+      Number.isFinite(entry.cost_usd) ? entry.cost_usd : 0,
+      Number.isFinite(entry.duration_ms) ? entry.duration_ms : 0,
+      entry.status ?? "success",
+      entry.error_message ?? null,
+      JSON.stringify(entry.related_memory_ids ?? []),
+      entry.metadata !== undefined
+        ? (typeof entry.metadata === "string" ? entry.metadata : JSON.stringify(entry.metadata))
+        : null
+    );
+    return toLlmAudit(db.prepare("SELECT * FROM llm_audit_logs ORDER BY id DESC LIMIT 1").get());
+  }
+
+  function listLlmAudits({ limit = 50, offset = 0, source } = {}) {
+    const { limit: lim, offset: off } = sanitizePage(limit, offset, 50);
+    const clauses = [];
+    const params = [];
+    if (source) {
+      clauses.push("trigger_source = ?");
+      params.push(source);
+    }
+    const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = db.prepare(
+      `SELECT * FROM llm_audit_logs ${where} ORDER BY timestamp DESC, id DESC LIMIT ? OFFSET ?`
+    ).all(...params, lim, off);
+    return rows.map(toLlmAudit);
+  }
+
+  function countLlmAudits({ source } = {}) {
+    const clauses = [];
+    const params = [];
+    if (source) {
+      clauses.push("trigger_source = ?");
+      params.push(source);
+    }
+    const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
+    return db.prepare(`SELECT count(*) AS c FROM llm_audit_logs ${where}`).get(...params).c;
+  }
+
+  /**
+   * Aggregate LLM spend over the last `days`: total calls/tokens/duration/cost,
+   * broken down by trigger_source and by status. Used by the API's
+   * /llm-audit/stats endpoint so the Web panel can show where budget goes.
+   */
+  function getLlmAuditStats({ days = 7 } = {}) {
+    const since = new Date(Date.now() - days * 86400000).toISOString();
+    const total = db.prepare(
+      `SELECT count(*) AS c,
+              COALESCE(SUM(input_tokens), 0) AS i,
+              COALESCE(SUM(output_tokens), 0) AS o,
+              COALESCE(SUM(total_tokens), 0) AS t,
+              COALESCE(SUM(duration_ms), 0) AS d,
+              COALESCE(SUM(cost_usd), 0) AS cst
+       FROM llm_audit_logs WHERE timestamp >= ?`
+    ).get(since);
+    const bySource = db.prepare(
+      `SELECT trigger_source AS source, count(*) AS c,
+              COALESCE(SUM(total_tokens), 0) AS total_tokens
+       FROM llm_audit_logs WHERE timestamp >= ?
+       GROUP BY trigger_source ORDER BY total_tokens DESC`
+    ).all(since);
+    const byStatus = db.prepare(
+      "SELECT status, count(*) AS c FROM llm_audit_logs WHERE timestamp >= ? GROUP BY status"
+    ).all(since);
+    return {
+      days,
+      since,
+      total_calls: total.c,
+      input_tokens: total.i,
+      output_tokens: total.o,
+      total_tokens: total.t,
+      total_duration_ms: total.d,
+      total_cost_usd: Number(total.cst),
+      by_source: bySource,
+      by_status: byStatus
+    };
+  }
+
+  /** Delete audit rows older than `before` (ISO string). Returns count removed. */
+  function deleteOldLlmAudits(before) {
+    return db.prepare("DELETE FROM llm_audit_logs WHERE timestamp < ?").run(before).changes;
+  }
+
   // --- failure memories ----------------------------------------------------
 
   /**
@@ -1524,6 +1877,14 @@ export function createStore(path) {
     saveRecallRun,
     getRecallRun,
     listRecallRuns,
+    saveRecallEval,
+    getRecallEval,
+    listRecallEvals,
+    saveLlmAudit,
+    listLlmAudits,
+    countLlmAudits,
+    getLlmAuditStats,
+    deleteOldLlmAudits,
     saveFailure,
     listFailures,
     getFailureStats,

package/src/summarize.js

@@ -98,6 +98,12 @@ export function createSummarizer(ctx, service, config) {
     if (disposed || inFlight.has(session.id)) return;
     const controller = new AbortController();
     inFlight.set(session.id, controller);
+    // Bug8: audit state for the compression call. null = no audit for this run
+    // (disabled, or no LLM call was actually made). The audit row is written in
+    // the finally below — once, regardless of which exit path the call took —
+    // so a failed/aborted stream still leaves a status='error' trail without
+    // ever blocking the summarization itself.
+    let audit = null;
     try {
       const header = session.requestHeader?.()?.config;
       // Config override takes priority, then session header, then nothing.
@@ -110,6 +116,18 @@ export function createSummarizer(ctx, service, config) {
       const messages = collectMessages(session);
       if (!messages.length) return;
 
+      if (config?.llmAudit?.enabled !== false && typeof service.saveLlmAudit === "function") {
+        audit = {
+          route,
+          timestamp: new Date().toISOString(),
+          startedAt: Date.now(),
+          inputTokens: 0,
+          outputTokens: 0,
+          status: "success",
+          errorMessage: null
+        };
+      }
+
       const assembler = new BlockAssembler();
       let text = "";
       const options = {
@@ -122,15 +140,35 @@ export function createSummarizer(ctx, service, config) {
         ],
         signal: controller.signal
       };
-      for await (const chunk of ctx.llm.stream(options)) {
-        if (STREAM_CHUNK_TYPES.has(chunk.type)) assembler.push(toProtocolChunk(chunk));
-        if (chunk.type === "text-delta") {
-          text += chunk.text ?? chunk.delta ?? "";
+      try {
+        for await (const chunk of ctx.llm.stream(options)) {
+          if (STREAM_CHUNK_TYPES.has(chunk.type)) assembler.push(toProtocolChunk(chunk));
+          if (chunk.type === "text-delta") {
+            text += chunk.text ?? chunk.delta ?? "";
+          }
+          if (chunk.type === "usage" && audit) {
+            const i = chunk.input_tokens ?? chunk.inputTokens ?? chunk.prompt_tokens ?? chunk.promptTokens;
+            const o = chunk.output_tokens ?? chunk.outputTokens ?? chunk.completion_tokens ?? chunk.completionTokens;
+            if (Number.isFinite(i)) audit.inputTokens = i;
+            if (Number.isFinite(o)) audit.outputTokens = o;
+          }
+          if (chunk.type === "finish") {
+            const reasonKind = chunk.reason?.kind ?? chunk.kind;
+            if (reasonKind === "error" || reasonKind === "aborted") {
+              if (audit) {
+                audit.status = "error";
+                audit.errorMessage = `llm stream ${reasonKind}`;
+              }
+              return;
+            }
+          }
         }
-        if (chunk.type === "finish") {
-          const reasonKind = chunk.reason?.kind ?? chunk.kind;
-          if (reasonKind === "error" || reasonKind === "aborted") return;
+      } catch (error) {
+        if (audit) {
+          audit.status = "error";
+          audit.errorMessage = String(error?.message ?? error);
         }
+        throw error; // caller's catch handles the failure; audit already staged
       }
       // Direct delta accumulation is the primary extraction path (it works
       // for real protocol chunks {index,text} and looser {delta} shapes
@@ -147,6 +185,26 @@ export function createSummarizer(ctx, service, config) {
         service.saveWithDedupe({ ...entry, source: `session:${session.id}` });
       }
     } finally {
+      if (audit) {
+        try {
+          service.saveLlmAudit({
+            timestamp: audit.timestamp,
+            trigger_source: "autoSummarize",
+            operation_type: "summarize_compress",
+            model_id: `${audit.route.provider}:${audit.route.model}`,
+            input_tokens: audit.inputTokens,
+            output_tokens: audit.outputTokens,
+            total_tokens: audit.inputTokens + audit.outputTokens,
+            cost_usd: 0,
+            duration_ms: Date.now() - audit.startedAt,
+            status: audit.status,
+            error_message: audit.errorMessage,
+            related_memory_ids: []
+          });
+        } catch (auditError) {
+          ctx.logger?.warn?.(`dsh-mneme: llm audit write failed: ${String(auditError)}`);
+        }
+      }
       inFlight.delete(session.id);
     }
   }

package/src/vector-index.js

@@ -73,13 +73,23 @@ export function createVectorIndex({ store, logger }) {
 
     /** Re-embed every row missing an embedding. Returns indexed count. */
     async rebuildIndex(embedder, { limit = 1000 } = {}) {
-      if (!embedder || typeof embedder.embedSingle !== "function") return { indexed: 0, skipped: 0 };
+      // The loop needs a single-text embedder. Native embedSingle is preferred;
+      // embed-only OpenAI-compatible clients (issue #10) are accepted too via
+      // their `embed` single-text interface, so /vector-reindex no longer
+      // silently returns 0 for them. An embedder exposing neither is ignored.
+      let embedOne = null;
+      if (embedder && typeof embedder.embedSingle === "function") {
+        embedOne = (text) => embedder.embedSingle(text);
+      } else if (embedder && typeof embedder.embed === "function") {
+        embedOne = (text) => Promise.resolve(embedder.embed(text));
+      }
+      if (!embedOne) return { indexed: 0, skipped: 0 };
       const rows = store.needsEmbedding(limit);
       let indexed = 0;
       for (const row of rows) {
         try {
           const text = [row.title, row.content].filter(Boolean).join("\n");
-          const vector = await embedder.embedSingle(text);
+          const vector = await embedOne(text);
           if (vector && vector.length) {
             store.setEmbedding(row.id, vector);
             indexed++;