neurain 0.1.0-alpha.0

package/src/core/daemon.mjs

@@ -0,0 +1,536 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { absPath, ensureDir, safeResolve, sha256, timestamp } from './fs.mjs';
+import { buildSchedulerTick } from './scheduler.mjs';
+
+const MODES = new Set(['run', 'status', 'stop']);
+const STATE_REL = '00_system/neurain/daemon-state.json';
+const STOP_REL = '00_system/neurain/daemon-stop.json';
+const FORBIDDEN_FLAGS = [
+  'install',
+  'apply',
+  'write',
+  'promote',
+  'model-call',
+  'external',
+  'include-private',
+  'mcp',
+];
+
+export async function daemonCommand(args) {
+  const { mode, root } = parseDaemonTarget(args);
+  rejectUnsafeFlags(args);
+  if (mode === 'status') {
+    const payload = buildDaemonStatus(root);
+    if (args.json) return { json: true, payload };
+    return renderStatus(payload);
+  }
+  if (mode === 'stop') {
+    const payload = requestDaemonStop(root);
+    if (args.json) return { json: true, payload };
+    return renderStop(payload);
+  }
+  const payload = await runDaemon(root, {
+    area: args.area || '',
+    top: Number(args.top || 10),
+    sinceMinutes: Number(args['since-minutes'] || 1440),
+    minTriggers: Number(args['min-triggers'] || 1),
+    minEvents: Number(args['min-events'] || 1),
+    intervalSeconds: numberOrDefault(args['interval-seconds'], 300),
+    maxTicks: numberOrDefault(args['max-ticks'], 0),
+  });
+  if (args.json) return { json: true, payload };
+  return renderRun(payload);
+}
+
+export async function runDaemon(root, {
+  area = '',
+  top = 10,
+  sinceMinutes = 1440,
+  minTriggers = 1,
+  minEvents = 1,
+  intervalSeconds = 300,
+  maxTicks = 0,
+} = {}) {
+  const runId = sha256(`${process.pid}:${Date.now()}:${Math.random()}`).slice(0, 16);
+  const startedAt = timestamp();
+  const numericInterval = clampNumber(intervalSeconds, 300, 0, 3600);
+  const numericMaxTicks = normalizeMaxTicks(maxTicks);
+  if (numericMaxTicks === 0 && numericInterval === 0) {
+    throw new Error('Refusing unbounded daemon with interval 0. Use --max-ticks for tests or set --interval-seconds above 0.');
+  }
+  const existing = readState(root);
+  if (existing && ['running', 'stop_requested'].includes(existing.status) && isPidAlive(existing.pid)) {
+    throw new Error(`Daemon already running for this root: pid ${existing.pid}, run ${existing.run_id}. Run: neurain daemon stop "${root}"`);
+  }
+  clearStopRequest(root);
+  const ticks = [];
+  let stopReason = 'max_ticks_reached';
+  let state = baseState(root, {
+    runId,
+    startedAt,
+    status: 'running',
+    area,
+    intervalSeconds: numericInterval,
+    maxTicks: numericMaxTicks,
+  });
+  writeState(root, state);
+
+  for (let index = 0; numericMaxTicks === 0 || index < numericMaxTicks; index += 1) {
+    if (stopRequested(root, runId)) {
+      stopReason = 'stop_requested';
+      break;
+    }
+
+    const tick = buildSchedulerTick(root, {
+      command: 'daemon scheduler tick',
+      area,
+      top,
+      sinceMinutes,
+      minTriggers,
+      minEvents,
+      includeReview: true,
+    });
+    const summary = summarizeTick(tick, index + 1, numericInterval);
+    ticks.push(summary);
+    state = {
+      ...state,
+      status: 'running',
+      updated_at: timestamp(),
+      tick_count: ticks.length,
+      review_due_count: ticks.filter((item) => item.review_due).length,
+      last_tick: summary,
+      stop_requested: stopRequested(root, runId),
+    };
+    writeState(root, state);
+
+    if (state.stop_requested) {
+      stopReason = 'stop_requested';
+      break;
+    }
+    if (numericMaxTicks > 0 && ticks.length >= numericMaxTicks) break;
+    if (stopRequested(root, runId)) {
+      stopReason = 'stop_requested';
+      break;
+    }
+    if (numericInterval > 0) {
+      const stoppedDuringSleep = await interruptibleSleep(root, runId, numericInterval * 1000);
+      if (stoppedDuringSleep) {
+        stopReason = 'stop_requested';
+        break;
+      }
+    }
+  }
+
+  const finalState = {
+    ...state,
+    status: 'stopped',
+    stop_reason: stopReason,
+    stop_requested: stopReason === 'stop_requested',
+    stopped_at: timestamp(),
+    updated_at: timestamp(),
+    tick_count: ticks.length,
+    review_due_count: ticks.filter((item) => item.review_due).length,
+  };
+  writeState(root, finalState);
+  clearStopRequest(root, runId);
+
+  return {
+    ok: true,
+    command: 'daemon run',
+    root,
+    area: area || null,
+    durable_write: false,
+    durable_knowledge_write: false,
+    operational_state_write: true,
+    model_calls: false,
+    external_tool_calls: false,
+    writes_wiki: false,
+    promotes_lessons: false,
+    daemon_started: true,
+    mcp_exposed: false,
+    write_policy: 'operational_state_only',
+    state_path: STATE_REL,
+    daemon: {
+      mode: 'foreground_continuous',
+      process_id: process.pid,
+      run_id: runId,
+      interval_seconds: numericInterval,
+      max_ticks: numericMaxTicks,
+      completed_ticks: ticks.length,
+      review_due_count: finalState.review_due_count,
+      stop_reason: stopReason,
+      background_job_started: false,
+      install_supported: false,
+      mcp_exposed: false,
+      stop_supported: true,
+    },
+    ticks,
+  };
+}
+
+export function buildDaemonStatus(root) {
+  const state = readState(root);
+  const pidAlive = state?.pid ? isPidAlive(state.pid) : false;
+  return {
+    ok: true,
+    command: 'daemon status',
+    root,
+    durable_write: false,
+    durable_knowledge_write: false,
+    operational_state_write: false,
+    model_calls: false,
+    external_tool_calls: false,
+    mcp_exposed: false,
+    state_path: STATE_REL,
+    state_exists: Boolean(state),
+    daemon: state
+      ? {
+          status: state.status,
+          run_id: state.run_id,
+          process_id: state.pid,
+          pid_alive: ['running', 'stop_requested'].includes(state.status) ? pidAlive : false,
+          started_at: state.started_at,
+          updated_at: state.updated_at,
+          stopped_at: state.stopped_at || null,
+          tick_count: state.tick_count || 0,
+          review_due_count: state.review_due_count || 0,
+          stop_requested: Boolean(state.stop_requested),
+          last_tick: state.last_tick || null,
+          safety: state.safety,
+        }
+      : null,
+    next_suggested_command: ['running', 'stop_requested'].includes(state?.status)
+      ? `neurain daemon stop "${root}"`
+      : `neurain daemon run "${root}" --interval-seconds 300`,
+  };
+}
+
+export function requestDaemonStop(root) {
+  const state = readState(root);
+  if (!state) {
+    return {
+      ok: true,
+      command: 'daemon stop',
+      root,
+      durable_write: false,
+      durable_knowledge_write: false,
+      operational_state_write: false,
+      model_calls: false,
+      external_tool_calls: false,
+      mcp_exposed: false,
+      stop_requested: false,
+      reason: 'no running daemon state found',
+    };
+  }
+  if (['running', 'stop_requested'].includes(state.status) && !isPidAlive(state.pid)) {
+    const stale = {
+      ...state,
+      status: 'stopped',
+      stop_reason: 'stale_pid',
+      stop_requested: false,
+      stopped_at: timestamp(),
+      updated_at: timestamp(),
+    };
+    writeState(root, stale);
+    clearStopRequest(root, state.run_id);
+    return {
+      ok: true,
+      command: 'daemon stop',
+      root,
+      durable_write: false,
+      durable_knowledge_write: false,
+      operational_state_write: true,
+      model_calls: false,
+      external_tool_calls: false,
+      mcp_exposed: false,
+      stop_requested: false,
+      state_path: STATE_REL,
+      reason: 'stale running state found; marked stopped',
+    };
+  }
+  if (state.status === 'stop_requested') {
+    return {
+      ok: true,
+      command: 'daemon stop',
+      root,
+      durable_write: false,
+      durable_knowledge_write: false,
+      operational_state_write: false,
+      model_calls: false,
+      external_tool_calls: false,
+      mcp_exposed: false,
+      stop_requested: true,
+      state_path: STATE_REL,
+      daemon: {
+        run_id: state.run_id,
+        process_id: state.pid,
+        pid_alive: isPidAlive(state.pid),
+        status: state.status,
+      },
+    };
+  }
+  if (state.status !== 'running') {
+    return {
+      ok: true,
+      command: 'daemon stop',
+      root,
+      durable_write: false,
+      durable_knowledge_write: false,
+      operational_state_write: false,
+      model_calls: false,
+      external_tool_calls: false,
+      mcp_exposed: false,
+      stop_requested: false,
+      reason: 'no running daemon state found',
+    };
+  }
+  const next = {
+    ...state,
+    status: 'stop_requested',
+    stop_requested: true,
+    updated_at: timestamp(),
+  };
+  writeStopRequest(root, next.run_id);
+  writeState(root, next);
+  return {
+    ok: true,
+    command: 'daemon stop',
+    root,
+    durable_write: false,
+    durable_knowledge_write: false,
+    operational_state_write: true,
+    model_calls: false,
+    external_tool_calls: false,
+    mcp_exposed: false,
+    stop_requested: true,
+    state_path: STATE_REL,
+    daemon: {
+      run_id: next.run_id,
+      process_id: next.pid,
+      pid_alive: isPidAlive(next.pid),
+      status: next.status,
+    },
+  };
+}
+
+function parseDaemonTarget(args) {
+  const parts = args._ || [];
+  const first = parts[0] || 'status';
+  if (['install', 'launchd', 'service', 'background', 'apply', 'write', 'promote'].includes(first)) {
+    throw new Error('Public alpha daemon supports foreground run, status, and cooperative stop only.');
+  }
+  const mode = MODES.has(first) ? first : 'status';
+  const rootArg = MODES.has(first) ? parts[1] : first;
+  return {
+    mode,
+    root: absPath(rootArg || args.root || process.cwd()),
+  };
+}
+
+function rejectUnsafeFlags(args) {
+  for (const flag of FORBIDDEN_FLAGS) {
+    if (args[flag]) {
+      throw new Error('Public alpha daemon cannot install jobs, write knowledge, promote lessons, call models, expose MCP write tools, or include private material.');
+    }
+  }
+}
+
+function baseState(root, { runId, startedAt, status, area, intervalSeconds, maxTicks }) {
+  return {
+    version: 1,
+    kind: 'neurain_daemon_state',
+    run_id: runId,
+    root,
+    area: area || null,
+    pid: process.pid,
+    status,
+    started_at: startedAt,
+    updated_at: startedAt,
+    stopped_at: null,
+    tick_count: 0,
+    review_due_count: 0,
+    interval_seconds: intervalSeconds,
+    max_ticks: maxTicks,
+    stop_requested: false,
+    safety: {
+      durable_knowledge_write: false,
+      operational_state_write: true,
+      model_calls: false,
+      external_tool_calls: false,
+      writes_wiki: false,
+      promotes_lessons: false,
+      private_paths_stored: false,
+      private_descendant_paths_stored: false,
+      mcp_exposed: false,
+    },
+  };
+}
+
+function summarizeTick(tick, index, intervalSeconds) {
+  return {
+    index,
+    at: timestamp(),
+    interval_seconds: intervalSeconds,
+    review_due: Boolean(tick.review_fork.should_run),
+    reason: sanitizeReason(tick.review_fork.reason),
+    trigger_count: tick.review_fork.trigger_count,
+    meaningful_event_count: tick.review_fork.meaningful_event_count,
+    includes_review_report: Boolean(tick.review_fork.includes_review_report),
+    journal_integrity_ok: Boolean(tick.watch_report?.journal_integrity?.ok),
+    lesson_candidate_count: Number(tick.watch_report?.lesson_candidate_count || 0),
+    recent_event_count: Number(tick.watch_report?.recent_events?.length || 0),
+    recent_file_count: Number(tick.watch_report?.recent_files?.length || 0),
+  };
+}
+
+function readState(root) {
+  try {
+    const file = safeResolve(root, STATE_REL);
+    if (!fs.existsSync(file)) return null;
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function readStopRequest(root) {
+  try {
+    const file = safeResolve(root, STOP_REL);
+    if (!fs.existsSync(file)) return null;
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeState(root, state) {
+  const file = safeResolve(root, STATE_REL);
+  ensureDir(path.dirname(file));
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  fs.renameSync(tmp, file);
+}
+
+function writeStopRequest(root, runId) {
+  const file = safeResolve(root, STOP_REL);
+  ensureDir(path.dirname(file));
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify({
+    version: 1,
+    kind: 'neurain_daemon_stop_request',
+    run_id: runId,
+    requested_at: timestamp(),
+  }, null, 2)}\n`, 'utf8');
+  fs.renameSync(tmp, file);
+}
+
+function clearStopRequest(root, runId = null) {
+  const request = readStopRequest(root);
+  if (runId && request?.run_id !== runId) return;
+  try {
+    fs.rmSync(safeResolve(root, STOP_REL), { force: true });
+  } catch {
+    /* ignore cleanup failures */
+  }
+}
+
+function stopRequested(root, runId) {
+  const request = readStopRequest(root);
+  return request?.run_id === runId;
+}
+
+function sanitizeReason(reason) {
+  const text = String(reason || 'review threshold reached');
+  if (/(^|\s)([A-Za-z0-9._-]+\/)+[A-Za-z0-9._-]+/.test(text)) return 'review threshold reached';
+  return text.length > 240 ? `${text.slice(0, 237)}...` : text;
+}
+
+function renderRun(payload) {
+  return {
+    text: [
+      '# Neurain daemon run',
+      '',
+      `- Root: ${payload.root}`,
+      `- Area: ${payload.area || 'all'}`,
+      '- Durable knowledge write: no',
+      '- Operational state write: yes',
+      '- Model calls: no',
+      '- External tool calls: no',
+      '- MCP exposed: no',
+      `- Ticks completed: ${payload.daemon.completed_ticks}`,
+      `- Review due ticks: ${payload.daemon.review_due_count}`,
+      `- State: ${payload.state_path}`,
+    ].join('\n'),
+  };
+}
+
+function renderStatus(payload) {
+  return {
+    text: [
+      '# Neurain daemon status',
+      '',
+      `- Root: ${payload.root}`,
+      '- Durable knowledge write: no',
+      '- Operational state write: no',
+      `- State exists: ${payload.state_exists ? 'yes' : 'no'}`,
+      `- Status: ${payload.daemon?.status || 'not running'}`,
+      `- Stop requested: ${payload.daemon?.stop_requested ? 'yes' : 'no'}`,
+      `- Ticks: ${payload.daemon?.tick_count || 0}`,
+      `- Next: ${payload.next_suggested_command}`,
+    ].join('\n'),
+  };
+}
+
+function renderStop(payload) {
+  return {
+    text: [
+      '# Neurain daemon stop',
+      '',
+      `- Root: ${payload.root}`,
+      '- Durable knowledge write: no',
+      `- Stop requested: ${payload.stop_requested ? 'yes' : 'no'}`,
+      payload.reason ? `- Reason: ${payload.reason}` : `- State: ${payload.state_path}`,
+    ].join('\n'),
+  };
+}
+
+function isPidAlive(pid) {
+  try {
+    process.kill(Number(pid), 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function normalizeMaxTicks(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return 0;
+  return Math.max(1, Math.min(Math.trunc(parsed), 1000));
+}
+
+async function interruptibleSleep(root, runId, ms) {
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    if (stopRequested(root, runId)) return true;
+    await sleep(Math.min(1000, deadline - Date.now()));
+  }
+  return stopRequested(root, runId);
+}
+
+function clampNumber(value, fallback, min, max) {
+  const parsed = Number(value);
+  const selected = Number.isFinite(parsed) ? parsed : fallback;
+  return Math.max(min, Math.min(Math.trunc(selected), max));
+}
+
+function numberOrDefault(value, fallback) {
+  if (value === undefined || value === null || value === '') return fallback;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/core/digest.mjs

@@ -0,0 +1,155 @@
+// "Since your last visit" cross-session digest. Read-only port of the vault
+// digest-intel compute + render. The engine NEVER advances the ack pointer:
+// session-state writes are owned by a later wave (W-D), and introducing a second
+// lock protocol on session-state.json during the soak is the data-loss class the
+// cutover machinery exists to avoid. The legacy ack therefore stays vault-side;
+// the engine returns `through_ms` so a vault shim can ack after delivering the
+// rendered digest to a human.
+//
+// Privacy (kept identical to the vault): current-area only, foreign-area
+// references redacted at output time, conservative dedupe, a 72h window floor.
+import path from 'node:path';
+import { absPath } from './fs.mjs';
+import { vaultConfig } from './config.mjs';
+import { areaBriefPath, frontmatterField, loadSessionState, readJsonl, readTextAt } from './vault_state.mjs';
+
+const WINDOW_HOURS_DEFAULT = 72;
+const MAX_ITEMS = 12;
+const MAX_TEXT = 140;
+
+function toMs(ts) {
+  if (!ts) return NaN;
+  const ms = new Date(String(ts).trim().replace(' ', 'T')).getTime();
+  return Number.isNaN(ms) ? NaN : ms;
+}
+
+function agoLabel(ms, now) {
+  const d = Math.max(0, now - ms);
+  const h = d / 3600000;
+  if (h < 1) return `${Math.max(1, Math.round(d / 60000))}m ago`;
+  if (h < 48) return `${Math.round(h)}h ago`;
+  return `${Math.round(h / 24)}d ago`;
+}
+
+function clip(s) {
+  const t = String(s || '').replace(/\s+/g, ' ').trim();
+  return t.length > MAX_TEXT ? `${t.slice(0, MAX_TEXT - 1)}…` : t;
+}
+
+// Pure read. now/windowHours/sources injectable; never throws on missing data.
+export function computeDigest(root, sessionId, opts = {}) {
+  const vaultCfg = opts.vaultCfg || vaultConfig(root);
+  const now = opts.now || Date.now();
+  const windowHours = opts.windowHours || WINDOW_HOURS_DEFAULT;
+  const sources = new Set(opts.sources || ['area-brief', 'wrap-journal']);
+
+  let state = { sessions: {} };
+  try { state = loadSessionState(root, vaultCfg); } catch { state = { sessions: {} }; }
+  const sessions = state.sessions || {};
+  const me = sessions[sessionId];
+  if (!me) return { ok: false, error: `unknown session "${sessionId}"`, known: Object.keys(sessions) };
+  const area = me.area || '';
+  if (!area) return { ok: false, error: `session "${sessionId}" has no area (digest is per-area)` };
+
+  const floorMs = now - windowHours * 3600000;
+  const ackedMs = toMs(me.last_acked_at);
+  const lowerMs = Math.max(Number.isNaN(ackedMs) ? 0 : ackedMs, floorMs);
+  const engineOf = (sid) => (sessions[sid] && sessions[sid].engine) || 'unknown';
+  const areaSensitivity = frontmatterField(readTextAt(root, `${vaultCfg.areas_dir}/${area}/_area.md`), 'sensitivity') || 'internal';
+
+  // Redact notes that reference ANOTHER area (cross-area text may carry private
+  // content). Match the underscore area-id form, applied at output (after dedupe).
+  const foreignAreas = [...new Set(Object.values(sessions).map((s) => s && s.area).filter((a) => a && a !== area))];
+  const foreignRe = foreignAreas.length
+    ? new RegExp(`(?:^|[^A-Za-z0-9_])(${foreignAreas.map((a) => a.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')})(?![A-Za-z0-9])`)
+    : null;
+  const redact = (t) => (foreignRe && foreignRe.test(String(t)) ? '[redacted: references another area]' : String(t));
+
+  const items = [];
+  if (sources.has('area-brief')) {
+    const brief = readTextAt(root, areaBriefPath(vaultCfg, area));
+    if (brief) {
+      let inNotes = false;
+      for (const ln of brief.split(/\r?\n/)) {
+        if (/^#{1,6}\s/.test(ln)) { inNotes = /Latest Cross-Session Notes/i.test(ln); continue; }
+        if (!inNotes) continue;
+        const m = ln.match(/^-\s+(\d{4}-\d{2}-\d{2}[T ][0-9:+\-Z.]+)\s+([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!m) continue;
+        const ms = toMs(m[1]);
+        if (Number.isNaN(ms)) continue;
+        items.push({ ms, session: m[2], text: m[3], source: 'area-brief' });
+      }
+    }
+  }
+  if (sources.has('wrap-journal')) {
+    for (const r of readJsonl(path.join(root, vaultCfg.wrap_journal))) {
+      if (!r || r.area !== area) continue;
+      if (r.committed === false || r.dry_run) continue;
+      const ms = toMs(r.wrapped_at);
+      if (Number.isNaN(ms)) continue;
+      items.push({ ms, session: r.session_id || '?', text: r.headline || r.boundary || 'wrap', source: 'wrap-journal' });
+    }
+  }
+
+  const kept = items.filter((it) => it.ms > lowerMs && it.ms <= now && it.session !== sessionId);
+  const seen = new Map();
+  for (const it of kept.sort((a, b) => (a.source === b.source ? 0 : a.source === 'wrap-journal' ? -1 : 1))) {
+    const key = `${it.session}|${clip(it.text).toLowerCase()}`;
+    if (!seen.has(key)) seen.set(key, it);
+  }
+  const deduped = [...seen.values()].sort((a, b) => b.ms - a.ms);
+  const total = deduped.length;
+  const shown = deduped.slice(0, MAX_ITEMS);
+
+  return {
+    ok: true,
+    area,
+    area_sensitivity: areaSensitivity,
+    window_hours: windowHours,
+    lower_ms: lowerMs,
+    through_ms: now,
+    total,
+    shown: shown.length,
+    truncated: total - shown.length,
+    items: shown.map((it) => ({ ago: agoLabel(it.ms, now), engine: engineOf(it.session), session: it.session, source: it.source, text: clip(redact(it.text)) })),
+    coverage_note: 'From wrap/sync records only; work ended without a command is not shown.',
+    privacy_note: "This area's command-mediated work only; other areas (including private ones) are never gathered, and cross-area references are redacted.",
+  };
+}
+
+export function renderDigest(d) {
+  if (!d || !d.ok) return '';
+  const lines = [];
+  lines.push(`## Since your last visit (last ${d.window_hours}h in ${d.area}; from wrap/sync records, work ended without a command is not shown)`);
+  if (!d.items.length) {
+    lines.push('- Nothing new from other sessions in this window.');
+  } else {
+    for (const it of d.items) {
+      const who = it.engine && it.engine !== 'unknown' ? `${it.engine}/${it.session}` : it.session;
+      lines.push(`- [${who}] ${it.text}  (${it.ago})`);
+    }
+    if (d.truncated > 0) lines.push(`- ... and ${d.truncated} more (see area brief + wrap-journal)`);
+  }
+  lines.push('');
+  lines.push(`_${d.privacy_note}_`);
+  return lines.join('\n');
+}
+
+export async function digestCommand(args) {
+  const root = absPath(args._[0] || args.root || process.cwd());
+  const sessionId = String(args.session || args['session-id'] || '');
+  if (!sessionId) throw new Error('digest requires --session <id>.');
+  const opts = {
+    now: args.now !== undefined ? Number(args.now) : undefined,
+    windowHours: args['window-hours'] !== undefined ? Number(args['window-hours']) : undefined,
+    sources: args.sources ? String(args.sources).split(',').map((s) => s.trim()).filter(Boolean) : undefined,
+  };
+  const payload = computeDigest(root, sessionId, opts);
+  // The engine never acks; a vault shim acks after delivering `rendered`.
+  payload.command = 'digest';
+  payload.durable_write = false;
+  payload.rendered = renderDigest(payload);
+  if (args.json) return { json: true, payload };
+  if (!payload.ok) return { text: `# Neurain digest\n\n- ${payload.error}` };
+  return { text: payload.rendered || '# Neurain digest\n\n- Nothing new.' };
+}