@limina-labs/momentum 0.30.2

package/core/orchestration/continue.js

@@ -0,0 +1,102 @@
+'use strict';
+
+// continueHandoff — receiving-side counterpart to handoff.
+//
+// Reads a pending inbox file, parses the HandoffBlock, marks the file
+// as read (move to .momentum/inbox/read/), and emits a [NOTE] in the
+// receiving repo's active phase history. Returns the HandoffBlock so
+// the agent or CLI can act on it.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const eventsLib = require('./events');
+const handoffLib = require('./handoff');
+const sessionLog = require('./session-log');
+
+/**
+ * Pick up a pending handoff in the receiving repo.
+ *
+ * @param {object} opts
+ * @param {string} opts.repo            absolute path to receiving repo
+ * @param {string} [opts.handoffId]     pick a specific id; default: oldest pending
+ * @param {object} [opts.ecosystem]
+ * @param {object} [opts.emitter]
+ * @param {boolean} [opts.silent]
+ * @returns {Promise<HandoffBlock|null>}  null when no pending handoff
+ */
+async function continueHandoff(opts) {
+  const { repo, ecosystem } = opts;
+  if (!repo) throw new Error('orchestration/continue: opts.repo required');
+
+  const pending = handoffLib.listPending(repo);
+  if (pending.length === 0) return null;
+
+  let chosen;
+  if (opts.handoffId) {
+    const id = String(opts.handoffId).padStart(3, '0');
+    chosen = pending.find((p) => path.basename(p) === `handoff-${id}.md`);
+    if (!chosen) {
+      throw new Error(`orchestration/continue: handoff-${id}.md not found in ${repo}`);
+    }
+  } else {
+    chosen = pending[0];
+  }
+
+  const emitter = opts.emitter || eventsLib.createEmitter({ primitive: 'continue', repo });
+  if (!opts.emitter && !opts.silent) {
+    emitter.on(eventsLib.createRenderer({ stream: process.stdout }));
+  }
+  if (ecosystem) {
+    emitter.on(eventsLib.createPersister({
+      ecosystemRoot: ecosystem.rootPath,
+      memberId: ecosystem.memberId,
+    }));
+  }
+
+  const block = handoffLib.parseInbox(chosen);
+  emitter.emit('started', { message: `picking up ${path.basename(chosen)} from ${path.basename(block.fromRepo)}` });
+  const readPath = handoffLib.markRead(chosen);
+  emitter.emit('step', { message: `marked ${path.basename(readPath)} read` });
+
+  // Append a [NOTE] entry in the receiving repo's active phase history.
+  const activePhase = handoffLib.detectActivePhase(repo);
+  if (activePhase) {
+    appendReceivingNote({ repo, activePhase, block });
+  }
+
+  emitter.emit('finished', { runArtifactPath: readPath });
+  return block;
+}
+
+/**
+ * List pending handoffs (paths) in the given repo. Convenience wrapper
+ * over handoffLib.listPending so callers don't have to know about the
+ * inbox layout.
+ */
+function listPending(repo) {
+  return handoffLib.listPending(repo);
+}
+
+function appendReceivingNote({ repo, activePhase, block }) {
+  const historyPath = path.join(repo, 'specs', 'phases', activePhase, 'history.md');
+  if (!fs.existsSync(historyPath)) return;
+  const date = new Date().toISOString().slice(0, 10);
+  const entry = [
+    '',
+    `### [NOTE] ${date} — Picked up handoff-${block.handoffId} from ${path.basename(block.fromRepo)}`,
+    `Topics: orchestration, handoff-pickup, handoff-${block.handoffId}`,
+    `Affects-phases: ${activePhase} (or "none")`,
+    `Affects-specs: ${path.relative(repo, path.join(repo, handoffLib.INBOX_DIRNAME, 'read', `handoff-${block.handoffId}.md`))}`,
+    `Detail: Received handoff from ${path.basename(block.fromRepo)}. Summary: ${block.summary}`,
+    '',
+    '---',
+    '',
+  ].join('\n');
+  fs.appendFileSync(historyPath, entry);
+}
+
+module.exports = {
+  continueHandoff,
+  listPending,
+};

package/core/orchestration/dispatch.js

@@ -0,0 +1,366 @@
+'use strict';
+
+// dispatch — parallel multi-repo fan-out + synthesis.
+//
+// In-process mode (CLI floor): runs scout against each repo. On
+// `mode='parallel'` they run concurrently via Promise.all; on
+// `mode='sequential'` they run one at a time and the user is told
+// up front via a `started` event note. Either way, sub-agent failures
+// are captured in `failures[]` — the call never throws.
+//
+// In-agent mode (slash command on Claude Code / Codex / Antigravity):
+// the agent does the per-repo fan-out using its own sub-agent surface
+// (Task tool on Claude Code, etc.), then calls record() with the
+// structured results so the artifact + log line + tracking-contract
+// hand-off all happen via the same code path as the CLI.
+//
+// Synthesis: in-process, the synthesizer concatenates per-repo
+// summaries with a header — no LLM available from raw Node. Agent-
+// driven dispatch produces a true synthesis in the originating agent's
+// context, then calls record() with `synthesis` text included.
+
+const path = require('node:path');
+
+const eventsLib = require('./events');
+const runArtifact = require('./run-artifact');
+const sessionLog = require('./session-log');
+const types = require('./types');
+const routing = require('./capability-routing');
+const scoutLib = require('./scout');
+
+// ENH-034 — CLI / in-process dispatch degraded-mode notice. Emitted as
+// the FIRST event before `started`, and rendered as a `> [!NOTE]`
+// admonition inside the artifact + synthesis body. Three surfaces, one
+// string so the message stays consistent everywhere agents/users see it.
+const CLI_MODE_NOTICE =
+  'MODE NOTICE: CLI mode produces keyword summaries only (no LLM synthesis). ' +
+  'For full synthesis, invoke /dispatch as a slash command from an agent surface ' +
+  '(Claude Code Task tool, Codex sub-agent, etc.).';
+
+/**
+ * Run a dispatch in-process across the given repos.
+ *
+ * @param {object} opts
+ * @param {string[]} opts.repos              absolute paths to target repos
+ * @param {string}   opts.userIntent         high-level prompt
+ * @param {string}   [opts.originatingRepo]  defaults to first repo
+ * @param {object}   [opts.adapter]          adapter module for capability routing
+ * @param {object}   [opts.ecosystem]        { rootPath, memberId }
+ * @param {boolean}  [opts.forceSequential]  force sequential mode (testing aid)
+ * @param {boolean}  [opts.silent]
+ * @returns {Promise<DispatchResult>}
+ */
+async function dispatch(opts) {
+  const { repos, userIntent } = opts;
+  if (!Array.isArray(repos) || repos.length === 0) {
+    throw new Error('orchestration/dispatch: opts.repos must be a non-empty array');
+  }
+  if (!userIntent) {
+    throw new Error('orchestration/dispatch: opts.userIntent is required');
+  }
+  const originatingRepo = opts.originatingRepo || repos[0];
+
+  // Decide mode: explicit override > adapter capability > parallel default.
+  let mode = 'parallel';
+  let modeNotes = [];
+  if (opts.forceSequential) {
+    mode = 'sequential';
+    modeNotes.push('sequential mode forced via --sequential');
+  } else if (opts.adapter) {
+    const decision = routing.chooseMode(opts.adapter, 'dispatch');
+    mode = decision.mode;
+    modeNotes = decision.notes;
+  }
+
+  const start = Date.now();
+  const emitter = opts.emitter || eventsLib.createEmitter({ primitive: 'dispatch', repo: originatingRepo });
+  if (!opts.emitter && !opts.silent) {
+    emitter.on(eventsLib.createRenderer({ stream: process.stdout }));
+  }
+  if (opts.ecosystem) {
+    emitter.on(eventsLib.createPersister({
+      ecosystemRoot: opts.ecosystem.rootPath,
+      memberId: opts.ecosystem.memberId,
+    }));
+  }
+
+  // ENH-034 — surface the in-process degraded-mode notice UPFRONT
+  // (before the `started` event) so it is the literal first user-visible
+  // output line. Without this, agents and users were silently getting
+  // keyword-grep summaries and concluding "this is the answer."
+  //
+  // The `record()` path (agent-driven dispatch from a slash command)
+  // never reaches dispatch(), so this notice only fires for CLI /
+  // in-process callers — exactly where it's needed.
+  emitter.emit('note', { message: CLI_MODE_NOTICE });
+
+  emitter.emit('started', {
+    message: `${repos.length} repo(s): ${userIntent}`,
+  });
+  for (const note of modeNotes) {
+    emitter.emit('note', { message: note });
+  }
+
+  const perRepoResults = [];
+  const failures = [];
+
+  async function runOne(repo) {
+    emitter.emit('subagent-started', { repo });
+    const perRepoPrompt = tailorPrompt(userIntent, repo);
+    const t0 = Date.now();
+    try {
+      const scoutResult = await scoutLib.scout({
+        repo,
+        prompt: perRepoPrompt,
+        originatingRepo,
+        // Skip session log on sub-scouts so the ecosystem log isn't
+        // peppered with per-repo lines; the dispatch parent emits one
+        // line summarising the whole run.
+        ecosystem: null,
+        silent: true,
+      });
+      const entry = {
+        repo,
+        prompt: perRepoPrompt,
+        summary: scoutResult.summary,
+        findings: scoutResult.findings,
+        filesRead: scoutResult.filesRead,
+        duration: Date.now() - t0,
+      };
+      perRepoResults.push(entry);
+      emitter.emit('subagent-finished', { repo, duration: entry.duration });
+      return entry;
+    } catch (err) {
+      const entry = {
+        repo,
+        prompt: perRepoPrompt,
+        error: { message: err.message },
+        duration: Date.now() - t0,
+      };
+      perRepoResults.push(entry);
+      failures.push(entry);
+      emitter.emit('subagent-failed', { repo, error: err.message });
+      return entry;
+    }
+  }
+
+  if (mode === 'parallel') {
+    await Promise.all(repos.map(runOne));
+  } else {
+    for (const repo of repos) {
+      await runOne(repo);
+    }
+  }
+
+  const synthesis = synthesizeInProcess({ userIntent, perRepoResults, failures });
+  emitter.emit('synthesized', { summary: oneLineSynthesis(perRepoResults, failures) });
+
+  const duration = Date.now() - start;
+  const { runId, artifactPath } = runArtifact.writeWithAllocatedId({
+    repo: originatingRepo,
+    primitive: 'dispatch',
+    bodyFor: (id) => renderArtifact({ runId: id, repos, userIntent, mode, modeNotes, perRepoResults, failures, synthesis, duration }),
+  });
+  emitter.context.runId = runId;
+  emitter.emit('finished', { duration, runArtifactPath: artifactPath });
+
+  const result = {
+    repos,
+    userIntent,
+    mode,
+    modeNotes,
+    perRepoResults,
+    failures,
+    synthesis,
+    duration,
+    runArtifactPath: artifactPath,
+    runId,
+  };
+  return types.validateDispatchResult(result);
+}
+
+/**
+ * Record a dispatch performed by an external agent.
+ *
+ * The agent does its own sub-agent fan-out (e.g., Claude Code Task
+ * tool) and synthesis, then calls record() with the structured shape
+ * so the artifact + session log line + tracking-contract hand-off all
+ * happen via the same code path the CLI uses.
+ */
+function record(opts) {
+  const {
+    repos,
+    userIntent,
+    mode = 'parallel',
+    modeNotes = [],
+    perRepoResults = [],
+    failures = [],
+    synthesis,
+    originatingRepo,
+    ecosystem,
+    duration = 0,
+  } = opts;
+  if (!originatingRepo) {
+    throw new Error('orchestration/dispatch.record: originatingRepo required');
+  }
+  const { runId, artifactPath } = runArtifact.writeWithAllocatedId({
+    repo: originatingRepo,
+    primitive: 'dispatch',
+    bodyFor: (id) => renderArtifact({ runId: id, repos, userIntent, mode, modeNotes, perRepoResults, failures, synthesis, duration, isAgentDriven: true }),
+  });
+  if (ecosystem && ecosystem.rootPath && ecosystem.memberId) {
+    sessionLog.appendLine({
+      ecosystemRoot: ecosystem.rootPath,
+      memberId: ecosystem.memberId,
+      kind: 'dispatch',
+      summary: `${repos.length} repos: ${userIntent}`,
+      context: `run-${runId} → ${path.relative(originatingRepo, artifactPath)}`,
+    });
+  }
+  // Tracking contract: each per-repo finding proposed as [DISCOVERY]
+  // in THAT repo's active phase history (only when meaningful per
+  // Rule 3). The synthesis is proposed as a [NOTE] in the
+  // ORIGINATING repo's active phase history when present.
+  const tracking = require('./tracking');
+  for (const perRepo of perRepoResults) {
+    if (!perRepo.findings) continue;
+    for (const finding of perRepo.findings) {
+      tracking.proposeDiscovery({ primitive: 'dispatch', finding, targetRepo: perRepo.repo });
+    }
+  }
+  if (synthesis) {
+    tracking.proposeHistoryNote({
+      primitive: 'dispatch',
+      originatingRepo,
+      message: `dispatch across ${repos.length} repo(s) for: ${userIntent}`,
+      runArtifactRef: path.relative(originatingRepo, artifactPath),
+    });
+  }
+  const result = {
+    repos, userIntent, mode, modeNotes,
+    perRepoResults, failures, synthesis,
+    duration, runArtifactPath: artifactPath, runId,
+  };
+  return types.validateDispatchResult(result);
+}
+
+// ── helpers ────────────────────────────────────────────────────────────────
+
+function tailorPrompt(userIntent, repo) {
+  // In-process mode reuses the same prompt verbatim — the scout
+  // tokenizer is the limiting factor anyway. Agent-driven dispatch
+  // can produce repo-specific phrasing in the originating agent's
+  // context before calling record().
+  const repoLabel = path.basename(repo);
+  return `In repo ${repoLabel}: ${userIntent}`;
+}
+
+function synthesizeInProcess({ userIntent, perRepoResults, failures }) {
+  const successes = perRepoResults.filter((r) => !r.error);
+  // ENH-034 — admonition at the TOP of the synthesis block so anyone
+  // reading the in-process synthesis sees the mode caveat BEFORE the
+  // per-repo summaries (previously buried at the bottom as a paren).
+  const lines = [
+    '> [!NOTE]',
+    '> **MODE: CLI / in-process — keyword summaries only.**',
+    '> For LLM synthesis, invoke /dispatch via an agent slash command.',
+    '',
+    `Dispatch across ${perRepoResults.length} repo(s) for: ${userIntent}`,
+    '',
+    `- ${successes.length} succeeded, ${failures.length} failed.`,
+  ];
+  if (successes.length) {
+    lines.push('', '## Per-repo summaries');
+    for (const r of successes) {
+      const repoLabel = path.basename(r.repo);
+      lines.push(`- **${repoLabel}** (${r.duration}ms): ${truncateForSynth(r.summary)}`);
+    }
+  }
+  if (failures.length) {
+    lines.push('', '## Failures');
+    for (const f of failures) {
+      const repoLabel = path.basename(f.repo);
+      lines.push(`- **${repoLabel}**: ${f.error && f.error.message ? f.error.message : 'unknown error'}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+function oneLineSynthesis(perRepoResults, failures) {
+  const okCount = perRepoResults.length - failures.length;
+  return `${okCount}/${perRepoResults.length} succeeded${failures.length ? `, ${failures.length} failed` : ''}`;
+}
+
+function truncateForSynth(s) {
+  if (!s) return '(empty)';
+  if (s.length <= 200) return s.replace(/\n+/g, ' ');
+  return s.slice(0, 200).replace(/\n+/g, ' ') + '…';
+}
+
+function renderArtifact({ runId, repos, userIntent, mode, modeNotes, perRepoResults, failures, synthesis, duration, isAgentDriven = false }) {
+  // ENH-034 — admonition immediately under the Mode header so anyone
+  // opening the artifact sees the CLI-degradation caveat before reading
+  // the synthesis. Skip on agent-driven `record()` runs — those carry
+  // a real LLM synthesis so the caveat would mislead.
+  const modeAdmonition = isAgentDriven
+    ? []
+    : [
+        '> [!NOTE]',
+        '> **CLI / in-process mode — keyword summaries only.**',
+        '> Invoke /dispatch via an agent slash command for true LLM synthesis.',
+        '',
+      ];
+  const lines = [
+    `# dispatch-${runId}`,
+    '',
+    `**User intent:** ${userIntent}`,
+    `**Mode:** ${mode}${modeNotes.length ? ` (${modeNotes.join('; ')})` : ''}`,
+    `**Repos (${repos.length}):**`,
+    ...repos.map((r) => `  - ${r}`),
+    `**Duration:** ${duration}ms`,
+    '',
+    ...modeAdmonition,
+    '## Synthesis',
+    '',
+    synthesis || '(no synthesis recorded)',
+    '',
+    '## Per-repo results',
+    '',
+  ];
+  for (const r of perRepoResults) {
+    const repoLabel = path.basename(r.repo);
+    lines.push(`### ${repoLabel}`, '');
+    lines.push(`- **Prompt:** ${r.prompt || '(n/a)'}`);
+    lines.push(`- **Duration:** ${r.duration != null ? r.duration : 'n/a'}ms`);
+    if (r.error) {
+      lines.push(`- **Error:** ${r.error.message}`);
+    } else {
+      lines.push(`- **Files read:** ${(r.filesRead || []).length}`);
+      lines.push('', '```', r.summary || '(empty)', '```');
+    }
+    if (r.findings && r.findings.length) {
+      lines.push('', 'Findings:');
+      for (const f of r.findings) {
+        lines.push(`  - **${f.kind || 'note'}**: ${f.title}`);
+      }
+    }
+    lines.push('');
+  }
+  if (failures.length) {
+    lines.push('## Failure manifest', '');
+    for (const f of failures) {
+      lines.push(`- ${path.basename(f.repo)}: ${f.error && f.error.message ? f.error.message : 'unknown'}`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  dispatch,
+  record,
+  CLI_MODE_NOTICE,
+  // exported for tests:
+  tailorPrompt,
+  synthesizeInProcess,
+};

package/core/orchestration/events.js

@@ -0,0 +1,197 @@
+'use strict';
+
+// Typed event emitter for orchestration primitives.
+//
+// Every primitive (scout, dispatch, handoff) emits structured events as
+// it runs. Two default subscribers:
+//   - renderer: prints `▸ <message>` lines to stdout (chat surface).
+//   - persister: appends the same events to the ecosystem session log
+//     (durable audit surface).
+//
+// One source, two surfaces — keeps live narration and the persistent
+// log in lockstep. New event types are listed in EVENT_KINDS; adding
+// one requires updating that list AND any rendering / persistence code
+// that depends on the kind.
+
+const EVENT_KINDS = Object.freeze([
+  // Primitive lifecycle
+  'started',
+  'finished',
+  'failed',
+
+  // Step-level progress (file reads, sub-agent spawns, etc.)
+  'step',
+  'note',           // free-form info that should land in chat + log
+
+  // Sub-agent lifecycle (used by dispatch)
+  'subagent-started',
+  'subagent-finished',
+  'subagent-failed',
+
+  // Result-level events
+  'finding',        // emitted by scout/dispatch when a notable finding is identified
+  'synthesized',    // emitted by dispatch after synthesis completes
+]);
+
+function isValidKind(kind) {
+  return EVENT_KINDS.includes(kind);
+}
+
+/**
+ * Create a new event emitter for a single primitive invocation.
+ *
+ * @param {object} opts
+ * @param {string} opts.primitive   one of: 'scout' | 'dispatch' | 'handoff' | 'continue'
+ * @param {string} [opts.runId]     monotonic per-primitive run id (set later by run-artifact)
+ * @param {string} [opts.repo]      originating repo path
+ * @returns {{ emit: Function, on: Function, kinds: string[], context: object }}
+ */
+function createEmitter(opts = {}) {
+  const subscribers = [];
+  const context = { ...opts };
+
+  function emit(kind, payload = {}) {
+    if (!isValidKind(kind)) {
+      throw new Error(
+        `orchestration/events: unknown event kind "${kind}". ` +
+        `Valid kinds: ${EVENT_KINDS.join(', ')}`,
+      );
+    }
+    const event = {
+      kind,
+      timestamp: new Date().toISOString(),
+      primitive: context.primitive,
+      runId: context.runId,
+      repo: context.repo,
+      ...payload,
+    };
+    for (const subscriber of subscribers) {
+      try {
+        subscriber(event);
+      } catch (err) {
+        // Subscribers MUST NOT throw — but if one does, log and continue
+        // rather than letting it break the primitive.
+        process.stderr.write(
+          `orchestration/events: subscriber error: ${err.message}\n`,
+        );
+      }
+    }
+    return event;
+  }
+
+  function on(handler) {
+    if (typeof handler !== 'function') {
+      throw new TypeError('orchestration/events: subscriber must be a function');
+    }
+    subscribers.push(handler);
+    return () => {
+      const idx = subscribers.indexOf(handler);
+      if (idx >= 0) subscribers.splice(idx, 1);
+    };
+  }
+
+  return { emit, on, kinds: EVENT_KINDS, context };
+}
+
+/**
+ * Default renderer subscriber — prints `▸ <message>` lines to a stream
+ * (default: stdout). Mostly for the CLI doors; in-agent contexts
+ * synthesize their own rendering layer.
+ *
+ * @param {object} [opts]
+ * @param {NodeJS.WritableStream} [opts.stream]  default: process.stdout
+ * @param {boolean} [opts.silent]  if true, no output (useful for tests)
+ * @returns {Function} subscriber
+ */
+function createRenderer(opts = {}) {
+  const stream = opts.stream || process.stdout;
+  return function rendererSubscriber(event) {
+    if (opts.silent) return;
+    const line = renderEvent(event);
+    if (line) stream.write(line + '\n');
+  };
+}
+
+function renderEvent(event) {
+  switch (event.kind) {
+    case 'started':
+      return `▸ ${event.primitive}${event.repo ? ` ${event.repo}` : ''}${
+        event.message ? `: ${event.message}` : ''
+      }`;
+    case 'finished':
+      return `▸ ${event.primitive} done${event.duration != null ? ` (${event.duration}ms)` : ''}${
+        event.runArtifactPath ? ` → ${event.runArtifactPath}` : ''
+      }`;
+    case 'failed':
+      return `▸ ${event.primitive} FAILED${event.error ? `: ${event.error}` : ''}`;
+    case 'step':
+      return `  ▸ ${event.message || ''}`;
+    case 'note':
+      return `  ▸ ${event.message || ''}`;
+    case 'subagent-started':
+      return `  ▸ ${event.repo}…`;
+    case 'subagent-finished':
+      return `  ▸ ${event.repo}… done${event.duration != null ? ` (${event.duration}ms)` : ''}`;
+    case 'subagent-failed':
+      return `  ▸ ${event.repo}… FAILED${event.error ? `: ${event.error}` : ''}`;
+    case 'finding':
+      return `  ▸ found: ${event.summary || event.message || ''}`;
+    case 'synthesized':
+      return event.message ? `▸ Synthesis\n${event.message}` : '▸ Synthesis';
+    default:
+      return null;
+  }
+}
+
+/**
+ * Default persister subscriber — appends events to the ecosystem
+ * session log. Uses the shared session-log writer (lock-aware) so we
+ * don't race with PostToolUse hook commits.
+ *
+ * @param {object} opts
+ * @param {string} opts.ecosystemRoot   ecosystem root path
+ * @param {string} opts.memberId        member id of the originating repo
+ * @returns {Function} subscriber
+ */
+function createPersister(opts) {
+  const { appendLine } = require('./session-log');
+  return function persisterSubscriber(event) {
+    if (!opts || !opts.ecosystemRoot || !opts.memberId) return;
+    const line = persistEvent(event);
+    if (!line) return;
+    appendLine({
+      ecosystemRoot: opts.ecosystemRoot,
+      memberId: opts.memberId,
+      kind: event.primitive,
+      summary: line,
+      context: event.runId ? `run-${event.runId}` : '',
+    });
+  };
+}
+
+function persistEvent(event) {
+  // Only persist primitive-level lifecycle events; step-level events
+  // would flood the session log.
+  switch (event.kind) {
+    case 'started':
+      return `${event.primitive} ${event.repo || ''}${event.message ? `: ${event.message}` : ''}`.trim();
+    case 'finished':
+      return `${event.primitive} done${event.runArtifactPath ? ` → ${event.runArtifactPath}` : ''}`;
+    case 'failed':
+      return `${event.primitive} FAILED${event.error ? `: ${event.error}` : ''}`;
+    case 'synthesized':
+      return event.summary ? `${event.primitive} synthesis: ${event.summary}` : null;
+    default:
+      return null;
+  }
+}
+
+module.exports = {
+  EVENT_KINDS,
+  isValidKind,
+  createEmitter,
+  createRenderer,
+  createPersister,
+  renderEvent,    // exported for tests
+  persistEvent,   // exported for tests
+};