@khoavu882/doflow 0.0.0-stage → 2.0.0-beta.4

package/src/runtime/decision-register.js

@@ -0,0 +1,493 @@
+'use strict';
+
+// TypeScript migration (agent-docs/BRIEF_GOAL_DOFLOW.md): run directly by Node native type-stripping.
+
+/**
+ * Decision register (IC-001 to IC-009). One `decisions/register.json` per feature folder holds
+ * every decision taken during the feature's chain; `decisions.md` (live view, one row per live
+ * topic) and `decisions/archive.md` (every decision with its rationale) are rendered from it and
+ * never edited by hand. The register is owned by this module: no caller sets a decision's
+ * `decidedBy`, `date`, `at`, `id` or `status`.
+ *
+ * Concurrency: every write holds the lock `task-state.js` already provides for its own files, so
+ * two handoffs writing at once serialize rather than allocate the same id. Files are written with
+ * a temp file and a rename; the register is written before the views, so a crash leaves a register
+ * that the next write re-renders into agreement.
+ */
+
+const nodeFs = require('node:fs');
+const path = require('node:path');
+const { acquireLock } = require('./task-state.js');
+const { resolveActiveFeature } = require('./feature-resolve.js');
+const { compactHistory } = require('./history-compactor.js');
+const { finishRuntime, usageError } = require('./cli-result.js');
+
+const REGISTER_VERSION = 1;
+const TOPIC_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const TOPIC_MAX = 48;
+const STATEMENT_MAX = 280;
+const REF_RE = /^[A-Za-z]+-?[0-9]+$/;
+const DEC_RE = /^DEC-[0-9]{3,}$/;
+const STAGES = ['discovery', 'design', 'planning', 'implementation', 'verification', 'review'];
+/** Channel -> who decided. The caller names the channel; `decidedBy` follows from it. */
+const CHANNEL_DECIDED_BY                         = { question: 'user', gate: 'user', prompt: 'user', default: 'agent', resolution: 'agent' };
+const ITEM_KEYS = ['topic', 'statement', 'channel', 'stage', 'rationale', 'supersedes', 'refs', 'source'];
+const REQUIRED_KEYS = ['topic', 'statement', 'channel', 'stage', 'rationale'];
+
+/** Line breaks Markdown renderers and editors treat as a break, not just \r and \n. */
+const LINE_BREAK = /[\r\n\u2028\u2029\u0085]/;
+
+const GENERATED_NOTE = 'Generated from `decisions/register.json` by `doflow-run decision`. Do not edit this file.';
+
+/** A caller mistake (exit 2). */
+class DecisionUsageError extends Error {}
+
+/** A finding the caller must act on (exit 1). */
+class DecisionFinding extends Error {
+  finding        ;
+
+  constructor(finding        , message        ) {
+    super(message);
+    this.finding = finding;
+  }
+}
+
+// ── paths ──────────────────────────────────────────────────────────────────────────────────────
+
+function registerFile(featureDir        )         { return path.join(featureDir, 'decisions', 'register.json'); }
+function liveViewFile(featureDir        )         { return path.join(featureDir, 'decisions.md'); }
+function archiveFile(featureDir        )         { return path.join(featureDir, 'decisions', 'archive.md'); }
+
+// ── register io ────────────────────────────────────────────────────────────────────────────────
+
+function readRegister(featureDir        , fsImpl      = nodeFs)      {
+  const file = registerFile(featureDir);
+  if (!fsImpl.existsSync(file)) return null;
+  let data     ;
+  try {
+    data = JSON.parse(fsImpl.readFileSync(file, 'utf8'));
+  } catch (error     ) {
+    throw new DecisionUsageError(`${file} is not valid JSON (${error.message}). The register is written atomically, so a torn file means outside interference; restore it from version control.`);
+  }
+  if (!data || data.version !== REGISTER_VERSION || !Array.isArray(data.decisions) || !Number.isInteger(data.nextId)) {
+    throw new DecisionUsageError(`${file} is not a version ${REGISTER_VERSION} decision register; refusing to guess at its shape.`);
+  }
+  return data;
+}
+
+function writeAtomic(fsImpl     , file        , content        )       {
+  fsImpl.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  try {
+    fsImpl.writeFileSync(tmp, content, 'utf8');
+    fsImpl.renameSync(tmp, file);
+  } catch (error     ) {
+    try { fsImpl.rmSync(tmp, { force: true }); } catch { /* nothing to clean */ }
+    throw error;
+  }
+}
+
+/** Writes only when the content differs, so re-rendering an unchanged view is a no-op. */
+function writeIfChanged(fsImpl     , file        , content        )       {
+  if (fsImpl.existsSync(file) && fsImpl.readFileSync(file, 'utf8') === content) return;
+  writeAtomic(fsImpl, file, content);
+}
+
+function writeRegister(fsImpl     , featureDir        , register     )       {
+  writeAtomic(fsImpl, registerFile(featureDir), `${JSON.stringify(register, null, 2)}\n`);
+}
+
+function renderViews(fsImpl     , featureDir        , register     )       {
+  writeIfChanged(fsImpl, liveViewFile(featureDir), renderLiveView(register));
+  writeIfChanged(fsImpl, archiveFile(featureDir), renderArchive(register));
+}
+
+// ── ordering and ids ───────────────────────────────────────────────────────────────────────────
+
+function idNumber(id        )         { return Number(id.slice(4)); }
+function formatId(n        )         { return `DEC-${String(n).padStart(3, '0')}`; }
+function byId(a     , b     )         { return idNumber(a.id) - idNumber(b.id); }
+function byTopic(a     , b     )         { return a.topic < b.topic ? -1 : a.topic > b.topic ? 1 : idNumber(a.id) - idNumber(b.id); }
+function liveOf(register     )        { return register.decisions.filter((d     ) => d.status === 'live'); }
+
+// ── renderers ──────────────────────────────────────────────────────────────────────────────────
+
+/** `\` is escaped first, so a statement ending in one cannot escape the pipe that closes the cell
+ * (IC-007); `|` would end the cell; `<` could open an HTML comment that hides every later row. */
+function cell(text     )         { return String(text).replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/</g, '\\<'); }
+
+/** Archive text is read by people and agents, never as HTML: `<` is escaped so `<!--` cannot hide later entries. */
+function plain(text     )         { return String(text).replace(/</g, '\\<'); }
+
+/**
+ * A one-line rationale reads inline. A longer one goes in a blockquote under the bullet, every line
+ * prefixed, so no line of it can start a heading or pose as one of the entry's own bullets.
+ */
+function rationaleLines(rationale     )           {
+  const parts = plain(rationale).split(/\r\n|[\n\r\u2028\u2029\u0085]/);
+  if (parts.length === 1) return [`- **Rationale:** ${parts[0]}`];
+  return ['- **Rationale:**', ...parts.map((l        ) => (l === '' ? '  >' : `  > ${l}`))];
+}
+
+/** IC-007. Size depends on the number of live topics, never on how many decisions were made. */
+function renderLiveView(register     )         {
+  const live = liveOf(register).sort(byTopic);
+  const out = [
+    `# Decisions: ${register.slug}`,
+    '',
+    `> ${GENERATED_NOTE} Superseded decisions and rationale are in \`decisions/archive.md\`.`,
+    '',
+  ];
+  if (live.length === 0) {
+    out.push('No live decisions yet.');
+  } else {
+    out.push('| ID | Topic | Decision | By | Stage | Date |', '|---|---|---|---|---|---|');
+    for (const d of live) {
+      out.push(`| ${d.id} | ${cell(d.topic)} | ${cell(d.statement)} | ${d.decidedBy} | ${d.stage} | ${d.date} |`);
+    }
+  }
+  return `${out.join('\n')}\n`;
+}
+
+/** IC-008. One entry per decision, by id; superseded entries stay with their rationale. */
+function renderArchive(register     )         {
+  const out = [`# Decision archive: ${register.slug}`, '', `> ${GENERATED_NOTE}`];
+  for (const d of [...register.decisions].sort(byId)) {
+    out.push('', `### ${d.id}: ${d.topic}`, '');
+    out.push(`- **Status:** ${d.status === 'live' ? 'Live' : `Superseded → ${d.supersededBy}`}`);
+    out.push(`- **Decision:** ${plain(d.statement)}`);
+    out.push(`- **By:** ${d.decidedBy} (${d.channel}) · **Stage:** ${d.stage} · **Date:** ${d.date}`);
+    if (d.supersedes.length) out.push(`- **Supersedes:** ${d.supersedes.join(', ')}`);
+    if (d.refs.length) out.push(`- **Refs:** ${d.refs.join(', ')}`);
+    if (d.source) out.push(`- **Source:** ${plain(d.source)}`);
+    out.push(...rationaleLines(d.rationale));
+  }
+  return `${out.join('\n')}\n`;
+}
+
+// ── item validation ────────────────────────────────────────────────────────────────────────────
+
+function toList(value     , what        , label        )           {
+  if (value === undefined || value === null || value === '') return [];
+  let list       ;
+  if (Array.isArray(value)) list = value;
+  else if (typeof value === 'string') list = value.split(',');
+  else throw new DecisionUsageError(`${label}: ${what} must be an array of strings`);
+  const out           = [];
+  for (const entry of list) {
+    if (typeof entry !== 'string') throw new DecisionUsageError(`${label}: ${what} must be an array of strings`);
+    const trimmed = entry.trim();
+    if (trimmed) out.push(trimmed);
+  }
+  return out;
+}
+
+/** Validates one add item against IC-003's field rules. Throws DecisionUsageError. */
+function normalizeItem(raw     , label        )      {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new DecisionUsageError(`${label}: must be an object`);
+  const extra = Object.keys(raw).filter((k        ) => !ITEM_KEYS.includes(k));
+  if (extra.length) {
+    throw new DecisionUsageError(`${label}: unknown key${extra.length > 1 ? 's' : ''} ${extra.map((k        ) => `'${k}'`).join(', ')}. Allowed: ${ITEM_KEYS.join(', ')} (decidedBy is set by the runtime from the channel)`);
+  }
+  for (const key of REQUIRED_KEYS) {
+    if (typeof raw[key] !== 'string' || raw[key].trim() === '') throw new DecisionUsageError(`${label}: '${key}' is required`);
+  }
+  const topic = raw.topic.trim();
+  if (LINE_BREAK.test(topic)) throw new DecisionUsageError(`${label}: topic must be one line`);
+  if (topic.length > TOPIC_MAX || !TOPIC_RE.test(topic)) {
+    throw new DecisionUsageError(`${label}: topic '${topic}' must be lowercase words joined by hyphens, at most ${TOPIC_MAX} characters`);
+  }
+  const statement = raw.statement.trim();
+  if (LINE_BREAK.test(statement)) throw new DecisionUsageError(`${label}: statement must be one line`);
+  if (statement.length > STATEMENT_MAX) {
+    throw new DecisionUsageError(`${label}: statement is ${statement.length} characters; the limit is ${STATEMENT_MAX}. Put the reasoning in --rationale`);
+  }
+  const channel = raw.channel.trim();
+  if (!Object.prototype.hasOwnProperty.call(CHANNEL_DECIDED_BY, channel)) {
+    throw new DecisionUsageError(`${label}: channel '${channel}' must be one of ${Object.keys(CHANNEL_DECIDED_BY).join(', ')}`);
+  }
+  const stage = raw.stage.trim();
+  if (!STAGES.includes(stage)) throw new DecisionUsageError(`${label}: stage '${stage}' must be one of ${STAGES.join(', ')}`);
+  const supersedes = toList(raw.supersedes, 'supersedes', label);
+  for (const id of supersedes) {
+    if (!DEC_RE.test(id)) throw new DecisionUsageError(`${label}: supersedes entry '${id}' is not a DEC-### id`);
+  }
+  if (new Set(supersedes).size !== supersedes.length) throw new DecisionUsageError(`${label}: supersedes names an id twice`);
+  const refs = toList(raw.refs, 'refs', label);
+  for (const ref of refs) {
+    if (!REF_RE.test(ref)) throw new DecisionUsageError(`${label}: refs entry '${ref}' does not look like an id (for example FR-001)`);
+  }
+  let source = '';
+  if (raw.source !== undefined && raw.source !== null) {
+    if (typeof raw.source !== 'string' || LINE_BREAK.test(raw.source)) throw new DecisionUsageError(`${label}: source must be a one-line string`);
+    source = raw.source.trim();
+  }
+  return { topic, statement, channel, stage, rationale: raw.rationale.trim(), supersedes, refs, source };
+}
+
+/** Normalizes the batch (`--batch` contents) or the single item, refusing everything on one fault. */
+function normalizeItems(items     )        {
+  if (!Array.isArray(items)) throw new DecisionUsageError('a batch must be a JSON array of decision objects');
+  const normalized = items.map((raw     , i        ) => normalizeItem(raw, `item ${i + 1}`));
+  const seen = new Set();
+  for (const item of normalized) {
+    if (seen.has(item.topic)) throw new DecisionUsageError(`topic '${item.topic}' appears more than once in the batch; a topic takes one decision per batch`);
+    seen.add(item.topic);
+  }
+  return normalized;
+}
+
+// ── actions ────────────────────────────────────────────────────────────────────────────────────
+
+function summary({ action, slug, featureDir }                                                      )                                                       { return { action, slug, featureDir }; }
+
+const FOLDER_ARTIFACTS = ['intention/requirement.md', 'requirement.md', 'design/design.md', 'design.md', 'plan.md'];
+
+/** IC-002. */
+function initRegister({ featureDir, slug, fsImpl = nodeFs }     )      {
+  const base = summary({ action: 'init', slug, featureDir });
+  if (fsImpl.existsSync(registerFile(featureDir))) return { ...base, created: false };
+  const present = FOLDER_ARTIFACTS.filter((rel        ) => fsImpl.existsSync(path.join(featureDir, rel)));
+  if (present.length) {
+    return {
+      ...base,
+      created: false,
+      finding: 'predates-register',
+      message: `${featureDir} already holds ${present.join(', ')} and no decision register; only a folder do-brainstorm is creating gets one, so it was left unchanged`,
+    };
+  }
+  fsImpl.mkdirSync(path.join(featureDir, 'decisions'), { recursive: true });
+  const release = acquireLock(fsImpl, registerFile(featureDir));
+  try {
+    if (fsImpl.existsSync(registerFile(featureDir))) return { ...base, created: false };
+    const register = { version: REGISTER_VERSION, slug, nextId: 1, decisions: [] };
+    writeRegister(fsImpl, featureDir, register);
+    renderViews(fsImpl, featureDir, register);
+  } finally {
+    release();
+  }
+  return { ...base, created: true };
+}
+
+/**
+ * IC-003. All-or-nothing: the whole batch is validated and simulated against the register first,
+ * and nothing is written unless every item passes.
+ */
+function addDecisions({ featureDir, slug, items, now = new Date(), fsImpl = nodeFs }     )      {
+  const normalized = normalizeItems(items);
+  const base = summary({ action: 'add', slug, featureDir });
+  if (!fsImpl.existsSync(registerFile(featureDir))) {
+    return { ...base, finding: 'no-register', message: `${featureDir} has no decisions/register.json; run \`decision --action init\` when the feature is created` };
+  }
+  // Nothing to register: answer without taking the lock or rewriting a byte.
+  if (normalized.length === 0) return { ...base, added: [], superseded: [] };
+  const release = acquireLock(fsImpl, registerFile(featureDir));
+  try {
+    const register = readRegister(featureDir, fsImpl);
+    const iso = now.toISOString();
+    const added        = [];
+    const superseded        = [];
+    let conflict      = null;
+    let nextId = register.nextId;
+    for (const item of normalized) {
+      for (const id of item.supersedes) {
+        const target = register.decisions.find((d     ) => d.id === id);
+        if (!target) throw new DecisionUsageError(`topic '${item.topic}': supersedes ${id}, which is not a decision in this register`);
+        if (target.status !== 'live') throw new DecisionUsageError(`topic '${item.topic}': supersedes ${id}, which is not live (it was superseded by ${target.supersededBy})`);
+      }
+      const unnamed = register.decisions.find((d     ) => d.status === 'live' && d.topic === item.topic && !item.supersedes.includes(d.id));
+      if (unnamed && !conflict) {
+        conflict = { finding: 'topic-conflict', message: `topic '${item.topic}' already has live decision ${unnamed.id}; name it in supersedes to replace it. Nothing was written` };
+      }
+      const id = formatId(nextId);
+      nextId += 1;
+      for (const old of item.supersedes) {
+        const target = register.decisions.find((d     ) => d.id === old);
+        target.status = 'superseded';
+        target.supersededBy = id;
+        superseded.push({ id: old, by: id });
+      }
+      register.decisions.push({
+        id,
+        topic: item.topic,
+        statement: item.statement,
+        decidedBy: CHANNEL_DECIDED_BY[item.channel],
+        channel: item.channel,
+        stage: item.stage,
+        date: iso.slice(0, 10),
+        at: iso,
+        status: 'live',
+        supersedes: item.supersedes,
+        supersededBy: null,
+        refs: item.refs,
+        source: item.source,
+        rationale: item.rationale,
+      });
+      added.push({ id, topic: item.topic });
+    }
+    if (conflict) return { ...base, ...conflict };
+    register.nextId = nextId;
+    writeRegister(fsImpl, featureDir, register);
+    renderViews(fsImpl, featureDir, register);
+    return { ...base, added, superseded };
+  } finally {
+    release();
+  }
+}
+
+/** IC-004. */
+function listDecisions({ featureDir, slug, all = false, fsImpl = nodeFs }     )      {
+  const base = summary({ action: 'list', slug, featureDir });
+  const register = readRegister(featureDir, fsImpl);
+  if (!register) return { ...base, finding: 'no-register', message: `${featureDir} has no decisions/register.json` };
+  const decisions = all ? [...register.decisions].sort(byId) : liveOf(register).sort(byTopic);
+  return { ...base, decisions };
+}
+
+/** IC-005: compaction plus the view re-render, under the register lock `compactHistory` itself lacks. */
+function compactDecisions({ featureDir, slug, repoRoot, paths, now = new Date(), fsImpl = nodeFs }     )      {
+  const base = summary({ action: 'compact', slug, featureDir });
+  if (!fsImpl.existsSync(registerFile(featureDir))) {
+    return { ...base, finding: 'no-register', message: `${featureDir} has no decisions/register.json; nothing was touched` };
+  }
+  const release = acquireLock(fsImpl, registerFile(featureDir));
+  try {
+    const register = readRegister(featureDir, fsImpl);
+    const result = compactHistory({ repoRoot, featureDir, paths, date: now.toISOString().slice(0, 10), fsImpl });
+    // The views are re-rendered when anything moved, including in a partial run: the artifacts
+    // that did compact are changed whatever happened to the others.
+    if (result.moved.length) renderViews(fsImpl, featureDir, register);
+    if (result.failed.length) {
+      return {
+        ...base, status: result.status, finding: 'compaction-failed',
+        message: result.failed.map((f     ) => f.message).join('; '),
+        artifact: result.failed[0].path, moved: result.moved, failed: result.failed,
+      };
+    }
+    return { ...base, status: result.status, moved: result.moved, failed: [] };
+  } finally {
+    release();
+  }
+}
+
+// ── verb handler ───────────────────────────────────────────────────────────────────────────────
+
+const VALID_ACTIONS = ['init', 'add', 'list', 'compact'];
+
+function readBatchFile(batchPath        , fsImpl     )      {
+  let text        ;
+  try {
+    // `-` is stdin, as for the evidence verb.
+    text = batchPath === '-' ? fsImpl.readFileSync(0, 'utf8') : fsImpl.readFileSync(path.resolve(batchPath), 'utf8');
+  } catch (error     ) {
+    throw new DecisionUsageError(`cannot read --batch ${batchPath}: ${error.message}`);
+  }
+  try {
+    return JSON.parse(text);
+  } catch (error     ) {
+    throw new DecisionUsageError(`--batch ${batchPath} is not valid JSON: ${error.message}`);
+  }
+}
+
+/**
+ * Runs one action and returns its result without printing, so other verbs (the handoff's
+ * compaction) can call it directly.
+ *
+ * @param {Object} options
+ * @param {string} options.action init | add | list | status | compact
+ * @param {string} options.projectRoot directory the feature is resolved from
+ * @param {string|null} [options.slug] explicit feature override
+ * @param {Object} [options.flags] add: topic, statement, channel, stage, rationale, supersedes,
+ *   refs, source, batch (path); list: all
+ * @returns {{exitCode:number, result?:Object, usage?:string}}
+ */
+function runDecision({ action = 'list', projectRoot, slug = null, flags = {}, now = new Date(), fsImpl = nodeFs }     )                                                     {
+  const act = action === 'status' ? 'list' : action;
+  let resolved      = null;
+  try {
+    if (!VALID_ACTIONS.includes(act)) throw new DecisionUsageError(`unknown --action '${action}'. Valid: ${VALID_ACTIONS.join(', ')}`);
+    const feature = resolveActiveFeature({ projectRoot, slug });
+    if (feature.error) throw new DecisionUsageError(feature.message);
+    resolved = { featureDir: feature.featureDir, slug: feature.paths.feature_slug };
+    let result     ;
+    if (act === 'init') {
+      result = initRegister({ ...resolved, fsImpl });
+    } else if (act === 'list') {
+      result = listDecisions({ ...resolved, all: Boolean(flags.all), fsImpl });
+    } else if (act === 'compact') {
+      result = compactDecisions({ ...resolved, repoRoot: feature.repoRoot, paths: feature.paths, now, fsImpl });
+    } else {
+      let items     ;
+      if (flags.batch) {
+        const named = ITEM_KEYS.filter((k) => flags[k] !== undefined);
+        if (named.length) throw new DecisionUsageError(`--batch cannot be combined with --${named[0]}`);
+        items = readBatchFile(flags.batch, fsImpl);
+      } else {
+        const single                      = {};
+        for (const key of ITEM_KEYS) if (flags[key] !== undefined) single[key] = flags[key];
+        for (const key of REQUIRED_KEYS) {
+          if (single[key] === undefined) throw new DecisionUsageError(`--${key} is required for --action add (or pass --batch <file.json>)`);
+        }
+        items = [single];
+      }
+      result = addDecisions({ ...resolved, items, now, fsImpl });
+    }
+    return { exitCode: result.finding ? 1 : 0, result };
+  } catch (error     ) {
+    if (error instanceof DecisionUsageError) return { exitCode: 2, usage: error.message };
+    // Another writer holds the register lock: a condition to retry, not a mistake in the call.
+    if (resolved && error && /^Could not lock/.test(error.message || '')) {
+      return { exitCode: 1, result: { action: act, slug: resolved.slug, featureDir: resolved.featureDir, finding: 'register-locked', message: error.message } };
+    }
+    throw error;
+  }
+}
+
+function humanLines(result     )           {
+  const lines           = [];
+  if (result.finding) lines.push(`${result.finding}: ${result.message}`);
+  if (result.action === 'init' && !result.finding) {
+    lines.push(result.created ? `created ${path.join(result.featureDir, 'decisions', 'register.json')}` : 'register already exists; nothing written');
+  }
+  for (const a of (result.added || [])         ) lines.push(`added ${a.id} (${a.topic})`);
+  for (const s of (result.superseded || [])         ) lines.push(`superseded ${s.id} by ${s.by}`);
+  if (result.action === 'list' && !result.finding) {
+    if (result.decisions.length === 0) lines.push('No decisions.');
+    for (const d of result.decisions         ) lines.push(`${d.id}  ${d.topic}  ${d.statement}  [${d.decidedBy}, ${d.stage}${d.status === 'live' ? '' : `, superseded by ${d.supersededBy}`}]`);
+  }
+  if (result.action === 'compact') {
+    if (result.status === 'unchanged') lines.push('nothing to compact');
+    for (const m of (result.moved || [])         ) lines.push(`moved ${m.lines} line${m.lines === 1 ? '' : 's'} from ${m.path} to ${m.archive}`);
+  }
+  return lines;
+}
+
+/**
+ * `decision` verb. Exit 0 = answered, 1 = a finding the caller must act on, 2 = usage.
+ * `--json` prints the result object unmodified.
+ */
+function handleDecisionCommand({ action = 'list', projectRoot, slug = null, flags = {}, json = false }      = {})         {
+  const run = runDecision({ action, projectRoot: projectRoot || process.cwd(), slug, flags });
+  if (run.usage !== undefined) return usageError('decision', run.usage, json);
+  if (json) console.log(JSON.stringify(run.result, null, 2));
+  else for (const line of humanLines(run.result)) console.log(line);
+  return finishRuntime(run.exitCode);
+}
+
+module.exports = {
+  handleDecisionCommand,
+  runDecision,
+  initRegister,
+  addDecisions,
+  listDecisions,
+  compactDecisions,
+  readRegister,
+  renderLiveView,
+  renderArchive,
+  registerFile,
+  liveViewFile,
+  archiveFile,
+  STAGES,
+  CHANNEL_DECIDED_BY,
+  STATEMENT_MAX,
+};