create-byan-agent 2.25.0 → 2.26.0

package/install/templates/.claude/hooks/lib/autobench-ledger-report.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+// BYAN Auto-Benchmark miss-ledger reader / aggregator (C5e).
+//
+// The Stop hook (autobench-stop-guard.js) appends ONE JSONL line per invocation
+// to _byan-output/benchmark-ledger.jsonl. Each line is an audit record of one
+// end-of-turn decision: did the agent benchmark a fork it should have, or did it
+// MISS. This module reads that trail and aggregates it into the fires / misses /
+// miss-rate summary required by the acceptance criteria, plus a small CLI-ish
+// `main()` so a human (or CI) can run a one-shot report.
+//
+// Event vocabulary is OWNED by the hook; this reader treats it as the contract:
+//   fired-block               -> a MISS (the agent offered a fork without a
+//                                benchmark marker; the hook forced a regen).
+//   satisfied-marker          -> a HIT  (a real benchmark was presented).
+//   satisfied-skip            -> a deliberate skip (fork considered, not tabled).
+//   satisfied-never           -> exempt (y/n confirm / destructive prompt).
+//   satisfied-escape          -> exempt (escape-hatch active).
+//   satisfied-already-blocked -> the forced regen pass (block-once accounting).
+//   no-choice                 -> no fork was present (the common case).
+// Anything else is bucketed under `unknown` so a future event type is surfaced,
+// not silently dropped.
+//
+// Pure read-only: this module NEVER writes the ledger. It reads what the hook
+// wrote. Robust to a partially-written / corrupt JSONL file: a malformed line is
+// counted under `malformed` and skipped, never thrown.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+// Events that count as a genuine MISS the agent must fix. Kept narrow on
+// purpose: only `fired-block` is a real failure. Everything else is either a
+// hit, an exempt case, or accounting.
+const MISS_EVENTS = new Set(['fired-block']);
+
+// Events that count as a real benchmark HIT (a fork was tabled).
+const HIT_EVENTS = new Set(['satisfied-marker']);
+
+// Events that mean "a fork was considered and deliberately not tabled".
+const SKIP_EVENTS = new Set(['satisfied-skip']);
+
+// Exempt / accounting events: present in the trail but neither a miss nor a hit.
+const EXEMPT_EVENTS = new Set([
+  'satisfied-never',
+  'satisfied-escape',
+  'satisfied-already-blocked',
+  'no-choice',
+]);
+
+function projectRoot() {
+  return process.env.CLAUDE_PROJECT_DIR || process.cwd();
+}
+
+function defaultLedgerPath() {
+  return path.join(projectRoot(), '_byan-output', 'benchmark-ledger.jsonl');
+}
+
+/**
+ * Read and parse the ledger file into an array of entries.
+ * Returns { entries, malformed, missing } where `malformed` counts unparseable
+ * lines and `missing` is true when the file does not exist (a fresh repo where
+ * the hook never fired -> not an error, just an empty trail).
+ *
+ * @param {string} [filePath] absolute path; defaults to the project ledger.
+ */
+function readLedger(filePath) {
+  const p = filePath || defaultLedgerPath();
+  let raw;
+  try {
+    if (!fs.existsSync(p)) return { entries: [], malformed: 0, missing: true };
+    raw = fs.readFileSync(p, 'utf8');
+  } catch {
+    // An unreadable ledger is treated as empty rather than thrown: a reporting
+    // tool must never crash the caller over a permissions blip.
+    return { entries: [], malformed: 0, missing: true };
+  }
+
+  const entries = [];
+  let malformed = 0;
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const obj = JSON.parse(trimmed);
+      if (obj && typeof obj === 'object') entries.push(obj);
+      else malformed += 1;
+    } catch {
+      malformed += 1;
+    }
+  }
+  return { entries, malformed, missing: false };
+}
+
+/**
+ * Aggregate a list of ledger entries into a summary.
+ *
+ * @param {Array<object>} entries
+ * @returns {object} {
+ *   total, fires, misses, hits, skips, exempt, unknown, missRate,
+ *   byEvent:{event:count}, byScope:{internal,external,unknown},
+ *   gates:{g1Total,g2Total,countWithGates}
+ * }
+ *   - fires  = decisions where a fork was present and acted on (hits + misses).
+ *   - misses = fired-block events (the agent must fix these).
+ *   - missRate = misses / fires (0 when no fork was ever present).
+ */
+function aggregate(entries) {
+  const list = Array.isArray(entries) ? entries : [];
+
+  const byEvent = {};
+  const byScope = { internal: 0, external: 0, unknown: 0 };
+  let misses = 0;
+  let hits = 0;
+  let skips = 0;
+  let exempt = 0;
+  let unknown = 0;
+  let g1Total = 0;
+  let g2Total = 0;
+  let countWithGates = 0;
+
+  for (const e of list) {
+    const event = e && typeof e.event === 'string' ? e.event : 'unknown';
+    byEvent[event] = (byEvent[event] || 0) + 1;
+
+    if (MISS_EVENTS.has(event)) misses += 1;
+    else if (HIT_EVENTS.has(event)) hits += 1;
+    else if (SKIP_EVENTS.has(event)) skips += 1;
+    else if (EXEMPT_EVENTS.has(event)) exempt += 1;
+    else unknown += 1;
+
+    // Scope tally (only the marker-bearing hits/skips carry a scope field).
+    const scope = e && e.scope;
+    if (scope === 'internal' || scope === 'external') byScope[scope] += 1;
+    else if (scope != null) byScope.unknown += 1;
+
+    // Gate totals: only the satisfied-marker entries carry g1/g2 (the marker
+    // fields the hook parsed). Average gate counts hint at fork complexity.
+    if (typeof e.g1 === 'number' || typeof e.g2 === 'number') {
+      if (typeof e.g1 === 'number') g1Total += e.g1;
+      if (typeof e.g2 === 'number') g2Total += e.g2;
+      countWithGates += 1;
+    }
+  }
+
+  // A "fire" is a turn where a fork was genuinely present and the doctrine
+  // applied: a HIT (tabled) or a MISS (should have, didn't). Skips, exempts and
+  // no-choice turns are NOT fires, so the miss-rate is not diluted by the vast
+  // majority of turns that have no fork at all.
+  const fires = hits + misses;
+  const missRate = fires > 0 ? misses / fires : 0;
+
+  return {
+    total: list.length,
+    fires,
+    misses,
+    hits,
+    skips,
+    exempt,
+    unknown,
+    missRate,
+    byEvent,
+    byScope,
+    gates: {
+      g1Total,
+      g2Total,
+      countWithGates,
+      g1Avg: countWithGates > 0 ? g1Total / countWithGates : 0,
+      g2Avg: countWithGates > 0 ? g2Total / countWithGates : 0,
+    },
+  };
+}
+
+/**
+ * Convenience: read + aggregate in one call.
+ * @param {string} [filePath]
+ * @returns {object} aggregate(...) plus { malformed, missing, path }.
+ */
+function report(filePath) {
+  const p = filePath || defaultLedgerPath();
+  const { entries, malformed, missing } = readLedger(p);
+  return Object.assign(aggregate(entries), { malformed, missing, path: p });
+}
+
+// Render a percentage with one decimal, no trailing-zero noise (e.g. "12.5%").
+function pct(ratio) {
+  return `${(ratio * 100).toFixed(1)}%`;
+}
+
+/**
+ * Render a human-readable summary block (no color, no emoji). Returns a string
+ * so it is testable; main() writes it to stdout.
+ */
+function formatReport(rep) {
+  const lines = [];
+  lines.push('BYAN Auto-Benchmark ledger report');
+  lines.push(`  file        : ${rep.path}`);
+  if (rep.missing) {
+    lines.push('  status      : ledger not found (the Stop hook has not fired yet)');
+    return lines.join('\n');
+  }
+  lines.push(`  records     : ${rep.total}${rep.malformed ? ` (+${rep.malformed} malformed, skipped)` : ''}`);
+  lines.push(`  forks (fires): ${rep.fires}   hits: ${rep.hits}   misses: ${rep.misses}`);
+  lines.push(`  miss-rate   : ${pct(rep.missRate)}${rep.fires === 0 ? ' (no fork seen)' : ''}`);
+  lines.push(`  skips       : ${rep.skips}   exempt: ${rep.exempt}   unknown: ${rep.unknown}`);
+  lines.push(
+    `  scope       : internal=${rep.byScope.internal} external=${rep.byScope.external}`
+  );
+  if (rep.gates.countWithGates > 0) {
+    lines.push(
+      `  avg gates   : g1=${rep.gates.g1Avg.toFixed(1)} g2=${rep.gates.g2Avg.toFixed(1)} (over ${rep.gates.countWithGates} benchmarks)`
+    );
+  }
+  const events = Object.keys(rep.byEvent).sort();
+  if (events.length) {
+    lines.push('  by event    :');
+    for (const ev of events) lines.push(`    ${ev.padEnd(26)} ${rep.byEvent[ev]}`);
+  }
+  return lines.join('\n');
+}
+
+// CLI entry: `node autobench-ledger-report.js [path]` or `--json` for raw data.
+// Exit 0 always (a report tool never fails the shell over a read).
+function main(argv) {
+  const args = Array.isArray(argv) ? argv : process.argv.slice(2);
+  const asJson = args.includes('--json');
+  const fileArg = args.find((a) => a && !a.startsWith('--'));
+  const rep = report(fileArg);
+  if (asJson) {
+    process.stdout.write(JSON.stringify(rep, null, 2) + '\n');
+  } else {
+    process.stdout.write(formatReport(rep) + '\n');
+  }
+  return rep;
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  MISS_EVENTS,
+  HIT_EVENTS,
+  SKIP_EVENTS,
+  EXEMPT_EVENTS,
+  defaultLedgerPath,
+  readLedger,
+  aggregate,
+  report,
+  formatReport,
+  pct,
+  main,
+};

package/install/templates/.claude/hooks/lib/autobench-runtime.js

@@ -0,0 +1,199 @@
+// Shared runtime helpers for the BYAN Auto-Benchmark Stop hook.
+//
+// Reads one static file :
+//   - .claude/hooks/lib/autobench-config.json : the runtime subset generated
+//     from _byan/_config/autobench.yaml by byan-sync-rules (never_list regexes,
+//     choice_language regexes, marker patterns, escape-hatch paths, banners,
+//     ledger path).
+//
+// Owns the ephemeral session artifacts the Stop hook needs :
+//   - .byan-autobench/off : session escape-hatch flag (touch to disable).
+//   - .byan-autobench/blocked-<turnHash> : the block-once token, written when a
+//     turn is blocked so the regenerated turn is never blocked a second time.
+//   - _byan-output/benchmark-ledger.jsonl : the append-only fire/miss audit.
+//
+// This module is deliberately SEPARATE from strict-runtime.js : the two hook
+// families have different state shapes and lifecycles, and coupling them would
+// make a change to one risk the other.
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+function projectRoot() {
+  return process.env.CLAUDE_PROJECT_DIR || process.cwd();
+}
+
+function readJson(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function configPath() {
+  return path.join(projectRoot(), '.claude', 'hooks', 'lib', 'autobench-config.json');
+}
+
+function loadAutobenchConfig() {
+  return readJson(configPath());
+}
+
+// Session-scoped flag file. Its mere presence disables blocking for the
+// session. The cross-session opt-out lives in the config (escape_hatch.disabled)
+// so it survives across sessions and is regenerated from the YAML.
+function sessionFlagPath() {
+  return path.join(projectRoot(), '.byan-autobench', 'off');
+}
+
+function escapeHatchActive(config) {
+  // Session flag : touch .byan-autobench/off to disable for this session.
+  try {
+    if (fs.existsSync(sessionFlagPath())) return true;
+  } catch {
+    // ignore — fall through to the cross-session check
+  }
+  // Cross-session opt-out, carried in the generated config.
+  const eh = config && config.escape_hatch;
+  if (eh && eh.disabled === true) return true;
+  return false;
+}
+
+// Arming. The Stop hook ships DISARMED (approach C) : it observes and ledgers
+// but never blocks until explicitly armed, so day one is zero noise / latency.
+// Arming is config-only : set enforcement.armed === true in
+// _byan/_config/autobench.yaml and run byan-sync-rules to regenerate the
+// config. There is NO loose flag file — a stray file on disk must not silently
+// arm a machine (the incoherent state the integration audit found). Default : OFF.
+function isArmed(config) {
+  const en = config && config.enforcement;
+  return !!(en && en.armed === true);
+}
+
+function blockDir() {
+  return path.join(projectRoot(), '.byan-autobench');
+}
+
+function blockTokenPath(turnHash) {
+  return path.join(blockDir(), `blocked-${turnHash}`);
+}
+
+function readBlockToken(turnHash) {
+  try {
+    return fs.existsSync(blockTokenPath(turnHash));
+  } catch {
+    return false;
+  }
+}
+
+function writeBlockToken(turnHash) {
+  try {
+    fs.mkdirSync(blockDir(), { recursive: true });
+    // Content is irrelevant — presence is the signal. We still stamp the hash so
+    // a human inspecting .byan-autobench/ can tell which turn was blocked.
+    fs.writeFileSync(blockTokenPath(turnHash), turnHash + '\n');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function ledgerPath(config) {
+  const rel =
+    (config && config.ledger && config.ledger.path) ||
+    path.join('_byan-output', 'benchmark-ledger.jsonl');
+  return path.isAbsolute(rel) ? rel : path.join(projectRoot(), rel);
+}
+
+// Append ONE JSONL line. Best-effort : a failed append never traps the turn.
+// The caller supplies any timestamp/session via the entry so this stays
+// deterministic and unit-testable (no clock read here).
+function appendLedger(entry, config) {
+  try {
+    const p = ledgerPath(config);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.appendFileSync(p, JSON.stringify(entry) + '\n');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Transcript extraction (text + raw content) is shared with the other Stop hooks
+// through transcript-read.js — one canonical reader for the real Stop payload
+// (last_assistant_message + transcript_path JSONL) instead of divergent per-hook
+// copies. extractLastAssistantContent feeds hasChoiceArtifact below.
+const {
+  extractLastAssistantText,
+  extractLastAssistantContent,
+  lastAssistantContentFromTranscriptFile,
+  contentToText,
+} = require('./transcript-read');
+
+// ARTIFACT-primary fork signal : a real choice surfaced through the
+// AskUserQuestion tool (the multiple-choice UI) is unambiguous, unlike prose
+// that merely contains 'or' / 'option'. Keys on the structural tool_use block in
+// the finished turn, NOT on choice-WORDS. The lexical regex stays a last-resort
+// fallback for inline-prose forks that never call the tool. Post-hoc by
+// construction (GH #28273) : the tool_use is read from the finished transcript.
+function hasChoiceArtifact(content) {
+  if (!Array.isArray(content)) return false;
+  return content.some(
+    (b) =>
+      b &&
+      b.type === 'tool_use' &&
+      typeof b.name === 'string' &&
+      /askuserquestion/i.test(b.name)
+  );
+}
+
+// Content-only hash : NO clock, NO RNG. Block-once must be stable across the
+// original turn and its regeneration would only differ if the text differs.
+function turnHash(text) {
+  return crypto.createHash('sha1').update(String(text || '')).digest('hex').slice(0, 16);
+}
+
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve('');
+    let data = '';
+    process.stdin.on('data', (c) => (data += c));
+    process.stdin.on('end', () => resolve(data));
+    process.stdin.on('error', () => resolve(data));
+  });
+}
+
+function parseJson(raw) {
+  try {
+    return raw ? JSON.parse(raw) : {};
+  } catch {
+    return {};
+  }
+}
+
+module.exports = {
+  projectRoot,
+  configPath,
+  loadAutobenchConfig,
+  sessionFlagPath,
+  escapeHatchActive,
+  isArmed,
+  blockDir,
+  blockTokenPath,
+  readBlockToken,
+  writeBlockToken,
+  ledgerPath,
+  appendLedger,
+  extractLastAssistantText,
+  extractLastAssistantContent,
+  lastAssistantContentFromTranscriptFile,
+  contentToText,
+  hasChoiceArtifact,
+  turnHash,
+  readStdin,
+  parseJson,
+};

package/install/templates/.claude/hooks/lib/fact-check-core.js

@@ -0,0 +1,69 @@
+/**
+ * fact-check-core — pure detection engine shared by the fact-check hooks.
+ *
+ * No IO, no process exit. The PreToolUse doc gate (fact-check-absolutes.js)
+ * and the Stop conversation nudge (fact-check-claims.js) both consume this so
+ * the absolute-detection logic lives in one place.
+ */
+
+'use strict';
+
+const ABSOLUTES = [
+  /\btoujours\b/i,
+  /\bjamais\b/i,
+  /\bforc[eé]ment\b/i,
+  /\bobviously\b/i,
+  /\balways\b/i,
+  /\bnever\b/i,
+  /\bclearly\b/i,
+  /\bundoubtedly\b/i,
+  /\bfaster than\b/i,
+  /\bbetter than\b/i,
+  /\bplus rapide que\b/i,
+  /\bmeilleur que\b/i,
+];
+
+const SOURCE_MARKERS = [
+  /\bRFC\s*\d+/i,
+  /\bCVE-\d{4}-\d+/i,
+  /https?:\/\//,
+  /\[CLAIM\s+L[1-5]\]/i,
+  /\[FACT\s+USER-VERIFIED/i,
+  /\bsource\s*:/i,
+  /_byan\/knowledge\/sources\.md/,
+];
+
+// Strip content that cannot be a claim :
+//   - fenced code blocks ``` ... ```
+//   - inline backticks `...`
+//   - block quotes (lines starting with >)
+//   - list-of-pattern lines (e.g. "- toujours")
+function stripNonClaimZones(text) {
+  if (!text) return '';
+  return text
+    .replace(/```[\s\S]*?```/g, '')
+    .replace(/`[^`\n]+`/g, '')
+    .replace(/^> .*$/gm, '')
+    .replace(/^[\s-]*['"]?\b(toujours|jamais|forc[eé]ment|obviously|always|never|clearly|undoubtedly)\b['"]?/gim, '');
+}
+
+// Return the first unsourced absolute (with surrounding context) or null when
+// every absolute has a source marker within a +/-240 char window.
+function findUnsourced(text) {
+  if (!text) return null;
+  for (const re of ABSOLUTES) {
+    const match = text.match(re);
+    if (!match) continue;
+    const idx = match.index || 0;
+    const windowStart = Math.max(0, idx - 240);
+    const windowEnd = Math.min(text.length, idx + match[0].length + 240);
+    const ctx = text.slice(windowStart, windowEnd);
+    const hasSource = SOURCE_MARKERS.some((sm) => sm.test(ctx));
+    if (!hasSource) {
+      return { absolute: match[0], context: text.slice(Math.max(0, idx - 80), idx + 80) };
+    }
+  }
+  return null;
+}
+
+module.exports = { ABSOLUTES, SOURCE_MARKERS, stripNonClaimZones, findUnsourced };

package/install/templates/.claude/hooks/lib/transcript-read.js

@@ -0,0 +1,137 @@
+// Shared transcript reader for Claude Code Stop hooks.
+//
+// The real Stop-hook payload carries NO inline transcript: the runtime hands a
+// `last_assistant_message` string and a `transcript_path` pointing at a JSONL
+// file. A hook that reads `payload.transcript || payload.messages` (an inline
+// array) extracts nothing in production and silently never fires — the bug this
+// module exists to prevent, in one place instead of four divergent copies.
+//
+// Transcript JSONL shape (one object per line): a turn is
+//   { type: 'user'|'assistant', message: { role, content: string | block[] } }
+// where a block is { type: 'text', text } or { type: 'tool_use', name, input, ... }.
+//
+// Every function is best-effort: an unreadable/short file or a malformed line
+// yields empty/null so a hook never traps a turn it cannot read.
+
+'use strict';
+
+const fs = require('fs');
+
+// Flatten an assistant message content (string or block array) to plain text.
+function contentToText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content.map((c) => (c && typeof c.text === 'string' ? c.text : '')).join(' ');
+  }
+  return '';
+}
+
+// Parse a transcript JSONL file into the array of its message objects
+// ({ type, message:{role, content} }), skipping blank/malformed lines.
+function readTranscriptLines(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const out = [];
+    for (const line of raw.split('\n')) {
+      if (!line || !line.trim()) continue;
+      try {
+        out.push(JSON.parse(line));
+      } catch {
+        // skip a malformed line, keep the rest
+      }
+    }
+    return out;
+  } catch {
+    return null;
+  }
+}
+
+function isAssistantLine(o) {
+  return Boolean((o && o.type === 'assistant') || (o && o.message && o.message.role === 'assistant'));
+}
+
+// The RAW content (string or block array) of the last assistant turn in the
+// file, or null. Used for artifact detection (tool_use blocks survive here).
+function lastAssistantContentFromTranscriptFile(filePath) {
+  const lines = readTranscriptLines(filePath);
+  if (!lines) return null;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const o = lines[i];
+    if (isAssistantLine(o) && o.message && o.message.content != null) return o.message.content;
+  }
+  return null;
+}
+
+// The user/assistant messages from the file as { role, content } objects, in
+// order, or null. Lets a hook reconstruct the last N turns of a conversation.
+function messagesFromTranscriptFile(filePath) {
+  const lines = readTranscriptLines(filePath);
+  if (!lines) return null;
+  const out = [];
+  for (const o of lines) {
+    const m = o && o.message;
+    if (m && (m.role === 'user' || m.role === 'assistant')) {
+      out.push({ role: m.role, content: m.content });
+    }
+  }
+  return out.length ? out : null;
+}
+
+// The RAW content of the finished assistant turn from ANY payload shape: an
+// inline array (test fixtures / legacy) first, then the transcript_path file.
+// last_assistant_message is text-only, so it cannot feed artifact detection and
+// is handled in extractLastAssistantText, not here.
+function extractLastAssistantContent(payload) {
+  if (!payload || typeof payload !== 'object') return null;
+
+  const inline = payload.transcript || payload.messages;
+  if (Array.isArray(inline)) {
+    for (let i = inline.length - 1; i >= 0; i--) {
+      const m = inline[i];
+      if (m && m.role === 'assistant') return m.content;
+    }
+  }
+
+  const tp = payload.transcript_path || payload.transcriptPath;
+  if (typeof tp === 'string') {
+    const content = lastAssistantContentFromTranscriptFile(tp);
+    if (content != null) return content;
+  }
+
+  return null;
+}
+
+// The finished assistant turn as plain text (the primary signal for most hooks).
+// Prefer the runtime-provided last_assistant_message; else derive from content.
+function extractLastAssistantText(payload) {
+  if (!payload || typeof payload !== 'object') return '';
+  if (typeof payload.last_assistant_message === 'string') return payload.last_assistant_message;
+  if (typeof payload.lastAssistantMessage === 'string') return payload.lastAssistantMessage;
+  return contentToText(extractLastAssistantContent(payload));
+}
+
+// The last N user/assistant messages as { role, content }, from any payload
+// shape (inline array or transcript_path file), or null when none are readable.
+function extractRecentMessages(payload, limit) {
+  if (!payload || typeof payload !== 'object') return null;
+  let msgs = payload.transcript || payload.messages;
+  if (!Array.isArray(msgs)) {
+    const tp = payload.transcript_path || payload.transcriptPath;
+    if (typeof tp === 'string') msgs = messagesFromTranscriptFile(tp);
+  }
+  if (!Array.isArray(msgs)) return null;
+  const filtered = msgs.filter((m) => m && (m.role === 'user' || m.role === 'assistant'));
+  if (!filtered.length) return null;
+  return typeof limit === 'number' ? filtered.slice(-limit) : filtered;
+}
+
+module.exports = {
+  contentToText,
+  readTranscriptLines,
+  lastAssistantContentFromTranscriptFile,
+  messagesFromTranscriptFile,
+  extractLastAssistantContent,
+  extractLastAssistantText,
+  extractRecentMessages,
+};