@druumen/sessions-db 0.1.0

package/cli/format.mjs

@@ -0,0 +1,277 @@
+/**
+ * Output formatting helpers for sessions-db CLI subcommands.
+ *
+ * Supports three output styles:
+ *  - `formatSessionTable` — fixed-column ASCII table for `find` (default).
+ *  - `formatTree` — hub-spoke ASCII tree rooted at a stable_id (depth-capped
+ *    to defend against circular parent_session_id chains).
+ *  - `formatJSON` — pretty-printed JSON.stringify with stable key order.
+ *
+ * No external deps — color is pure ANSI escape codes, gated by a TTY check
+ * the CLI entry can override with NO_COLOR=1 / --no-color.
+ *
+ * The depth cap matters: P3 identity surfaces parent_candidates as hub-spoke
+ * hints, but the actual `parent_session_id` is set by `link-parent`. A user
+ * could (accidentally or maliciously) create A→B→A. We cap recursion at
+ * MAX_TREE_DEPTH and surface a `(circular reference)` marker so the operator
+ * can fix it via `link-parent --remove`.
+ */
+
+const MAX_TREE_DEPTH = 32;
+
+// ANSI escape codes (zero-dep). Disabled when NO_COLOR is set or stdout is
+// not a TTY (caller's responsibility — pass useColor=false to bypass).
+const ANSI = Object.freeze({
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  gray: '\x1b[90m',
+});
+
+function paint(text, color, useColor) {
+  if (!useColor || !color) return text;
+  return color + text + ANSI.reset;
+}
+
+/**
+ * Truncate a stable_id to the first 16 chars for display
+ * (sess_<8>-<4>... is enough for visual disambiguation).
+ *
+ * Exported so tests can verify identical truncation rules across handlers.
+ */
+export function truncateStableId(id) {
+  if (typeof id !== 'string') return '<invalid>';
+  if (id.length <= 22) return id;
+  return id.slice(0, 22);
+}
+
+/**
+ * Human-friendly relative time ("3 hours ago", "2 days ago", "just now").
+ *
+ * Exported because both find (table cell) and tree (state suffix) want the
+ * same relative-time vocabulary so ops staff don't see "3h" in one place and
+ * "3 hours ago" in another.
+ *
+ * @param {string|null|undefined} iso - ISO 8601 timestamp
+ * @param {number} [now=Date.now()] - injectable for deterministic tests
+ */
+export function relTime(iso, now = Date.now()) {
+  if (!iso || typeof iso !== 'string') return '-';
+  const t = Date.parse(iso);
+  if (!Number.isFinite(t)) return '-';
+  const deltaMs = now - t;
+  if (deltaMs < 0) return 'in the future';
+  const sec = Math.floor(deltaMs / 1000);
+  if (sec < 5) return 'just now';
+  if (sec < 60) return `${sec}s ago`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m ago`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr}h ago`;
+  const day = Math.floor(hr / 24);
+  if (day < 30) return `${day}d ago`;
+  const mo = Math.floor(day / 30);
+  if (mo < 12) return `${mo}mo ago`;
+  const yr = Math.floor(day / 365);
+  return `${yr}y ago`;
+}
+
+/**
+ * Format a list of session records as a fixed-column ASCII table.
+ *
+ * @param {Array<object>} sessions
+ * @param {{ useColor?: boolean, now?: number }} [opts]
+ * @returns {string}
+ */
+export function formatSessionTable(sessions, opts = {}) {
+  const useColor = opts.useColor === true;
+  const now = typeof opts.now === 'number' ? opts.now : Date.now();
+
+  if (!Array.isArray(sessions) || sessions.length === 0) {
+    return '(no sessions matched)\n';
+  }
+
+  const rows = sessions.map((s) => ({
+    stable: truncateStableId(s.stable_id || ''),
+    alias: s.alias || '-',
+    state: s.activity_state || '-',
+    outcome: s.outcome || '-',
+    last: relTime(s.last_progress_at, now),
+    branch: truncBranch(s.branch_current || s.branch_at_start),
+    cwd: truncCwd(s.cwd || s.worktree_path_observed),
+  }));
+
+  const headers = {
+    stable: 'stable_id',
+    alias: 'alias',
+    state: 'state',
+    outcome: 'outcome',
+    last: 'last_progress',
+    branch: 'branch',
+    cwd: 'cwd',
+  };
+
+  const widths = {
+    stable: Math.max(headers.stable.length, ...rows.map((r) => r.stable.length)),
+    alias: Math.max(headers.alias.length, ...rows.map((r) => r.alias.length)),
+    state: Math.max(headers.state.length, ...rows.map((r) => r.state.length)),
+    outcome: Math.max(headers.outcome.length, ...rows.map((r) => r.outcome.length)),
+    last: Math.max(headers.last.length, ...rows.map((r) => r.last.length)),
+    branch: Math.max(headers.branch.length, ...rows.map((r) => r.branch.length)),
+    cwd: Math.max(headers.cwd.length, ...rows.map((r) => r.cwd.length)),
+  };
+
+  const fmt = (r, isHeader = false) => {
+    const cells = [
+      r.stable.padEnd(widths.stable),
+      r.alias.padEnd(widths.alias),
+      paintState(r.state, useColor && !isHeader, widths.state),
+      paintOutcome(r.outcome, useColor && !isHeader, widths.outcome),
+      r.last.padEnd(widths.last),
+      r.branch.padEnd(widths.branch),
+      r.cwd.padEnd(widths.cwd),
+    ];
+    return cells.join('  ').trimEnd();
+  };
+
+  const lines = [];
+  lines.push(paint(fmt(headers, true), useColor ? ANSI.bold : null, useColor));
+  for (const r of rows) lines.push(fmt(r));
+  return lines.join('\n') + '\n';
+}
+
+function paintState(state, useColor, width) {
+  const padded = state.padEnd(width);
+  if (!useColor) return padded;
+  if (state === 'active') return paint(padded, ANSI.green, true);
+  if (state === 'idle') return paint(padded, ANSI.yellow, true);
+  if (state === 'archived') return paint(padded, ANSI.gray, true);
+  return padded;
+}
+
+function paintOutcome(outcome, useColor, width) {
+  const padded = outcome.padEnd(width);
+  if (!useColor) return padded;
+  if (outcome === 'open') return paint(padded, ANSI.cyan, true);
+  if (outcome === 'done' || outcome === 'merged') return paint(padded, ANSI.green, true);
+  if (outcome === 'blocked') return paint(padded, ANSI.red, true);
+  return padded;
+}
+
+function truncBranch(branch) {
+  if (!branch) return '-';
+  if (branch.length <= 32) return branch;
+  return branch.slice(0, 29) + '...';
+}
+
+function truncCwd(cwd) {
+  if (!cwd) return '-';
+  if (cwd.length <= 40) return cwd;
+  // Keep the tail (most informative — the trailing dir reveals which
+  // worktree / project this is) and prefix with `…`.
+  return '...' + cwd.slice(-37);
+}
+
+/**
+ * Format a hub-spoke tree rooted at `rootStableId`.
+ *
+ * @param {string} rootStableId
+ * @param {object} projection
+ * @param {{ useColor?: boolean, now?: number }} [opts]
+ * @returns {string} ASCII tree text or an error sentinel string when root
+ *   does not exist (caller decides exit code).
+ */
+export function formatTree(rootStableId, projection, opts = {}) {
+  const useColor = opts.useColor === true;
+  const now = typeof opts.now === 'number' ? opts.now : Date.now();
+
+  const sessions = projection && projection.sessions ? projection.sessions : {};
+  if (!sessions[rootStableId]) {
+    return `error: stable_id not found: ${rootStableId}\n`;
+  }
+
+  // Build child index: parent_session_id → [child stable_ids]
+  const children = new Map();
+  for (const [sid, s] of Object.entries(sessions)) {
+    const parent = s && typeof s.parent_session_id === 'string' ? s.parent_session_id : null;
+    if (parent && parent !== sid) {
+      if (!children.has(parent)) children.set(parent, []);
+      children.get(parent).push(sid);
+    }
+  }
+  // Sort children by created_at ASC for stable, deterministic output.
+  for (const arr of children.values()) {
+    arr.sort((a, b) => {
+      const ca = sessions[a] && sessions[a].created_at;
+      const cb = sessions[b] && sessions[b].created_at;
+      if (!ca && !cb) return 0;
+      if (!ca) return 1;
+      if (!cb) return -1;
+      return ca < cb ? -1 : ca > cb ? 1 : 0;
+    });
+  }
+
+  const lines = [];
+  const visited = new Set();
+
+  function nodeLabel(sid) {
+    const s = sessions[sid];
+    const idShort = truncateStableId(sid);
+    const alias = s && s.alias ? ` (${s.alias})` : '';
+    const stateLabel = s
+      ? `[${s.activity_state || '?'}/${s.outcome || '?'}]`
+      : '[?/?]';
+    const last = s ? ` ${relTime(s.last_progress_at, now)}` : '';
+    return `${paint(idShort, useColor ? ANSI.bold : null, useColor)}${alias} ${paint(stateLabel, useColor ? ANSI.dim : null, useColor)}${last}`;
+  }
+
+  function emit(sid, prefix, isLast, depth) {
+    const connector = depth === 0 ? '' : (isLast ? '└── ' : '├── ');
+    lines.push(prefix + connector + nodeLabel(sid));
+
+    if (depth >= MAX_TREE_DEPTH) {
+      lines.push(prefix + (isLast ? '    ' : '│   ') + paint('(max depth reached)', useColor ? ANSI.yellow : null, useColor));
+      return;
+    }
+
+    if (visited.has(sid)) {
+      lines.push(prefix + (isLast ? '    ' : '│   ') + paint('(circular reference)', useColor ? ANSI.red : null, useColor));
+      return;
+    }
+    visited.add(sid);
+
+    const kids = children.get(sid) || [];
+    const childPrefix = prefix + (depth === 0 ? '' : (isLast ? '    ' : '│   '));
+    for (let i = 0; i < kids.length; i++) {
+      emit(kids[i], childPrefix, i === kids.length - 1, depth + 1);
+    }
+  }
+
+  emit(rootStableId, '', true, 0);
+  return lines.join('\n') + '\n';
+}
+
+/**
+ * Format any value as JSON with stable 2-space indentation.
+ * @param {any} data
+ * @returns {string}
+ */
+export function formatJSON(data) {
+  return JSON.stringify(data, null, 2) + '\n';
+}
+
+/**
+ * Decide whether to enable ANSI color: TTY + NO_COLOR not set + --no-color
+ * not passed. Exposed so the CLI entry / handlers can call it once at the
+ * start and pass the boolean down to formatters.
+ */
+export function shouldUseColor(streamIsTTY, env = process.env, noColorFlag = false) {
+  if (noColorFlag) return false;
+  if (env && env.NO_COLOR && env.NO_COLOR.length > 0) return false;
+  return streamIsTTY === true;
+}

package/cli/link-parent.mjs

@@ -0,0 +1,133 @@
+/**
+ * `sessions-db link-parent <child> <parent>` — explicitly promote a hub-spoke
+ * parent relationship (sets `parent_session_id` on child).
+ * `sessions-db link-parent <child> --remove` — clear parent (set null).
+ *
+ * Day 3 refactor: all child / parent existence checks AND multi-hop cycle
+ * detection live in `lib/operations.setParent`. This handler is a thin
+ * wrapper that maps argv → operation call → exit code, so the cycle
+ * defense exists in exactly one place.
+ *
+ * Cycle defense semantics (preserved from earlier phases):
+ *   - direct: child === parent (1-cycle) — rejected
+ *   - multi-hop: walk the proposed parent's ancestor chain (via the
+ *     projection's parent_session_id pointers) and refuse if we ever
+ *     encounter `child` — that would close the loop, e.g. A→B already
+ *     exists and someone runs `link-parent B A` would form A→B→A.
+ *   - bound: MAX_PARENT_CHAIN_DEPTH = 50 in operations.mjs to defend
+ *     against a stale projection cycle.
+ */
+
+import { setParent } from '../lib/operations.mjs';
+import { ArgparseError, formatHelp, parseArgs } from './argparse.mjs';
+import { renderDryRun, reportResult, reportStableIdNotFound } from './_write-helpers.mjs';
+
+const SPEC = {
+  positional: [
+    { name: 'child', required: true },
+    { name: 'parent', required: false },
+  ],
+  flags: {
+    '--remove': { type: 'boolean' },
+    '--dry-run': { type: 'boolean' },
+    '--json': { type: 'boolean' },
+    '--root': { type: 'string' },
+    '--quiet': { type: 'boolean' },
+  },
+};
+
+export const HELP = formatHelp({
+  usage: 'sessions-db link-parent <child> <parent>  |  sessions-db link-parent <child> --remove',
+  summary: 'Promote a hub-spoke parent relationship (or clear it).',
+  flags: [
+    { name: '--remove',    desc: 'clear parent_session_id (set null)' },
+    { name: '--dry-run',   desc: 'print event but do not write' },
+    { name: '--json',      desc: 'JSON output' },
+    { name: '--root <p>',  desc: 'override storage root' },
+  ],
+  examples: [
+    'sessions-db link-parent sess_child-... sess_parent-...',
+    'sessions-db link-parent sess_child-... --remove',
+  ],
+});
+
+export async function run(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs(argv, SPEC);
+  } catch (err) {
+    if (err instanceof ArgparseError) {
+      process.stderr.write(`error: ${err.message}\n\n${HELP}`);
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+
+  if (parsed.helpRequested) {
+    process.stdout.write(HELP);
+    return;
+  }
+
+  const child = parsed.positional.child;
+  const parent = parsed.positional.parent;
+  const remove = parsed.flags['--remove'] === true;
+  const root = parsed.flags['--root'];
+  const dryRun = parsed.flags['--dry-run'] === true;
+  const json = parsed.flags['--json'] === true;
+  const quiet = parsed.flags['--quiet'] === true;
+
+  if (remove && parent !== undefined) {
+    process.stderr.write(`error: parent positional and --remove are mutually exclusive\n`);
+    process.exit(2);
+  }
+  if (!remove && parent === undefined) {
+    process.stderr.write(`error: provide a parent stable_id or --remove\n`);
+    process.exit(2);
+  }
+  if (!remove && parent === child) {
+    // Self-cycle would render as "(circular reference)" and serve no
+    // purpose. Operations.setParent rejects it too, but the historical
+    // CLI message is "cannot be the same stable_id" — preserve it.
+    process.stderr.write(`error: parent and child cannot be the same stable_id\n`);
+    process.exit(1);
+  }
+
+  if (dryRun) {
+    const payload = remove ? { parent_session_id: null } : { parent_session_id: parent };
+    renderDryRun({ op: 'parent_set', stableId: child, payload, json });
+    return;
+  }
+
+  const opts = root ? { root } : {};
+  const result = remove
+    ? await setParent({ childId: child, clear: true, ...opts })
+    : await setParent({ childId: child, parentId: parent, ...opts });
+
+  if (!result.ok && typeof result.error === 'string') {
+    if (result.error.startsWith('stable_id not found:')) {
+      if (!quiet) {
+        const code = reportStableIdNotFound(result.error);
+        process.exit(code);
+      }
+      process.exit(1);
+    }
+    if (result.error.startsWith('setParent: would create a cycle:')) {
+      if (!quiet) {
+        // Strip the `setParent: ` prefix to keep the historical CLI
+        // wording (`error: link-parent would create a cycle: ...`). The
+        // operation phrasing is `would create a cycle:` — match the test
+        // regex `/would create a cycle/` either way; we re-prefix so
+        // the operator-facing message names the CLI subcommand.
+        const tail = result.error.slice('setParent: '.length);
+        process.stderr.write(`error: link-parent ${tail}\n`);
+      }
+      process.exit(1);
+    }
+  }
+
+  const code = reportResult({
+    result, op: 'parent_set', stableId: child, json, quiet,
+    extra: remove ? { cleared: true } : { parent: parent },
+  });
+  if (code !== 0) process.exit(code);
+}

package/cli/link.mjs

@@ -0,0 +1,132 @@
+/**
+ * `sessions-db link <stable_id> --task X|--project X` — link a session to a
+ * task or project (additive). Pass `--remove` to dispatch a `session_unlink`
+ * event that removes the named tasks / projects.
+ *
+ * Day 3 refactor: routes through `lib/operations.linkTask` /
+ * `lib/operations.unlinkTask` — argparse + result-to-exit only.
+ *
+ * P5 (preserved from earlier phases):
+ *   - `--remove --task X` writes a `session_unlink` event whose reducer
+ *     filters tasks[]/projects[] in place (set-based, idempotent).
+ *   - `--remove` with no `--task` / `--project` rejects with exit 2 +
+ *     "requires at least one --task or --project".
+ */
+
+import { linkTask, unlinkTask } from '../lib/operations.mjs';
+import { ArgparseError, formatHelp, parseArgs } from './argparse.mjs';
+import { renderDryRun, reportResult, reportStableIdNotFound } from './_write-helpers.mjs';
+
+const SPEC = {
+  positional: [{ name: 'stable_id', required: true }],
+  flags: {
+    '--task': { type: 'string', repeatable: true },
+    '--project': { type: 'string', repeatable: true },
+    '--remove': { type: 'boolean' },
+    '--dry-run': { type: 'boolean' },
+    '--json': { type: 'boolean' },
+    '--root': { type: 'string' },
+    '--quiet': { type: 'boolean' },
+  },
+};
+
+export const HELP = formatHelp({
+  usage: 'sessions-db link <stable_id> [--task T ...] [--project P ...] [--remove]',
+  summary: 'Link / unlink a session from one or more tasks / projects.',
+  flags: [
+    { name: '--task <id>',    desc: 'task filename to link (or unlink with --remove); repeatable' },
+    { name: '--project <id>', desc: 'project key to link (or unlink with --remove); repeatable' },
+    { name: '--remove',       desc: 'unlink instead of link — writes session_unlink event' },
+    { name: '--dry-run',      desc: 'print event but do not write' },
+    { name: '--json',         desc: 'JSON output' },
+    { name: '--root <p>',     desc: 'override storage root' },
+  ],
+  examples: [
+    'sessions-db link sess_01970000-... --task feat-foo.md',
+    'sessions-db link sess_01970000-... --project proj-bar --task feat-foo.md',
+    'sessions-db link sess_01970000-... --remove --task feat-foo.md',
+  ],
+});
+
+function asArray(v) {
+  if (v === undefined) return [];
+  return Array.isArray(v) ? v : [v];
+}
+
+export async function run(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs(argv, SPEC);
+  } catch (err) {
+    if (err instanceof ArgparseError) {
+      process.stderr.write(`error: ${err.message}\n\n${HELP}`);
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+
+  if (parsed.helpRequested) {
+    process.stdout.write(HELP);
+    return;
+  }
+
+  const stableId = parsed.positional.stable_id;
+  const tasks = asArray(parsed.flags['--task']);
+  const projects = asArray(parsed.flags['--project']);
+  const remove = parsed.flags['--remove'] === true;
+  const root = parsed.flags['--root'];
+  const dryRun = parsed.flags['--dry-run'] === true;
+  const json = parsed.flags['--json'] === true;
+  const quiet = parsed.flags['--quiet'] === true;
+
+  if (tasks.length === 0 && projects.length === 0) {
+    // Same message regardless of remove vs add — both modes need targets.
+    if (remove) {
+      process.stderr.write(
+        `error: link --remove requires at least one --task or --project\n`,
+      );
+    } else {
+      process.stderr.write(`error: provide at least one --task or --project\n`);
+    }
+    process.exit(2);
+  }
+
+  // P5: --remove writes a session_unlink event (set-based filter). Otherwise
+  // we keep the P1 session_link path (additive).
+  const op = remove ? 'session_unlink' : 'session_link';
+
+  if (dryRun) {
+    const payload = {};
+    if (tasks.length > 0) payload.tasks = tasks;
+    if (projects.length > 0) payload.projects = projects;
+    renderDryRun({ op, stableId, payload, json });
+    return;
+  }
+
+  const opts = root ? { root } : {};
+  const fn = remove ? unlinkTask : linkTask;
+  const result = await fn({
+    stableId,
+    tasks: tasks.length > 0 ? tasks : undefined,
+    projects: projects.length > 0 ? projects : undefined,
+    ...opts,
+  });
+
+  if (!result.ok && typeof result.error === 'string'
+      && result.error.startsWith('stable_id not found:')) {
+    if (!quiet) {
+      const code = reportStableIdNotFound(result.error);
+      process.exit(code);
+    }
+    process.exit(1);
+  }
+
+  const extra = {};
+  if (tasks.length > 0) extra.tasks = tasks;
+  if (projects.length > 0) extra.projects = projects;
+  if (remove) extra.removed = true;
+  const code = reportResult({
+    result, op, stableId, json, quiet, extra,
+  });
+  if (code !== 0) process.exit(code);
+}

package/cli/rebuild.mjs

@@ -0,0 +1,98 @@
+/**
+ * `sessions-db rebuild` — rebuild the projection cache from events.jsonl.
+ *
+ * Use cases:
+ *  - Recover after a corrupted projection (loadProjection auto-falls back to
+ *    rebuild on parse failure, but a manual rebuild gives ops visible
+ *    confirmation).
+ *  - After a hand-edit of events.jsonl (rare; e.g. removing a poisoned event).
+ *  - During schema migration when the reducer changes meaning of an existing
+ *    op.
+ *
+ * Output: human-readable summary by default, machine-readable JSON with
+ * --json. Tolerated tail-partial corruptions (interrupted writes) are
+ * surfaced as a count so ops can correlate against hook failures. Middle-
+ * line corruptions throw and exit 1.
+ */
+
+import { rebuildProjection } from '../lib/storage.mjs';
+import { ArgparseError, formatHelp, parseArgs } from './argparse.mjs';
+import { formatJSON } from './format.mjs';
+
+const SPEC = {
+  positional: [],
+  flags: {
+    '--json': { type: 'boolean' },
+    '--root': { type: 'string' },
+    '--quiet': { type: 'boolean' },
+  },
+};
+
+export const HELP = formatHelp({
+  usage: 'sessions-db rebuild [--json] [--root <p>]',
+  summary: 'Rebuild the projection cache from events.jsonl (full fold).',
+  flags: [
+    { name: '--json',     desc: 'JSON output' },
+    { name: '--root <p>', desc: 'override storage root' },
+  ],
+  examples: [
+    'sessions-db rebuild',
+    'sessions-db rebuild --root /tmp/sessions-isolation-test',
+  ],
+});
+
+export async function run(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs(argv, SPEC);
+  } catch (err) {
+    if (err instanceof ArgparseError) {
+      process.stderr.write(`error: ${err.message}\n\n${HELP}`);
+      process.exit(err.exitCode);
+    }
+    throw err;
+  }
+
+  if (parsed.helpRequested) {
+    process.stdout.write(HELP);
+    return;
+  }
+
+  const root = parsed.flags['--root'];
+  const quiet = parsed.flags['--quiet'] === true;
+  const json = parsed.flags['--json'] === true;
+
+  let result;
+  try {
+    result = await rebuildProjection(root ? { root } : {});
+  } catch (err) {
+    // Middle-line corruption (or other rebuild failure) — surface and exit 1.
+    process.stderr.write(`error: rebuild failed: ${err && err.message ? err.message : String(err)}\n`);
+    if (err && Array.isArray(err.corruptions) && err.corruptions.length > 0) {
+      for (const c of err.corruptions.slice(0, 5)) {
+        process.stderr.write(`  line ${c.lineNumber}: ${c.error}\n`);
+      }
+    }
+    process.exit(1);
+  }
+
+  if (quiet) return;
+
+  if (json) {
+    process.stdout.write(formatJSON({ ok: true, ...result }));
+    return;
+  }
+
+  // P5: surface toleratedCorruptions on a SECOND line prefixed with "warning:"
+  // so log scrapers can grep for `^warning:` (or the parent token) without
+  // reading past the "ok:" header. Format aligned with the P5 ticket §5.
+  process.stdout.write(
+    `ok: rebuilt projection — ${result.sessionCount} session${result.sessionCount === 1 ? '' : 's'}, ` +
+    `${result.eventCount} event${result.eventCount === 1 ? '' : 's'}\n`,
+  );
+  if (result.toleratedCorruptions > 0) {
+    process.stdout.write(
+      `  (warning: ${result.toleratedCorruptions} tail-partial event line${result.toleratedCorruptions === 1 ? '' : 's'} tolerated)\n`,
+    );
+  }
+}