@shadowforge0/aquifer-memory 1.0.3 → 1.3.0

package/consumers/miranda/render-daily-md.js

@@ -0,0 +1,186 @@
+'use strict';
+
+// Miranda daily log renderer — reference implementation for the artifact
+// capability (spec §12).
+//
+// Pulls the canonical state for a date from Aquifer (timeline events + latest
+// state + active narrative + latest handoff) and renders it into a single
+// markdown file. Pure logic — does not write to disk; returns the rendered
+// string plus an artifact record declaration the caller can persist via
+// aq.artifacts.record().
+//
+// Shape deliberately mirrors the historical Miranda daily-log format so the
+// downstream consumers (CC, Discord pushes, weekly rollup) see no regression
+// during the cutover from render-daily-log.js to this reference impl.
+
+const crypto = require('crypto');
+
+function startOfDayIso(dateStr) {
+  return `${dateStr}T00:00:00Z`;
+}
+
+function endOfDayIso(dateStr) {
+  return `${dateStr}T23:59:59.999Z`;
+}
+
+function ensureDate(input) {
+  if (!input) throw new Error('date (YYYY-MM-DD) is required');
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(input)) {
+    throw new Error(`date must match YYYY-MM-DD, got: ${input}`);
+  }
+  return input;
+}
+
+function renderSection(title, lines) {
+  if (!lines || lines.length === 0) return null;
+  return `## ${title}\n\n${lines.join('\n')}\n`;
+}
+
+function formatTimelineLine(evt) {
+  const ts = new Date(evt.occurredAt).toISOString().slice(11, 16);
+  const src = evt.sessionRef ? ` (${evt.sessionRef})` : '';
+  return `- \`${ts}\`${src} ${evt.text}`;
+}
+
+function formatHandoff(payload) {
+  if (!payload) return null;
+  const lines = [];
+  if (payload.last_step) lines.push(`**Last step.** ${payload.last_step}`);
+  if (payload.status) lines.push(`**Status.** ${payload.status}`);
+  if (payload.next) lines.push(`**Next.** ${payload.next}`);
+  if (Array.isArray(payload.blockers) && payload.blockers.length > 0) {
+    lines.push(`**Blockers.**`);
+    for (const b of payload.blockers) lines.push(`- ${b}`);
+  }
+  if (Array.isArray(payload.open_loops) && payload.open_loops.length > 0) {
+    lines.push(`**Open loops.**`);
+    for (const l of payload.open_loops) lines.push(`- ${l}`);
+  }
+  return lines.length > 0 ? lines.join('\n') + '\n' : null;
+}
+
+function formatState(state) {
+  if (!state) return null;
+  const lines = [];
+  if (state.goal) lines.push(`**Goal.** ${state.goal}`);
+  if (Array.isArray(state.active_work) && state.active_work.length > 0) {
+    lines.push(`**Active work.**`);
+    for (const w of state.active_work) lines.push(`- ${w}`);
+  }
+  if (state.affect && typeof state.affect === 'object') {
+    const bits = [];
+    if (state.affect.mood) bits.push(`mood: ${state.affect.mood}`);
+    if (state.affect.energy) bits.push(`energy: ${state.affect.energy}`);
+    if (state.affect.confidence) bits.push(`confidence: ${state.affect.confidence}`);
+    if (bits.length > 0) lines.push(`**Affect.** ${bits.join(', ')}`);
+  }
+  return lines.length > 0 ? lines.join('\n') + '\n' : null;
+}
+
+// -------------------------------------------------------------------------
+// Public entry
+// -------------------------------------------------------------------------
+//
+// renderDailyMd({ aquifer, date, agentId, tenantId?, categories? }) returns:
+//   {
+//     markdown: string,
+//     artifact: { producerId, type, format, destination, payload,
+//                 idempotencyKey }  // ready for aq.artifacts.record()
+//   }
+//
+// The caller decides whether to persist the artifact record and where the
+// rendered file lands. Aquifer itself doesn't touch disk.
+
+async function renderDailyMd({
+  aquifer, date, agentId, tenantId, categories,
+  destinationTemplate = 'workspace://memory/{date}.md',
+  producerId = 'miranda.workspace.daily-log',
+}) {
+  if (!aquifer) throw new Error('aquifer instance is required');
+  if (!agentId) throw new Error('agentId is required');
+  const day = ensureDate(date);
+
+  const since = startOfDayIso(day);
+  const until = endOfDayIso(day);
+
+  const timelineResult = await aquifer.timeline.list({
+    tenantId, agentId, categories, since, until, limit: 500,
+  });
+  if (!timelineResult.ok) throw new Error(`timeline.list failed: ${timelineResult.error.message}`);
+
+  const stateResult = await aquifer.state.getLatest({ tenantId, agentId });
+  if (!stateResult.ok) throw new Error(`state.getLatest failed: ${stateResult.error.message}`);
+
+  const handoffResult = await aquifer.handoff.getLatest({ tenantId, agentId });
+  if (!handoffResult.ok) throw new Error(`handoff.getLatest failed: ${handoffResult.error.message}`);
+
+  const narrativeResult = await aquifer.narratives.getLatest({ tenantId, agentId });
+  if (!narrativeResult.ok) throw new Error(`narratives.getLatest failed: ${narrativeResult.error.message}`);
+
+  const events = (timelineResult.data.rows || []).slice().sort((a, b) =>
+    new Date(a.occurredAt).getTime() - new Date(b.occurredAt).getTime());
+
+  // Group timeline by category.
+  const grouped = new Map();
+  for (const evt of events) {
+    if (!grouped.has(evt.category)) grouped.set(evt.category, []);
+    grouped.get(evt.category).push(evt);
+  }
+
+  const sections = [];
+  sections.push(`# ${day}\n`);
+  const stateBlock = formatState(stateResult.data.state);
+  if (stateBlock) sections.push(`## State\n\n${stateBlock}`);
+
+  if (narrativeResult.data.narrative) {
+    sections.push(`## Narrative\n\n${narrativeResult.data.narrative.text}\n`);
+  }
+
+  const categoryOrder = ['focus', 'todo', 'mood', 'handoff', 'narrative',
+    'organized', 'note', 'stats', 'health', 'garmin', 'weekly', 'monthly', 'cli'];
+  const emitted = new Set();
+  for (const cat of categoryOrder) {
+    if (!grouped.has(cat)) continue;
+    const lines = grouped.get(cat).map(formatTimelineLine);
+    const sec = renderSection(cat.charAt(0).toUpperCase() + cat.slice(1), lines);
+    if (sec) sections.push(sec);
+    emitted.add(cat);
+  }
+  for (const [cat, evts] of grouped) {
+    if (emitted.has(cat)) continue;
+    const lines = evts.map(formatTimelineLine);
+    const sec = renderSection(cat, lines);
+    if (sec) sections.push(sec);
+  }
+
+  const handoffBlock = formatHandoff(handoffResult.data.handoff);
+  if (handoffBlock) sections.push(`## Handoff\n\n${handoffBlock}`);
+
+  const markdown = sections.join('\n').replace(/\n{3,}/g, '\n\n').trim() + '\n';
+
+  const destination = destinationTemplate.replace('{date}', day);
+  const idempotencyKey = crypto.createHash('sha256')
+    .update(`miranda:daily:${tenantId || 'default'}:${agentId}:${day}`)
+    .digest('hex');
+
+  return {
+    markdown,
+    artifact: {
+      producerId,
+      type: 'daily-log',
+      format: 'markdown',
+      destination,
+      triggerPhase: 'artifact_dispatch',
+      payload: {
+        date: day,
+        event_count: events.length,
+        has_state: !!stateResult.data.state,
+        has_handoff: !!handoffResult.data.handoff,
+        has_narrative: !!narrativeResult.data.narrative,
+      },
+      idempotencyKey,
+    },
+  };
+}
+
+module.exports = { renderDailyMd };

package/consumers/miranda/workspace-files.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Host-owned file paths: emotional state + recap JSON + learned skills.
+// These are Miranda persona artifacts; other consumers won't want them.
+
+function extractFilePaths(conversationText) {
+    const re = /(?:^|\s|["'`])((?:\/[\w.@-]+)+(?:\/[\w.@-]+)*\.[\w]+)/g;
+    const paths = new Set();
+    let m;
+    while ((m = re.exec(conversationText || '')) !== null) {
+        const p = m[1];
+        if (p.startsWith('/bin/') || p.startsWith('/usr/') || p.startsWith('/etc/')) continue;
+        if (p.includes('node_modules/')) continue;
+        paths.add(p);
+    }
+    return [...paths].slice(0, 30);
+}
+
+async function writeWorkspaceFiles(sections, recap, workspaceDir, context, logger = console) {
+    let emotionalStateWritten = false;
+    const recapFilesWritten = [];
+    let learnedSkillsWritten = 0;
+
+    if (sections?.emotional_state) {
+        await fs.promises.mkdir(path.join(workspaceDir, 'memory'), { recursive: true });
+        await fs.promises.writeFile(
+            path.join(workspaceDir, 'memory', 'emotional-state.md'),
+            sections.emotional_state, 'utf8',
+        );
+        emotionalStateWritten = true;
+        if (logger.info) logger.info('[miranda] wrote emotional state');
+    }
+
+    if (recap?.title) {
+        const sessDir = path.join(workspaceDir, 'memory', 'sessions');
+        await fs.promises.mkdir(sessDir, { recursive: true });
+        if (context?.conversationText) recap.files_mentioned = extractFilePaths(context.conversationText);
+
+        await fs.promises.writeFile(
+            path.join(sessDir, 'afterburn-latest.json'),
+            JSON.stringify(recap, null, 2), 'utf8',
+        );
+        recapFilesWritten.push('afterburn-latest.json');
+
+        const safeId = String(context?.sessionId || '').replace(/[^a-zA-Z0-9._-]/g, '_');
+        if (safeId) {
+            const fname = `afterburn-${safeId}.json`;
+            await fs.promises.writeFile(path.join(sessDir, fname), JSON.stringify(recap, null, 2), 'utf8');
+            recapFilesWritten.push(fname);
+        }
+        if (logger.info) logger.info(`[miranda] wrote recap (title=${recap.title.slice(0, 40)})`);
+    }
+
+    if (Array.isArray(recap?.reusable_patterns) && recap.reusable_patterns.length > 0) {
+        try {
+            const skillsPath = path.join(workspaceDir, 'memory', 'topics', 'learned-skills.md');
+            let existing = '';
+            try { existing = await fs.promises.readFile(skillsPath, 'utf8'); } catch { /* first write */ }
+            if (!existing) {
+                existing = '# Learned Skills\n\n> 自動從 session 中抽取的可重用操作模式。\n> invariant = 永久規則。derived = 情境洞察（可能過期）。\n\n';
+            }
+            const now = new Intl.DateTimeFormat('sv-SE', {
+                timeZone: 'Asia/Taipei',
+                year: 'numeric', month: '2-digit', day: '2-digit',
+            }).format(new Date());
+            const patterns = recap.reusable_patterns.filter(p => p.pattern && p.trigger);
+            const lines = [];
+            for (const p of patterns) {
+                const icon = p.durability === 'invariant' ? '🔒' : '📌';
+                const suffix = p.durability !== 'invariant' ? '（expires ~14d）' : '';
+                lines.push(`- ${icon} **${p.pattern}** — 觸發：${p.trigger}；做法：${p.action || '(見 session)'}${suffix}`);
+            }
+            if (lines.length > 0) {
+                await fs.promises.mkdir(path.dirname(skillsPath), { recursive: true });
+                const section = `\n### ${now} (${String(context?.sessionId || '').slice(0, 8)})\n${lines.join('\n')}\n`;
+                await fs.promises.writeFile(skillsPath, existing + section, 'utf8');
+                learnedSkillsWritten = patterns.length;
+                if (logger.info) logger.info(`[miranda] wrote ${patterns.length} skill(s)`);
+            }
+        } catch (err) {
+            if (logger.info) logger.info(`[miranda] skill write skip: ${err.message}`);
+        }
+    }
+
+    return { emotionalStateWritten, recapFilesWritten, learnedSkillsWritten };
+}
+
+module.exports = { writeWorkspaceFiles, extractFilePaths };

package/consumers/openclaw-ext/index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+// Aquifer Memory — drop-in OpenClaw extension
+//
+// Host layout:
+//   $OPENCLAW_HOME/extensions/aquifer-memory/  ← symlink to this directory
+//   (or run `bash scripts/install-openclaw.sh $OPENCLAW_HOME` from the tarball)
+//
+// Behavior:
+//   - Loads $OPENCLAW_HOME/.env so DATABASE_URL / EMBED_PROVIDER /
+//     AQUIFER_LLM_PROVIDER etc. are visible to the plugin.
+//   - Delegates to consumers/openclaw-plugin.js. If AQUIFER_PERSONA is set
+//     (pluginConfig.persona or env), the plugin loads the persona module
+//     and hands off mountOnOpenClaw(api); otherwise the default generic
+//     path runs (before_reset capture + session_recall + session_feedback).
+//
+// Host-specific customization goes in a persona module, not here.
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const OPENCLAW_HOME = process.env.OPENCLAW_HOME || path.join(os.homedir(), '.openclaw');
+
+function loadEnvFile(envPath) {
+  try {
+    const text = fs.readFileSync(envPath, 'utf8');
+    for (const line of text.split('\n')) {
+      const m = line.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/);
+      if (m && !process.env[m[1]]) process.env[m[1]] = m[2].trim();
+    }
+  } catch { /* .env missing — ok */ }
+}
+
+loadEnvFile(path.join(OPENCLAW_HOME, '.env'));
+
+// Re-export the plugin as-is. OpenClaw expects { id, name, register }.
+module.exports = require('../openclaw-plugin');

package/consumers/openclaw-ext/openclaw.plugin.json

@@ -0,0 +1,9 @@
+{
+  "id": "aquifer-memory",
+  "name": "Aquifer Memory",
+  "version": "1.2.0",
+  "description": "Session ingest + recall + feedback. Reads DATABASE_URL / EMBED_PROVIDER / AQUIFER_LLM_PROVIDER from host env; delegates to AQUIFER_PERSONA module if set.",
+  "main": "index.js",
+  "hooks": ["before_reset"],
+  "configSchema": {}
+}

package/consumers/openclaw-ext/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "aquifer-openclaw-ext",
+  "version": "1.2.0",
+  "private": true,
+  "main": "index.js",
+  "description": "Drop-in OpenClaw extension for Aquifer Memory. Symlink into $OPENCLAW_HOME/extensions/aquifer-memory/ — no host-side boilerplate required.",
+  "openclaw": {
+    "plugin": "./openclaw.plugin.json"
+  }
+}

package/consumers/openclaw-plugin.js

@@ -16,6 +16,8 @@
  */
 
 const { createAquiferFromConfig } = require('./shared/factory');
+const { runIngest } = require('./shared/ingest');
+const { formatRecallResults: sharedFormatRecallResults } = require('./shared/recall-format');
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -38,6 +40,7 @@ function normalizeEntries(rawEntries) {
   let startedAt = null, lastMessageAt = null;
 
   for (const entry of rawEntries) {
+    if (!entry) continue;
     const msg = entry.message || entry;
     if (!msg || !msg.role) continue;
     if (!['user', 'assistant', 'system'].includes(msg.role)) continue;
@@ -79,43 +82,63 @@ function normalizeEntries(rawEntries) {
   };
 }
 
-function formatDate(value) {
-  if (!value) return 'unknown';
-  const parsed = new Date(value);
-  return isNaN(parsed.getTime()) ? 'unknown' : parsed.toISOString().slice(0, 10);
-}
-
-function formatRecallResults(results) {
-  if (results.length === 0) return 'No matching sessions found.';
-
-  return results.map((r, i) => {
-    const ss = r.structuredSummary || {};
-    const title = ss.title || r.summaryText?.slice(0, 60) || '(untitled)';
-    const date = formatDate(r.startedAt);
-
-    const lines = [`### ${i + 1}. ${title} (${date}, ${r.agentId || 'default'})`];
-    if (ss.overview || r.summaryText) {
-      lines.push((ss.overview || r.summaryText).slice(0, 300));
-    }
-    if (r.matchedTurnText) {
-      lines.push(`Matched: ${r.matchedTurnText.slice(0, 200)}`);
-    }
-    return lines.join('\n');
-  }).join('\n\n');
-}
+// Thin adapter over the shared formatter. OpenClaw's tool output historically
+// used "Matched:" instead of "Matched turn:" and joined with blank lines, so
+// we supply a pair of renderer overrides to preserve that shape.
+const formatRecallResults = (function () {
+  const { createRecallFormatter } = require('./shared/recall-format');
+  const _fmt = createRecallFormatter({
+    header: () => null,
+    matched: (r) => r.matchedTurnText ? `Matched: ${String(r.matchedTurnText).slice(0, 200)}` : null,
+    separator: () => '',
+  });
+  return (results) => {
+    if (!results || results.length === 0) return 'No matching sessions found.';
+    return _fmt(results);
+  };
+})();
+// Re-export the shared formatter too for callers that want the default shape.
+formatRecallResults.shared = sharedFormatRecallResults;
 
 // ---------------------------------------------------------------------------
 // Plugin
 // ---------------------------------------------------------------------------
 
-module.exports = {
-  id: 'aquifer-memory',
-  name: 'Aquifer Memory',
+function buildPlugin() {
+  return {
+    id: 'aquifer-memory',
+    name: 'Aquifer Memory',
+    register,
+  };
+}
+
+module.exports = buildPlugin();
+// Expose helpers for unit testing. Not part of the plugin's OpenClaw-visible
+// contract; OpenClaw reads { id, name, register } only.
+module.exports.normalizeEntries = normalizeEntries;
+module.exports.coerceRawEntries = coerceRawEntries;
 
-  register(api) {
+function register(api) {
     const pluginConfig = api.pluginConfig || {};
-    let aquifer;
 
+    // v1.2.0: delegate to a persona layer if one is configured, otherwise
+    // run the generic default path (before_reset + session_recall + feedback).
+    const personaPath = pluginConfig.persona || process.env.AQUIFER_PERSONA;
+    if (personaPath) {
+      try {
+        const persona = require(personaPath);
+        if (persona && typeof persona.mountOnOpenClaw === 'function') {
+          persona.mountOnOpenClaw(api, pluginConfig);
+          api.logger.info(`[aquifer-memory] registered via persona: ${personaPath}`);
+          return;
+        }
+        api.logger.warn(`[aquifer-memory] persona at ${personaPath} lacks mountOnOpenClaw; falling back to default`);
+      } catch (err) {
+        api.logger.warn(`[aquifer-memory] failed to load persona ${personaPath}: ${err.message}; falling back to default`);
+      }
+    }
+
+    let aquifer;
     try {
       aquifer = createAquiferFromConfig(pluginConfig);
     } catch (err) {
@@ -138,65 +161,35 @@ module.exports = {
       if ((sessionKey || '').includes('subagent')) return;
       if ((sessionKey || '').includes(':cron:')) return;
 
-      const dedupKey = `${agentId}:${sessionId}`;
-      if (recentlyProcessed.has(dedupKey) || inFlight.has(dedupKey)) return;
-
       const rawEntries = coerceRawEntries(event?.messages || []);
       if (rawEntries.length < 3) {
         api.logger.info(`[aquifer-memory] skip: ${sessionId} only ${rawEntries.length} msgs`);
         return;
       }
 
-      inFlight.add(dedupKey);
       api.logger.info(`[aquifer-memory] capturing ${sessionId} (${rawEntries.length} entries)`);
 
       (async () => {
         try {
+          // OpenClaw hands us flat {role, content} entries; normalizeEntries
+          // produces the commit-ready shape, which we feed to shared runIngest
+          // as 'preNormalized' so commit+enrich+dedup stays host-agnostic.
           const norm = normalizeEntries(rawEntries);
-          if (norm.userCount === 0) {
-            api.logger.info(`[aquifer-memory] skip: no user messages in ${sessionId}`);
-            return;
-          }
-
-          // Commit
-          await aquifer.commit(sessionId, norm.messages, {
+          await runIngest({
+            aquifer,
+            sessionId,
             agentId,
             source: 'openclaw',
             sessionKey,
-            model: norm.model,
-            tokensIn: norm.tokensIn,
-            tokensOut: norm.tokensOut,
-            startedAt: norm.startedAt,
-            lastMessageAt: norm.lastMessageAt,
+            adapter: 'preNormalized',
+            preNormalized: norm,
+            minUserMessages,
+            dedupMap: recentlyProcessed,
+            inFlight,
+            logger: api.logger,
           });
-          api.logger.info(`[aquifer-memory] committed ${sessionId}`);
-
-          // Enrich (if enough messages)
-          if (norm.userCount >= minUserMessages) {
-            try {
-              const result = await aquifer.enrich(sessionId, { agentId });
-              api.logger.info(`[aquifer-memory] enriched ${sessionId} (${result.turnsEmbedded} turns, ${result.entitiesFound} entities)`);
-            } catch (enrichErr) {
-              api.logger.warn(`[aquifer-memory] enrich failed for ${sessionId}: ${enrichErr.message}`);
-            }
-          } else {
-            try {
-              await aquifer.skip(sessionId, { agentId, reason: `user_count=${norm.userCount} < min=${minUserMessages}` });
-            } catch (e) { api.logger.warn(`[aquifer-memory] skip failed for ${sessionId}: ${e.message}`); }
-          }
-
-          recentlyProcessed.set(dedupKey, Date.now());
         } catch (err) {
           api.logger.warn(`[aquifer-memory] capture failed for ${sessionId}: ${err.message}`);
-        } finally {
-          inFlight.delete(dedupKey);
-          // Evict old entries
-          if (recentlyProcessed.size > 200) {
-            const cutoff = Date.now() - 30 * 60 * 1000;
-            for (const [k, ts] of recentlyProcessed) {
-              if (ts < cutoff) recentlyProcessed.delete(k);
-            }
-          }
         }
       })();
     });
@@ -292,6 +285,5 @@ module.exports = {
       };
     }, { name: 'session_feedback' });
 
-    api.logger.info('[aquifer-memory] registered (before_reset + session_recall + session_feedback)');
-  },
-};
+  api.logger.info('[aquifer-memory] registered (before_reset + session_recall + session_feedback)');
+}

package/consumers/opencode.js

@@ -26,8 +26,7 @@
 
 const path = require('path');
 const os = require('os');
-const { createAquiferFromConfig } = require('./shared/factory');
-
+const { runIngest } = require('./shared/ingest');
 // ---------------------------------------------------------------------------
 // SQLite access — use Node 22+ built-in or fall back to better-sqlite3
 // ---------------------------------------------------------------------------
@@ -37,7 +36,7 @@ function openSqlite(dbPath) {
   try {
     const { DatabaseSync } = require('node:sqlite');
     return new DatabaseSync(dbPath, { open: true, readOnly: true });
-  } catch (_) {
+  } catch {
     // not available
   }
 
@@ -45,7 +44,7 @@ function openSqlite(dbPath) {
   try {
     const Database = require('better-sqlite3');
     return new Database(dbPath, { readonly: true });
-  } catch (_) {
+  } catch {
     // not available
   }
 
@@ -220,7 +219,7 @@ async function ingestOpenCode(aquifer, args) {
   try {
     const existing = await aquifer.exportSessions({ source: 'opencode', limit: 10000 });
     for (const row of existing) existingSet.add(row.session_id);
-  } catch (_) {
+  } catch {
     // exportSessions may not exist in all versions
   }
 
@@ -271,36 +270,34 @@ async function ingestOpenCode(aquifer, args) {
       continue;
     }
 
-    // Commit to Aquifer
+    // Commit + optional enrich via shared ingest pipeline
     try {
-      await aquifer.commit(sid, norm.messages, {
+      const ingestResult = await runIngest({
+        aquifer,
+        sessionId: sid,
         agentId,
         source: 'opencode',
-        model: norm.model,
-        tokensIn: norm.tokensIn,
-        tokensOut: norm.tokensOut,
-        startedAt: norm.startedAt,
-        lastMessageAt: norm.lastMessageAt,
+        adapter: 'preNormalized',
+        preNormalized: norm,
+        enrich: doEnrich,
+        minUserMessages,
+        logger: { info() {}, warn(m) { info.enrichError = m; } },
       });
+
       committed++;
       info.status = 'committed';
-
-      // Enrich if requested
-      if (doEnrich) {
-        try {
-          const enrichResult = await aquifer.enrich(sid, { agentId });
-          info.status = 'enriched';
-          info.turnsEmbedded = enrichResult.turnsEmbedded;
-          info.entitiesFound = enrichResult.entitiesFound;
-        } catch (enrichErr) {
-          info.enrichError = enrichErr.message;
-        }
+      if (ingestResult.enrichResult) {
+        info.status = 'enriched';
+        info.turnsEmbedded = ingestResult.enrichResult.turnsEmbedded;
+        info.entitiesFound = ingestResult.enrichResult.entitiesFound;
       }
 
       if (jsonOutput) {
         results.push(info);
       } else {
-        const enrichNote = info.turnsEmbedded != null ? ` (${info.turnsEmbedded} turns, ${info.entitiesFound} entities)` : '';
+        const enrichNote = info.turnsEmbedded !== null && info.turnsEmbedded !== undefined
+          ? ` (${info.turnsEmbedded} turns, ${info.entitiesFound} entities)`
+          : '';
         console.log(`  [${committed}] ${sid} "${session.title}"${enrichNote}`);
       }
     } catch (err) {