@shadowforge0/aquifer-memory 1.5.9 → 1.6.0

package/scripts/codex-recovery.js

@@ -0,0 +1,532 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { createAquiferFromConfig } = require('../consumers/shared/factory');
+const codex = require('../consumers/codex');
+const DB_ENV_KEYS = new Set(['DATABASE_URL', 'AQUIFER_DB_URL', 'AQUIFER_SCHEMA', 'AQUIFER_TENANT_ID']);
+
+const VALUE_FLAGS = new Set([
+  'agent-id',
+  'codex-home',
+  'config',
+  'except-session-id',
+  'file-path',
+  'finalizer-model',
+  'idle-ms',
+  'max-candidates',
+  'max-recovery-bytes',
+  'max-recovery-chars',
+  'max-recovery-messages',
+  'max-recovery-prompt-tokens',
+  'min-session-bytes',
+  'mode',
+  'reason',
+  'scope-kind',
+  'scope-key',
+  'session-id',
+  'session-key',
+  'sessions-dir',
+  'source',
+  'state-dir',
+  'structured-summary-json',
+  'summary-json',
+  'summary-text',
+  'verdict',
+]);
+
+function parseArgs(argv) {
+  const args = { _: [], flags: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const current = argv[i];
+    if (current === '--') {
+      args._.push(...argv.slice(i + 1));
+      break;
+    }
+    if (current.startsWith('--')) {
+      const key = current.slice(2);
+      if (VALUE_FLAGS.has(key) && i + 1 < argv.length && !argv[i + 1].startsWith('--')) {
+        args.flags[key] = argv[++i];
+      } else {
+        args.flags[key] = true;
+      }
+      continue;
+    }
+    args._.push(current);
+  }
+  return args;
+}
+
+function parseIntFlag(value, fallback) {
+  if (value === undefined || value === null || value === true || value === '') return fallback;
+  const parsed = parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function envDefault(env, ...keys) {
+  for (const key of keys) {
+    const value = env[key];
+    if (value !== undefined && value !== '') return value;
+  }
+  return null;
+}
+
+function loadEnvFile(filePath, env = process.env, opts = {}) {
+  if (!filePath) return;
+  const overrideKeys = opts.overrideKeys || null;
+  let raw = '';
+  try {
+    raw = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return;
+  }
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const match = /^([A-Z_][A-Z0-9_]*)=(.*)$/.exec(trimmed);
+    if (!match) continue;
+    if (env[match[1]] && !(overrideKeys && overrideKeys.has(match[1]))) continue;
+    let value = match[2].trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    env[match[1]] = value;
+  }
+}
+
+function loadCodexEnv(env = process.env, opts = {}) {
+  const codexHome = env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  const fileOpts = opts.overrideDb ? { overrideKeys: DB_ENV_KEYS } : {};
+  loadEnvFile(env.CODEX_ENV_PATH, env, fileOpts);
+  loadEnvFile(path.join(codexHome, '.env'), env, fileOpts);
+}
+
+function buildRecoveryOptions(flags = {}, env = process.env) {
+  const opts = {
+    agentId: flags['agent-id'] || envDefault(env, 'CODEX_AQUIFER_AGENT_ID', 'AQUIFER_AGENT_ID') || 'main',
+    source: flags.source || envDefault(env, 'CODEX_AQUIFER_SOURCE', 'AQUIFER_SOURCE') || 'codex',
+    sessionKey: flags['session-key'] || envDefault(env, 'CODEX_AQUIFER_SESSION_KEY') || 'codex:cli',
+    codexHome: flags['codex-home'] || envDefault(env, 'CODEX_HOME') || undefined,
+    stateDir: flags['state-dir'] || undefined,
+    sessionsDir: flags['sessions-dir'] || undefined,
+    maxRecoveryCandidates: parseIntFlag(flags['max-candidates'], 1),
+    minSessionBytes: parseIntFlag(flags['min-session-bytes'], undefined),
+    idleMs: parseIntFlag(flags['idle-ms'], undefined),
+    maxRecoveryBytes: parseIntFlag(flags['max-recovery-bytes'], undefined),
+    maxRecoveryMessages: parseIntFlag(flags['max-recovery-messages'], undefined),
+    maxRecoveryChars: parseIntFlag(flags['max-recovery-chars'], undefined),
+    maxRecoveryPromptTokens: parseIntFlag(flags['max-recovery-prompt-tokens'], undefined),
+    includeJsonlPreviews: flags['include-jsonl-previews'] === true,
+    includeDeferredRecovery: flags['include-deferred'] === true,
+    excludeNewest: flags['include-current'] === true ? false : true,
+  };
+  for (const [key, value] of Object.entries(opts)) {
+    if (value === undefined) delete opts[key];
+  }
+  return opts;
+}
+
+function shellQuote(value) {
+  return `'${String(value || '').replace(/'/g, `'\\''`)}'`;
+}
+
+function scriptCommand(subcommand, candidate = {}, opts = {}, extra = []) {
+  const scriptPath = path.resolve(__filename);
+  const parts = [process.execPath, scriptPath, subcommand];
+  if (candidate.sessionId) parts.push('--session-id', candidate.sessionId);
+  if (opts.agentId) parts.push('--agent-id', opts.agentId);
+  if (opts.source) parts.push('--source', opts.source);
+  if (opts.sessionKey) parts.push('--session-key', opts.sessionKey);
+  if (opts.maxRecoveryCandidates) parts.push('--max-candidates', String(opts.maxRecoveryCandidates));
+  parts.push(...extra);
+  return parts.map(shellQuote).join(' ');
+}
+
+function oneLine(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function renderCandidate(candidate = {}) {
+  const id = candidate.sessionId || candidate.fileSessionId || '(unknown)';
+  const counts = [];
+  if (candidate.userCount !== null && candidate.userCount !== undefined) counts.push(`${candidate.userCount} user turns`);
+  if (candidate.messageCount !== null && candidate.messageCount !== undefined) counts.push(`${candidate.messageCount} messages`);
+  if (candidate.approxPromptTokens !== null && candidate.approxPromptTokens !== undefined) counts.push(`~${candidate.approxPromptTokens} prompt tokens`);
+  if (candidate.updatedAt) {
+    const updated = new Date(candidate.updatedAt);
+    if (!Number.isNaN(updated.getTime())) counts.push(`updated ${updated.toISOString()}`);
+  }
+  return counts.length > 0 ? `${id} (${counts.join(', ')})` : id;
+}
+
+function renderFinalizeCommand(candidate = {}, opts = {}, extra = []) {
+  return scriptCommand('finalize', candidate, opts, [
+    ...recoveryArgsForCandidate(candidate),
+    '--summary-stdin',
+    '--mode',
+    'session_start_recovery',
+    ...extra,
+  ]);
+}
+
+function recoveryArgsForCandidate(candidate = {}) {
+  return candidate.origin === 'jsonl_preview' ? ['--include-jsonl-previews'] : [];
+}
+
+function renderHookContext(candidates = [], opts = {}) {
+  if (!candidates.length) return '';
+
+  const sharedArgs = candidates.some(candidate => candidate.origin === 'jsonl_preview')
+    ? ['--include-jsonl-previews']
+    : [];
+  const deferUnselectedCommand = scriptCommand('decision', {}, opts, [
+    ...sharedArgs,
+    '--all',
+    '--except-session-id',
+    'SELECTED_IDS_COMMA_SEPARATED',
+    '--verdict',
+    'deferred',
+    '--reason',
+    'not_selected_at_session_start',
+  ]);
+  const deferAllCommand = scriptCommand('decision', {}, opts, [
+    ...sharedArgs,
+    '--all',
+    '--verdict',
+    'deferred',
+    '--reason',
+    'deferred_by_user_at_session_start',
+  ]);
+  const declineAllCommand = scriptCommand('decision', {}, opts, [
+    ...sharedArgs,
+    '--all',
+    '--verdict',
+    'declined',
+    '--reason',
+    'declined_by_user_at_session_start',
+  ]);
+  const candidateLines = [];
+  candidates.forEach((candidate, index) => {
+    const previewArgs = recoveryArgsForCandidate(candidate);
+    const promptCommand = scriptCommand('prompt', candidate, opts, previewArgs);
+    const finalizeCommand = renderFinalizeCommand(candidate, opts);
+    candidateLines.push(`${index + 1}. ${renderCandidate(candidate)}`);
+    candidateLines.push(`   prompt: ${promptCommand}`);
+    candidateLines.push(`   finalize: ${finalizeCommand}`);
+  });
+
+  return [
+    '[AQUIFER RECOVERY]',
+    `Aquifer found ${candidates.length} Codex JSONL session(s) eligible for DB recovery.`,
+    'This hook scanned local JSONL only to compute eligibility, counts, hashes, and prompt budget. It did not inject transcript text.',
+    'Recover all: process every candidate below one at a time with its prompt command, summarize with the current Codex agent, then write the JSON result with its finalize command.',
+    'Recover selected: process only selected candidates, then mark the rest for manual recovery later with:',
+    deferUnselectedCommand,
+    'Recover none now but keep manual recovery available:',
+    deferAllCommand,
+    'Decline all recovery candidates:',
+    declineAllCommand,
+    'Manual later: rerun preview or prompt with --include-deferred.',
+    '',
+    ...candidateLines,
+  ].join('\n');
+}
+
+function selectCandidate(candidates = [], flags = {}) {
+  const wanted = flags['session-id'] ? String(flags['session-id']) : '';
+  if (!wanted) return candidates[0] || null;
+  return candidates.find((candidate) => {
+    return candidate.sessionId === wanted
+      || candidate.fileSessionId === wanted
+      || candidate.transcriptHash === wanted;
+  }) || null;
+}
+
+function compactCandidate(candidate = {}) {
+  return {
+    sessionId: candidate.sessionId || null,
+    fileSessionId: candidate.fileSessionId || null,
+    origin: candidate.origin || null,
+    source: candidate.source || null,
+    agentId: candidate.agentId || null,
+    sessionKey: candidate.sessionKey || null,
+    userCount: candidate.userCount || null,
+    messageCount: candidate.messageCount || null,
+    safeMessageCount: candidate.safeMessageCount || null,
+    charCount: candidate.charCount || null,
+    approxPromptTokens: candidate.approxPromptTokens || null,
+    transcriptHash: candidate.transcriptHash || null,
+    eligibilityStatus: candidate.eligibilityStatus || null,
+    finalizationStatus: candidate.finalizationStatus || null,
+    recoveryDecisionStatus: candidate.recoveryDecisionStatus || null,
+    updatedAt: candidate.updatedAt || null,
+  };
+}
+
+function parseIdList(value) {
+  if (!value || value === true) return new Set();
+  return new Set(String(value).split(',').map(part => part.trim()).filter(Boolean));
+}
+
+function readSummaryJson(flags = {}) {
+  if (flags['summary-stdin']) {
+    const raw = fs.readFileSync(0, 'utf8').trim();
+    if (!raw) throw new Error('summary JSON stdin is empty');
+    return JSON.parse(raw);
+  }
+  if (flags['summary-json']) {
+    const raw = fs.readFileSync(flags['summary-json'], 'utf8');
+    return JSON.parse(raw);
+  }
+  const summaryText = oneLine(flags['summary-text']);
+  const structuredRaw = flags['structured-summary-json'];
+  const structuredSummary = structuredRaw ? JSON.parse(structuredRaw) : {};
+  if (!summaryText && Object.keys(structuredSummary).length === 0) {
+    throw new Error('finalize requires --summary-stdin, --summary-json, or --summary-text');
+  }
+  return { summaryText, structuredSummary };
+}
+
+function finalizationReviewText(result = {}) {
+  return result.humanReviewText
+    || result.human_review_text
+    || result.finalization?.humanReviewText
+    || result.finalization?.human_review_text
+    || result.finalization?.finalization?.humanReviewText
+    || result.finalization?.finalization?.human_review_text
+    || '';
+}
+
+async function withAquifer(fn) {
+  let aquifer;
+  try {
+    loadCodexEnv(process.env, { overrideDb: true });
+    aquifer = createAquiferFromConfig({});
+    return await fn(aquifer);
+  } finally {
+    if (aquifer && typeof aquifer.close === 'function') {
+      await aquifer.close().catch(() => {});
+    }
+  }
+}
+
+async function listCandidates(aquifer, opts) {
+  return codex.findRecoveryCandidates(aquifer, opts);
+}
+
+async function listDbEligibleCandidates(aquifer, opts) {
+  return codex.findDbEligibleRecoveryCandidates(aquifer, opts);
+}
+
+async function listOperationalCandidates(aquifer, opts) {
+  if (opts && opts.includeJsonlPreviews) {
+    return listDbEligibleCandidates(aquifer, opts);
+  }
+  return listCandidates(aquifer, opts);
+}
+
+async function cmdPreview(aquifer, flags, opts) {
+  const candidates = await listCandidates(aquifer, opts);
+  if (flags.json) {
+    console.log(JSON.stringify({ status: candidates.length ? 'needs_consent' : 'none', candidates: candidates.map(compactCandidate) }, null, 2));
+    return;
+  }
+  if (candidates.length === 0) {
+    console.log('No Codex recovery candidates.');
+    return;
+  }
+  for (const candidate of candidates) console.log(renderCandidate(candidate));
+}
+
+async function cmdHookContext(aquifer, flags, opts) {
+  const maxRecoveryCandidates = Number.isFinite(opts.maxRecoveryCandidates)
+    ? Math.max(1, opts.maxRecoveryCandidates)
+    : 1;
+  const candidates = await listDbEligibleCandidates(aquifer, {
+    ...opts,
+    idleMs: opts.idleMs ?? 0,
+    maxRecoveryCandidates,
+    includeJsonlPreviews: true,
+  });
+  const context = renderHookContext(candidates, opts);
+  if (flags.json) {
+    console.log(JSON.stringify({ status: context ? 'needs_consent' : 'none', context, candidates: candidates.map(compactCandidate) }, null, 2));
+    return;
+  }
+  if (context) console.log(context);
+}
+
+async function cmdPrompt(aquifer, flags, opts) {
+  const candidates = await listOperationalCandidates(aquifer, opts);
+  const candidate = selectCandidate(candidates, flags);
+  if (!candidate) throw new Error(`No matching Codex recovery candidate: ${flags['session-id'] || '(first)'}`);
+  const prepared = await codex.prepareSessionStartRecovery(aquifer, {
+    ...opts,
+    consent: true,
+    candidate,
+  });
+  if (flags.json) {
+    console.log(JSON.stringify({
+      status: prepared.status,
+      candidate: compactCandidate(candidate),
+      view: prepared.view ? {
+        status: prepared.view.status,
+        sessionId: prepared.view.sessionId,
+        transcriptHash: prepared.view.transcriptHash,
+        charCount: prepared.view.charCount,
+        approxPromptTokens: prepared.view.approxPromptTokens,
+        counts: prepared.view.counts,
+      } : null,
+      prompt: prepared.prompt || null,
+    }, null, 2));
+    return;
+  }
+  if (prepared.status !== 'needs_agent_summary') {
+    console.log(`Recovery prompt unavailable: ${prepared.status}`);
+    return;
+  }
+  console.log([
+    prepared.prompt,
+    '',
+    '[AQUIFER FINALIZE]',
+    'After returning the JSON summary, pipe it into:',
+    renderFinalizeCommand(candidate, opts),
+  ].join('\n'));
+}
+
+async function cmdFinalize(aquifer, flags, opts) {
+  const candidates = await listOperationalCandidates(aquifer, opts);
+  const candidate = selectCandidate(candidates, flags);
+  if (!candidate && !flags['file-path']) {
+    throw new Error(`No matching Codex recovery candidate: ${flags['session-id'] || '(first)'}`);
+  }
+  const summary = readSummaryJson(flags);
+  const result = await codex.finalizeCodexSession(aquifer, {
+    candidate: candidate || null,
+    filePath: flags['file-path'] || undefined,
+    sessionId: flags['session-id'] || candidate?.sessionId || undefined,
+    summary,
+    mode: flags.mode || 'handoff',
+    agentId: opts.agentId,
+    source: opts.source,
+    sessionKey: opts.sessionKey,
+    finalizerModel: flags['finalizer-model'] || undefined,
+    scopeKind: flags['scope-kind'] || undefined,
+    scopeKey: flags['scope-key'] || undefined,
+  }, opts);
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`Finalization ${result.status}: ${result.sessionId || flags['session-id'] || '(unknown)'}`);
+  const review = finalizationReviewText(result);
+  if (review) console.log(review);
+}
+
+async function cmdDecision(aquifer, flags, opts) {
+  const verdict = flags.verdict;
+  if (!['declined', 'deferred'].includes(verdict)) {
+    throw new Error('decision requires --verdict declined|deferred');
+  }
+  const candidates = await listOperationalCandidates(aquifer, opts);
+  if (flags.all === true) {
+    const exceptIds = parseIdList(flags['except-session-id']);
+    const selected = candidates.filter(candidate => {
+      const ids = [candidate.sessionId, candidate.fileSessionId, candidate.transcriptHash].filter(Boolean);
+      return !ids.some(id => exceptIds.has(id));
+    });
+    const results = [];
+    for (const candidate of selected) {
+      results.push(await codex.recordRecoveryDecision(aquifer, candidate, verdict, {
+        ...opts,
+        reason: flags.reason || null,
+        mode: 'session_start_recovery',
+      }));
+    }
+    if (flags.json) {
+      console.log(JSON.stringify({ status: verdict, count: results.length, results }, null, 2));
+      return;
+    }
+    console.log(`Recovery ${verdict}: ${results.length} candidate(s)`);
+    return;
+  }
+  const candidate = selectCandidate(candidates, flags);
+  if (!candidate) throw new Error(`No matching Codex recovery candidate: ${flags['session-id'] || '(first)'}`);
+  const result = await codex.recordRecoveryDecision(aquifer, candidate, verdict, {
+    ...opts,
+    reason: flags.reason || null,
+    mode: 'session_start_recovery',
+  });
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`Recovery ${verdict}: ${candidate.sessionId}`);
+}
+
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  const command = args._[0] || 'help';
+  if (args.flags.config) process.env.AQUIFER_CONFIG = args.flags.config;
+  const opts = buildRecoveryOptions(args.flags);
+
+  if (command === 'help' || args.flags.help || args.flags.h) {
+    console.log(`Usage:
+  node scripts/codex-recovery.js hook-context [options]
+  node scripts/codex-recovery.js preview [options]
+  node scripts/codex-recovery.js prompt --session-id ID [options]
+  node scripts/codex-recovery.js finalize --session-id ID --summary-stdin [options]
+  node scripts/codex-recovery.js decision --session-id ID --verdict declined|deferred [options]
+  node scripts/codex-recovery.js decision --all --verdict declined|deferred [options]`);
+    return;
+  }
+
+  await withAquifer(async (aquifer) => {
+    switch (command) {
+      case 'preview':
+        await cmdPreview(aquifer, args.flags, opts);
+        break;
+      case 'hook-context':
+        await cmdHookContext(aquifer, args.flags, opts);
+        break;
+      case 'prompt':
+        await cmdPrompt(aquifer, args.flags, opts);
+        break;
+      case 'finalize':
+        await cmdFinalize(aquifer, args.flags, opts);
+        break;
+      case 'decision':
+        await cmdDecision(aquifer, args.flags, opts);
+        break;
+      default:
+        throw new Error(`Unknown command: ${command}`);
+    }
+  });
+}
+
+module.exports = {
+  buildRecoveryOptions,
+  cmdDecision,
+  cmdFinalize,
+  cmdHookContext,
+  cmdPrompt,
+  loadCodexEnv,
+  parseArgs,
+  renderFinalizeCommand,
+  renderHookContext,
+  selectCandidate,
+};
+
+if (require.main === module) {
+  main().catch((err) => {
+    if (process.argv[2] !== 'hook-context') {
+      console.error(`codex-recovery: ${err.message}`);
+      process.exit(1);
+      return;
+    }
+    process.exit(0);
+  });
+}

package/consumers/miranda/context-inject.js

@@ -1,119 +0,0 @@
-'use strict';
-
-const { getDailyEntries } = require('./daily-entries');
-
-// ---------------------------------------------------------------------------
-// buildSessionContext — pure function, testable.
-// Emits the Miranda persona briefing that gets prepended to the system
-// prompt. Style: 散文段落, 結論收尾, 不給 bullet/table/headers.
-// ---------------------------------------------------------------------------
-
-const TODO_CAP = 5;
-
-function buildSessionContext({ today, agentId, focusText, todoItems, moodLine, handoffText, cliEntries }) {
-    const parts = [];
-    parts.push('你是 Miranda。以下是你已經知道的現況，直接用來回應，不需要讀檔或搜尋。像做 briefing——帶現況也帶判斷和建議。用散文段落，最後一句必須是結論或建議，不能是問句。若草稿有 bullet、標題、表格或問句收尾，改寫再送出。');
-    parts.push('回答任何關於過去做過什麼、討論過什麼、決策過什麼的問題時，第一步用 session_recall MCP tool 查，不要用 grep、讀 log、翻檔案。工具在手上就用。');
-
-    if (focusText) parts.push(`現在的焦點是${focusText}。`);
-    if (handoffText) parts.push(`上一段的交接：${handoffText}`);
-
-    const items = (todoItems || []).slice(0, TODO_CAP);
-    if (items.length > 0) parts.push(`手上還有${items.join('、')}。`);
-
-    if (moodLine) parts.push(`整體狀態${moodLine}。`);
-
-    const cli = (cliEntries || []).slice(-15);
-    if (cli.length > 0) parts.push(`今天已經做過的事（不要重複）：${cli.join('；')}`);
-
-    if (parts.length <= 2) return '';
-    return `<session-context date="${today}" agent="${agentId}">\n${parts.join('\n')}\n</session-context>`;
-}
-
-// ---------------------------------------------------------------------------
-// extractFocusTodoMood — pull state rows (focus/todo/mood/handoff) + cli log
-// ---------------------------------------------------------------------------
-
-function extractFocusTodoMood(todayEntries, yesterdayEntries) {
-    const allEntries = [...(todayEntries || []), ...(yesterdayEntries || [])]
-        .sort((a, b) => new Date(b.event_at) - new Date(a.event_at));
-
-    const preferCli = (tag) => {
-        const cli = allEntries.find(e => e.tag === tag && e.source === 'cli');
-        return cli || allEntries.find(e => e.tag === tag);
-    };
-    const focusEntry = preferCli('[FOCUS]');
-    const todoEntry = preferCli('[TODO]');
-    const moodEntry = allEntries.find(e => e.tag === '[MOOD]');
-    const handoffEntry = preferCli('[HANDOFF]');
-
-    const focusText = focusEntry
-        ? focusEntry.text.split('\n').map(l => l.trim().replace(/^-\s*/, '')).filter(Boolean).join(', ')
-        : '';
-
-    const todoItems = todoEntry
-        ? todoEntry.text.split('\n').map(l => l.trim().replace(/^-\s*/, '')).filter(Boolean)
-        : [];
-
-    const moodLine = moodEntry ? moodEntry.text.trim() : '';
-
-    let handoffText = '';
-    if (handoffEntry) {
-        const meta = handoffEntry.metadata || {};
-        const isTrivial = (meta.status === 'completed' && meta.next === '無')
-            || handoffEntry.text.trim().startsWith('上一段已完成 簡短交談');
-        if (!isTrivial) {
-            handoffText = handoffEntry.text.trim();
-        }
-    }
-
-    const stateTags = new Set(['[FOCUS]', '[TODO]', '[MOOD]', '[HANDOFF]', '[HIGHLIGHT]', '[NARRATIVE]']);
-    const logEntries = (todayEntries || [])
-        .filter(e => !stateTags.has(e.tag))
-        .sort((a, b) => new Date(a.event_at) - new Date(b.event_at))
-        .map(e => e.text.trim())
-        .filter(Boolean);
-
-    return { focusText, todoItems, moodLine, handoffText, cliEntries: logEntries };
-}
-
-// ---------------------------------------------------------------------------
-// computeInjection — gateway/CC shared: queries daily_entries + aquifer.bootstrap
-// and returns a ready-to-prepend context string. No host-specific wiring.
-// ---------------------------------------------------------------------------
-
-function dateTaipei(d) {
-    return new Intl.DateTimeFormat('sv-SE', {
-        timeZone: 'Asia/Taipei', year: 'numeric', month: '2-digit', day: '2-digit',
-    }).format(d);
-}
-
-async function computeInjection({ aquifer, pool, agentId, now, includeBootstrap = true }) {
-    if (!now) now = new Date();
-    const today = dateTaipei(now);
-    const yesterday = dateTaipei(new Date(now.getTime() - 86400000));
-
-    const [todayEntries, yesterdayEntries] = await Promise.all([
-        getDailyEntries(pool, today, agentId),
-        getDailyEntries(pool, yesterday, agentId),
-    ]);
-
-    const state = extractFocusTodoMood(todayEntries, yesterdayEntries);
-    const context = buildSessionContext({ today, agentId, ...state });
-
-    let bootstrapText = '';
-    if (includeBootstrap && aquifer) {
-        try {
-            const bs = await aquifer.bootstrap({ agentId, limit: 5, maxChars: 2000, format: 'text' });
-            if (bs.text && bs.sessions && bs.sessions.length > 0) bootstrapText = '\n' + bs.text;
-        } catch { /* best-effort */ }
-    }
-
-    return context + bootstrapText;
-}
-
-module.exports = {
-    buildSessionContext,
-    extractFocusTodoMood,
-    computeInjection,
-};