@shadowforge0/aquifer-memory 1.5.12 → 1.7.0

package/consumers/miranda/index.js

@@ -1,364 +0,0 @@
-'use strict';
-
-// ---------------------------------------------------------------------------
-// Miranda persona layer.
-//
-// This is a PERSONA, not a host adapter. It wraps a host (OpenClaw gateway,
-// Claude Code afterburn) with Miranda's six-section prompt, zh-TW daily log,
-// workspace file artifacts, and consolidation lifecycle — but leaves the
-// actual hook plumbing (before_reset, before_prompt_build, MCP tool registry)
-// to the host.
-//
-// Entry points:
-//   mountOnOpenClaw(api, opts)     — gateway plugin wiring
-//   mountOnClaudeCode(cc, opts)    — CC afterburn wiring (see consumers/claude-code.js)
-//   buildPostProcess(opts)         — low-level: returns the enrich postProcess
-//                                    fn; host calls it directly if neither
-//                                    mount helper fits.
-// ---------------------------------------------------------------------------
-
-const { runIngest } = require('../shared/ingest');
-const { parseEntitySection } = require('../shared/entity-parser');
-
-const instance = require('./instance');
-const { callLlm, resolveModel, loadConfig } = require('./llm');
-const summary = require('./prompts/summary');
-const dailyEntries = require('./daily-entries');
-const workspaceFiles = require('./workspace-files');
-const contextInject = require('./context-inject');
-const mirandaRecallFormat = require('./recall-format');
-
-// ---------------------------------------------------------------------------
-// summaryFn / entityParseFn factories — shared by gateway + CC
-// ---------------------------------------------------------------------------
-
-function buildSummaryFn({ agentId, now, dailyContext, runtime = 'gateway', logger = console }) {
-    return async function summaryFn(_normalized) {
-        // _normalized is the cleaned messages from Aquifer; Miranda wants the
-        // reconstructed conversation text for the six-section prompt.
-        const conversationText = extractConversationText(_normalized);
-        if (!conversationText) throw new Error('empty conversation text');
-
-        const prompt = summary.buildSummaryPrompt({ conversationText, agentId, now, dailyContext });
-        if (logger.info) logger.info(`[miranda] calling LLM (${runtime})`);
-        const output = await callLlm(prompt, { runtime });
-        if (!output) throw new Error('LLM returned empty');
-
-        const sections = summary.parseSummaryOutput(output);
-        const recap = summary.parseRecapLines(sections.recap || '');
-        const workingFacts = summary.parseWorkingFacts(sections.working_facts || '');
-        if (!recap.title) throw new Error('LLM recap missing title');
-
-        return {
-            summaryText: recap.overview || '',
-            structuredSummary: { ...recap, raw_sections: sections },
-            entityRaw: sections.entities || null,
-            extra: { sections, recap, workingFacts },
-        };
-    };
-}
-
-function buildEntityParseFn() {
-    return function entityParseFn(text) {
-        const parsed = parseEntitySection(text);
-        return parsed.entities;  // already has { name, normalizedName, aliases, type }
-    };
-}
-
-function extractConversationText(normalized) {
-    if (!Array.isArray(normalized)) return '';
-    return normalized
-        .filter(m => m.role === 'user' || m.role === 'assistant')
-        .map(m => `[${m.role}] ${typeof m.content === 'string' ? m.content : ''}`)
-        .join('\n');
-}
-
-// ---------------------------------------------------------------------------
-// buildPostProcess — produce the enrich postProcess hook for Miranda
-// ---------------------------------------------------------------------------
-
-/**
- * @param {object} opts
- * @param {object} opts.aquifer — Aquifer instance
- * @param {object} opts.pool    — pg.Pool (used for daily-entries DAL)
- * @param {string} opts.agentId
- * @param {string} [opts.workspaceDir] — if set, writes emotional-state.md and recap JSON files
- * @param {string} [opts.source='afterburn']
- * @param {string|null} [opts.tag=null] — daily-entry tag (e.g. '[CLI]' for CC runs)
- * @param {Date}  [opts.now]
- * @param {object} [opts.logger]
- * @param {boolean} [opts.consolidate=true]
- */
-function buildPostProcess({
-    aquifer, pool, agentId, workspaceDir = null,
-    source = 'afterburn', tag = null, now = null,
-    logger = console, consolidate = true,
-} = {}) {
-    if (!aquifer) throw new Error('buildPostProcess: aquifer is required');
-    if (!pool) throw new Error('buildPostProcess: pool is required');
-    if (!agentId) throw new Error('buildPostProcess: agentId is required');
-
-    return async function postProcess(ctx) {
-        const _now = now || new Date();
-        const recap = ctx.extra?.recap || null;
-        const sections = ctx.extra?.sections || null;
-        const workingFacts = ctx.extra?.workingFacts || [];
-        const sessionId = ctx.session.sessionId;
-
-        // 1. Workspace files (optional — only if persona has a workspace dir)
-        if (workspaceDir && (sections || recap)) {
-            try {
-                await workspaceFiles.writeWorkspaceFiles(sections || {}, recap, workspaceDir, {
-                    sessionId,
-                    agentId,
-                    conversationText: extractConversationText(ctx.normalized || []),
-                }, logger);
-            } catch (err) {
-                if (logger.warn) logger.warn(`[miranda] workspace files failed: ${err.message}`);
-            }
-        }
-
-        // 2. Daily entries
-        if (sections || recap) {
-            try {
-                await dailyEntries.writeDailyEntries({
-                    sections: sections || {}, recap, pool, sessionId, agentId, logger,
-                    source, tag, now: _now,
-                });
-            } catch (err) {
-                if (logger.warn) logger.warn(`[miranda] daily entries failed: ${err.message}`);
-            }
-        }
-
-        // 3. Fact candidates — write to aquifer.${schema}.facts via consolidate 'create'
-        //    (We only CREATE here; candidate-lifecycle decisions come from the
-        //    consolidation step below.)
-        if (consolidate && workingFacts.length > 0) {
-            try {
-                const { normalizeEntityName } = require('../../index');
-                const actions = workingFacts.map(f => ({
-                    action: 'create',
-                    subject: f.subject,
-                    statement: f.statement,
-                    importance: 6,
-                }));
-                await aquifer.consolidate(sessionId, {
-                    agentId,
-                    actions,
-                    normalizeSubject: normalizeEntityName,
-                    recapOverview: recap?.overview || '',
-                });
-            } catch (err) {
-                if (logger.warn) logger.warn(`[miranda] fact candidates failed: ${err.message}`);
-            }
-        }
-    };
-}
-
-// ---------------------------------------------------------------------------
-// Mount helpers — afterburn / context-inject / session_recall tool.
-// Each is independently mountable so different OpenClaw extensions can claim
-// the hooks they care about. mountOnOpenClaw() is the all-in-one convenience.
-// ---------------------------------------------------------------------------
-
-function resolveCommon(opts) {
-    if (!opts.pool) throw new Error('Miranda: pool is required');
-    if (!opts.embedFn) throw new Error('Miranda: embedFn is required');
-    return {
-        pool: opts.pool,
-        embedFn: opts.embedFn,
-        defaultAgentId: opts.agentId || 'main',
-        workspaceDir: opts.workspaceDir || null,
-        minUserMessages: opts.minUserMessages || 3,
-        aquifer: instance.getAquifer({
-            pool: opts.pool, embedFn: opts.embedFn, llmFn: opts.llmFn, rerankKey: opts.rerankKey,
-        }),
-    };
-}
-
-/**
- * Register Miranda's afterburn hook (before_reset) on the OpenClaw api.
- * Runs commit + enrich with Miranda's summaryFn and postProcess.
- */
-function registerAfterburn(api, opts = {}) {
-    const { pool, aquifer, defaultAgentId, workspaceDir, minUserMessages } = resolveCommon(opts);
-    const recentlyProcessed = new Map();
-    const inFlight = new Set();
-
-    api.on('before_reset', (event, ctx) => {
-        const sessionId = ctx?.sessionId || event?.sessionId;
-        const agentId = ctx?.agentId || defaultAgentId;
-        const sessionKey = ctx?.sessionKey || null;
-
-        if (!sessionId) return;
-        if ((sessionKey || '').includes('subagent')) return;
-        if ((sessionKey || '').includes(':cron:')) return;
-
-        const rawEntries = Array.isArray(event?.messages) ? event.messages : [];
-        if (rawEntries.length < 3) {
-            api.logger.info(`[miranda] skip ${sessionId}: only ${rawEntries.length} msgs`);
-            return;
-        }
-
-        (async () => {
-            try {
-                const now = new Date();
-                const date = dailyEntries.taipeiDateString(now);
-                let dailyContext = '';
-                try { dailyContext = await dailyEntries.fetchDailyContext(pool, date, agentId); } catch { /* best-effort */ }
-
-                await runIngest({
-                    aquifer,
-                    sessionId,
-                    agentId,
-                    source: 'openclaw',
-                    sessionKey,
-                    adapter: 'gateway',
-                    rawEntries,
-                    minUserMessages,
-                    dedupMap: recentlyProcessed,
-                    inFlight,
-                    summaryFn: buildSummaryFn({ agentId, now, dailyContext, runtime: 'gateway', logger: api.logger }),
-                    entityParseFn: buildEntityParseFn(),
-                    postProcess: buildPostProcess({
-                        aquifer, pool, agentId, workspaceDir,
-                        source: 'afterburn', now, logger: api.logger,
-                    }),
-                    logger: api.logger,
-                });
-            } catch (err) {
-                api.logger.warn(`[miranda] capture failed ${sessionId}: ${err.message}`);
-            }
-        })();
-    });
-
-    api.logger.info('[miranda] registerAfterburn: before_reset hooked');
-    return { aquifer };
-}
-
-/**
- * Register the before_prompt_build Miranda context injection.
- * Separate from afterburn so the Driftwood ext can install it while the
- * afterburn ext owns the before_reset hook.
- */
-function registerContextInject(api, opts = {}) {
-    const { pool, aquifer, defaultAgentId } = resolveCommon(opts);
-
-    api.on('before_prompt_build', async (event, ctx) => {
-        try {
-            const agentId = ctx?.agentId || defaultAgentId;
-            if ((ctx?.sessionKey || '').includes('subagent')) return;
-
-            const context = await contextInject.computeInjection({
-                aquifer, pool, agentId, includeBootstrap: true,
-            });
-            if (context && context.split('\n').length > 3) {
-                api.logger.info(`[miranda] injecting context: ${context.length} chars, agent=${agentId}`);
-                return { prependSystemContext: context };
-            }
-        } catch (err) {
-            api.logger.warn(`[miranda] context injection failed: ${err.message}`);
-        }
-    });
-
-    api.logger.info('[miranda] registerContextInject: before_prompt_build hooked');
-    return { aquifer };
-}
-
-/**
- * Register the zh-TW session_recall tool.
- */
-function registerRecallTool(api, opts = {}) {
-    const { aquifer } = resolveCommon(opts);
-
-    api.registerTool((ctx) => {
-        if ((ctx?.sessionKey || '').includes('subagent')) return null;
-        return {
-            name: 'session_recall',
-            description: '搜尋歷史 session 的摘要和對話記錄。當問題明確提到具體人名、專案、工具、檔名時，傳 entities；只想保留全部命中的 session 用 entity_mode="all"，否則 "any" 是 boost。mode 可選 "fts"/"vector"/"hybrid"，default hybrid。',
-            parameters: {
-                type: 'object',
-                properties: {
-                    query: { type: 'string', description: '搜尋關鍵字或自然語言描述（必填非空）', minLength: 1 },
-                    date_from: { type: 'string' }, date_to: { type: 'string' },
-                    agent_id: { type: 'string' }, source: { type: 'string' },
-                    entities: { type: 'array', items: { type: 'string' }, description: '具名 entity 清單（人/專案/工具/檔名）' },
-                    entity_mode: { type: 'string', enum: ['any', 'all'], description: '"any" boost / "all" 硬過濾必含全部 entity' },
-                    mode: { type: 'string', enum: ['fts', 'hybrid', 'vector'], description: 'recall 模式，default hybrid' },
-                    detail: { type: 'string' },
-                    limit: { type: 'number' },
-                },
-            },
-            async execute(_toolCallId, params) {
-                try {
-                    const limit = Math.max(1, Math.min(20, parseInt(params?.limit ?? 5, 10) || 5));
-                    const recallOpts = {
-                        agentId: params?.agent_id || ctx?.agentId || undefined,
-                        source: params?.source || undefined,
-                        dateFrom: params?.date_from || undefined,
-                        dateTo: params?.date_to || undefined,
-                        limit,
-                    };
-                    if (Array.isArray(params?.entities) && params.entities.length > 0) {
-                        recallOpts.entities = params.entities;
-                        recallOpts.entityMode = params?.entity_mode || 'any';
-                    }
-                    if (params?.mode === 'fts' || params?.mode === 'hybrid' || params?.mode === 'vector') {
-                        recallOpts.mode = params.mode;
-                    }
-                    const results = await aquifer.recall(String(params?.query || ''), recallOpts);
-                    const text = mirandaRecallFormat.formatRecallResults(results.map(r => ({
-                        sessionId: r.sessionId, agentId: r.agentId, source: r.source,
-                        startedAt: r.startedAt, summaryText: r.summaryText,
-                        structuredSummary: r.structuredSummary,
-                        matchedTurnText: r.matchedTurnText,
-                    })));
-                    return { content: [{ type: 'text', text }] };
-                } catch (err) {
-                    return { content: [{ type: 'text', text: `session_recall 錯誤：${err.message}` }], isError: true };
-                }
-            },
-        };
-    }, { name: 'session_recall' });
-
-    api.logger.info('[miranda] registerRecallTool: session_recall tool registered');
-    return { aquifer };
-}
-
-/**
- * Convenience: register all three on the same api. Equivalent to calling
- * registerAfterburn + registerContextInject + registerRecallTool.
- */
-function mountOnOpenClaw(api, opts = {}) {
-    const r1 = registerAfterburn(api, opts);
-    registerContextInject(api, opts);
-    registerRecallTool(api, opts);
-    return r1;
-}
-
-// ---------------------------------------------------------------------------
-// Exports
-// ---------------------------------------------------------------------------
-
-module.exports = {
-    // Persona entry points
-    mountOnOpenClaw,
-    registerAfterburn,
-    registerContextInject,
-    registerRecallTool,
-    buildPostProcess,
-    buildSummaryFn,
-    buildEntityParseFn,
-
-    // Individual modules for advanced wiring
-    instance,
-    llm: { callLlm, resolveModel, loadConfig },
-    summary,
-    dailyEntries,
-    workspaceFiles,
-    contextInject,
-    recallFormat: mirandaRecallFormat,
-
-    // Helpers re-exported for convenience
-    extractConversationText,
-};

package/consumers/miranda/instance.js

@@ -1,55 +0,0 @@
-'use strict';
-
-// Miranda Aquifer instance factory — produces a singleton bound to the
-// miranda schema + entity scope + rerank config. Host supplies the pg.Pool
-// and embed function (they're host-specific wiring: OpenClaw has its own
-// pg + embed libs; CC uses the same).
-
-const { createAquifer } = require('../../index');
-const { callLlm } = require('./llm');
-
-let _instance = null;
-
-/**
- * @param {object} opts
- * @param {object} opts.pool — pg.Pool from the host
- * @param {function} opts.embedFn — async (texts: string[]) => number[][]
- * @param {function} [opts.llmFn] — defaults to Miranda's MiniMax wrapper
- * @param {string} [opts.rerankKey] — OpenRouter API key; falls back to
- *   process.env.OPENROUTER_API_KEY / AQUIFER_RERANK_API_KEY
- * @returns {object} Aquifer instance
- */
-function getAquifer(opts = {}) {
-    if (_instance) return _instance;
-    if (!opts.pool) throw new Error('Miranda: pool is required');
-    if (!opts.embedFn) throw new Error('Miranda: embedFn is required');
-
-    const rerankKey = opts.rerankKey
-        || process.env.OPENROUTER_API_KEY
-        || process.env.AQUIFER_RERANK_API_KEY;
-
-    _instance = createAquifer({
-        schema: 'miranda',
-        db: opts.pool,
-        tenantId: 'default',
-        embed: { fn: opts.embedFn },
-        llm: { fn: opts.llmFn || callLlm },
-        entities: { enabled: true, mergeCall: true, scope: 'miranda' },
-        facts: { enabled: true },
-        rerank: rerankKey ? {
-            provider: 'openrouter',
-            openrouterApiKey: rerankKey,
-            model: 'cohere/rerank-v3.5',
-            topK: 20,
-            maxChars: 1600,
-            timeout: 5000,
-            maxRetries: 1,
-        } : null,
-    });
-
-    return _instance;
-}
-
-function resetAquifer() { _instance = null; }
-
-module.exports = { getAquifer, resetAquifer };

package/consumers/miranda/llm.js

@@ -1,99 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Default host home. Callers can override via opts.envPath / opts.configDir.
-const DEFAULT_HOME = process.env.OPENCLAW_HOME || path.join(os.homedir(), '.openclaw');
-
-function loadEnvFile(envPath) {
-    if (!envPath) envPath = path.join(DEFAULT_HOME, '.env');
-    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 { /* no .env */ }
-}
-
-function loadConfig(pluginConfig = {}, opts = {}) {
-    const home = opts.home || DEFAULT_HOME;
-    loadEnvFile(opts.envPath || path.join(home, '.env'));
-
-    let defaults = {};
-    const configPath = opts.configPath || path.join(home, 'extensions/afterburn/config.default.json');
-    try {
-        let raw = fs.readFileSync(configPath, 'utf8');
-        raw = raw.replace(/\$\{(\w+)\}/g, (_, key) => process.env[key] || '');
-        defaults = JSON.parse(raw);
-    } catch { /* use empty */ }
-
-    return { ...defaults['afterburn'], ...pluginConfig };
-}
-
-// Model defaults per runtime — Miranda's choices on MiniMax
-const RUNTIME_DEFAULTS = {
-    gateway: 'MiniMax-M2.7',
-    cc: 'MiniMax-M2.5',
-    opencode: 'MiniMax-M2.5',
-};
-
-const RUNTIME_ENV_KEY = {
-    cc: 'CC_AFTERBURN_MODEL',
-    opencode: 'OPENCODE_AFTERBURN_MODEL',
-};
-
-function resolveModel({ runtime, explicitModel, configModel } = {}) {
-    if (explicitModel) return explicitModel;
-    const envKey = RUNTIME_ENV_KEY[runtime] || 'AFTERBURN_LLM_MODEL';
-    if (process.env[envKey]) return process.env[envKey];
-    if (configModel) return configModel;
-    return RUNTIME_DEFAULTS[runtime] || RUNTIME_DEFAULTS.gateway;
-}
-
-async function callLlm(prompt, { runtime, model, timeoutMs } = {}) {
-    const resolvedModel = model || resolveModel({ runtime });
-    const timeout = timeoutMs || 120000;
-    const apiKey = process.env.MINIMAX_API_KEY || process.env.OPENCODE_API_KEY || '';
-    if (!apiKey) throw new Error('MINIMAX_API_KEY not set');
-
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeout);
-    try {
-        const res = await fetch('https://api.minimax.io/anthropic/v1/messages', {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${apiKey}`,
-                'anthropic-version': '2023-06-01',
-            },
-            body: JSON.stringify({
-                model: resolvedModel,
-                messages: [{ role: 'user', content: prompt }],
-                max_tokens: 4096,
-            }),
-            signal: controller.signal,
-        });
-
-        if (!res.ok) {
-            const body = await res.text().catch(() => '');
-            throw new Error(`LLM ${res.status}: ${body.slice(0, 200)}`);
-        }
-
-        const data = await res.json();
-        let raw;
-        if (data.content && Array.isArray(data.content)) {
-            raw = data.content.map(c => c.text || '').join('');
-        } else {
-            raw = data.choices?.[0]?.message?.content || '';
-        }
-        // Strip <think>...</think> reasoning tags (MiniMax M2.5)
-        return raw.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
-    } finally {
-        clearTimeout(timer);
-    }
-}
-
-module.exports = { loadEnvFile, loadConfig, resolveModel, callLlm };

package/consumers/miranda/profile.json

@@ -1,145 +0,0 @@
-{
-  "$schema": "https://aquifer.dev/schema/consumer-profile.v1.json",
-  "consumer_profile_id": "miranda",
-  "version": 1,
-  "description": "Miranda persona consumer profile — canonical shape for session state, handoff, decision log, timeline categories, and default artifact producers. Reference implementation shipped inside Aquifer; production deployments may register additional versions with schema changes.",
-  "defaults": {
-    "tenant_id": "default",
-    "agent_id": "main",
-    "time_zone": "Asia/Taipei"
-  },
-  "schemas": {
-    "default.session_state.v1": {
-      "kind": "default",
-      "target": "sessionState",
-      "description": "What Miranda is currently focused on — goal + active threads + affect tag.",
-      "json_schema": {
-        "type": "object",
-        "additionalProperties": true,
-        "properties": {
-          "goal": { "type": ["string", "null"] },
-          "active_work": { "type": "array", "items": { "type": "string" } },
-          "blockers": { "type": "array", "items": { "type": "string" } },
-          "affect": {
-            "type": "object",
-            "additionalProperties": true,
-            "properties": {
-              "mood": { "type": ["string", "null"] },
-              "energy": { "enum": ["low", "medium", "high", null] },
-              "confidence": { "enum": ["low", "medium", "high", null] },
-              "notes": { "type": ["string", "null"] }
-            }
-          }
-        },
-        "required": ["goal", "active_work", "blockers", "affect"]
-      }
-    },
-    "default.session_handoff.v1": {
-      "kind": "default",
-      "target": "sessionHandoff",
-      "description": "Session-end baton: what was the last step, where to pick up, what still blocks.",
-      "json_schema": {
-        "type": "object",
-        "additionalProperties": true,
-        "properties": {
-          "last_step": { "type": "string" },
-          "status": { "enum": ["in_progress", "completed", "blocked"] },
-          "next": { "type": ["string", "null"] },
-          "blockers": { "type": "array", "items": { "type": "string" } },
-          "decided": { "type": "array", "items": { "type": "string" } },
-          "open_loops": { "type": "array", "items": { "type": "string" } }
-        },
-        "required": ["last_step", "status", "next", "blockers", "decided", "open_loops"]
-      }
-    },
-    "default.decision_log.v1": {
-      "kind": "default",
-      "target": "decisionLog",
-      "description": "Committed / proposed / reversed decisions with optional fact linkage.",
-      "json_schema": {
-        "type": "object",
-        "additionalProperties": true,
-        "properties": {
-          "decision": { "type": "string" },
-          "reason": { "type": ["string", "null"] },
-          "status": { "enum": ["proposed", "committed", "reversed"] },
-          "related_fact_ids": {
-            "type": "array",
-            "items": { "type": "integer" }
-          }
-        },
-        "required": ["decision", "reason", "status"]
-      }
-    },
-    "default.timeline.v1": {
-      "kind": "default",
-      "target": "timeline",
-      "description": "Miranda daily timeline category vocabulary. Categories map to existing daily-log sections (focus/todo/mood/handoff) plus organisational tags Miranda uses in weekly/monthly rollups.",
-      "category_vocabulary": [
-        "cli",
-        "focus",
-        "todo",
-        "handoff",
-        "narrative",
-        "organized",
-        "weekly",
-        "monthly",
-        "stats",
-        "health",
-        "garmin",
-        "note"
-      ],
-      "json_schema": {
-        "type": "object",
-        "additionalProperties": false,
-        "properties": {
-          "occurred_at": { "type": "string", "format": "date-time" },
-          "source": { "type": "string" },
-          "session_ref": { "type": ["string", "null"] },
-          "category": { "type": "string" },
-          "text": { "type": "string" },
-          "metadata": { "type": "object" }
-        },
-        "required": ["occurred_at", "source", "session_ref", "category", "text", "metadata"]
-      }
-    }
-  },
-  "artifacts": {
-    "producers": [
-      {
-        "producer_id": "miranda.workspace.daily-log",
-        "type": "daily-log",
-        "trigger_phase": "timeline_write",
-        "format": "markdown",
-        "destination": "workspace://memory/{date}.md",
-        "description": "Renders the day's timeline events + state snapshot + handoff to a single markdown file under the Miranda workspace. Source of truth remains the DB; the .md is a rendered view."
-      },
-      {
-        "producer_id": "miranda.workspace.weekly-log",
-        "type": "weekly-log",
-        "trigger_phase": "artifact_dispatch",
-        "format": "markdown",
-        "destination": "workspace://memory/weekly/{week_start}.md",
-        "description": "Weekly rollup. Timeline events tagged [WEEKLY] plus cross-session narratives. Rendered from DB via rollupWeekly() helper."
-      },
-      {
-        "producer_id": "miranda.workspace.monthly-log",
-        "type": "monthly-log",
-        "trigger_phase": "artifact_dispatch",
-        "format": "markdown",
-        "destination": "workspace://memory/monthly/{month}.md",
-        "description": "Monthly rollup. Aggregates weekly entries + narrative supersede chain."
-      }
-    ]
-  },
-  "extraction_hints": {
-    "entities": {
-      "include_types": ["person", "project", "tool", "topic"],
-      "exclude_patterns": ["^/tmp/", "^/home/mingko/\\.", "^node_modules/"]
-    },
-    "facts": {
-      "prefer_subjects": ["MK", "Miranda", "Aquifer", "OpenClaw", "Jenny", "Evan", "Ivan"],
-      "avoid_ephemeral": true
-    }
-  }
-}