@bongos/core 1.21.174 → 1.21.176

package/scripts/bongos/session-digest-build.js

@@ -0,0 +1,293 @@
+// scripts/bongos/session-digest-build.js — the PURE transcript→digest builder.
+//
+// Extracted from scripts/bongos/ship.js (task 1003217, serving the de-monolith goal
+// of task 1003203: nothing over 1,500 lines). ship.js was 4,646 lines and this
+// block — snippetOf + buildSessionDigest and their two constants — is pure,
+// separately tested, and shared: ship.js uploads a digest mid-ship and
+// session-digest.js uploads the final one on the SessionEnd seam.
+//
+// It has NO dependency on ship.js, which is what makes the split safe: ship.js
+// imports and re-exports this, so its public surface (and tests/session_records.mjs)
+// is unchanged, and the existing session-digest.js -> ship.js import cannot become
+// a cycle.
+//
+// NB the prose above deliberately says "imports", not the r-e-q-u-i-r-e call
+// spelled with './ship' — the fitness require-graph (scripts/bongos/fitness-ratchets.js
+// requireGraph) scans raw file text and does NOT strip comments, so naming that
+// call here invented a phantom session-digest-build <-> ship cycle and tripped the
+// require_cycle_count ratchet. Same trap the curated-set parser in run-unit-tests.js
+// warns about for quoted words in ITS comments.
+//
+// The transcript-grade secret scrubber + its ADR-0022 internals live in
+// modules/security/secret-scrub.js — extracted (task 1211 / GDS-V4 R72) so the
+// public-mirror export pipeline can reuse the ONE copy of the secret shapes
+// without requiring ship.js (whose grader / Discord / sound / session deps are
+// absent in a bare CI job). See that module for the recall-first design (a missed
+// secret is a compromise; over-redaction is cosmetic).
+const { scrubSecrets } = require('../../modules/security/secret-scrub');
+
+// snippetOf — short, single-line, scrubbed excerpt for footgun context.
+function snippetOf(text, extraSecrets, max = 160) {
+  if (typeof text !== 'string' || text.length === 0) return undefined;
+  // Drop NULs first: Postgres rejects a literal NUL in jsonb, so ONE of them anywhere in
+  // ONE snippet made the whole digest unstorable — POST /sessions answered 500 and
+  // the session never paid. UTF-16LE tool output (`wsl --list` is the observed
+  // case) is full of them, and \s below does NOT match NUL, so it must go here.
+  const flat = text.replace(/\0/g, '').replace(/\s+/g, ' ').trim();
+  if (!flat) return undefined;
+  const cut = flat.length > max ? flat.slice(0, max) : flat;
+  const scrubbed = scrubSecrets(cut, extraSecrets);
+  return scrubbed || undefined;
+}
+
+// buildSessionDigest — turn parsed Claude Code transcript entries into
+// { startedAt, endedAt, durationSeconds, totalTokens, metrics, detail }.
+// Pure (no I/O) + exported for unit tests. `detail` is per-turn metadata + short
+// scrubbed snippets, capped at maxTurns (head+tail kept when over).
+// Harness guardrail retries (task 959) — an is_error tool_result that is NOT real
+// friction but the agent harness rejecting a tool call: an Edit/Write before the
+// file was Read ("File has not been read yet"), or a foreground sleep ("Blocked:
+// sleep"). These were counted in tool_error_count, inflating it and skewing the
+// BFG's order=tool_errors ranking (top sessions ranked on benign retries). They
+// now go into a separate harness_retry_count so tool_error_count stays NET — and
+// because the sessions/search ordering reads metrics->>'tool_error_count'
+// (src/bongos/db.js), that ordering automatically uses the net figure with no route
+// change. (ADR 0027 lineage — the 6D session evaluator.)
+const HARNESS_RETRY_RE =
+  /File has not been read yet|Read it first before (?:writing|editing)|Blocked:\s*sleep|sleep is blocked in (?:the )?foreground/i;
+
+// task 1676 — the family bucket unlabeled token-bearing turns are folded into so
+// the cost-plus reward (ADR 0054) prices the real spend instead of rounding to $0.
+// A concrete, priceable model id (llm-pricing.js maps it to the opus family by
+// substring) — NOT a fabricated dollar figure; it carries the REAL token counts
+// ship.js already parsed, priced server-side like any other bucket.
+const UNATTRIBUTED_MODEL = 'claude-opus-4-8';
+
+// task 1003217 — ONE API CALL IS MANY TRANSCRIPT LINES.
+//
+// Claude Code writes a separate transcript line per content block of a single
+// assistant message (thinking / text / tool_use), and EVERY one of those lines
+// repeats the SAME `message.usage` object. Summing usage per line therefore
+// counted one API call's tokens two or three times: measured 2.22x inflation
+// across 12 real transcripts in this project (2,357 usage-bearing lines,
+// naive cache_read 551,095,738 vs deduped 248,555,962).
+//
+// `message.id` is the API call's identity — the usage tuples are byte-identical
+// across lines sharing an id. The proof that a line-GROUP is one call is the
+// cache chain: cache_read[n] == cache_read[n-1] + cache_creation[n-1] closes on
+// 99.1% of links after de-duplication (the residue is compaction boundaries)
+// and holds for none of them before it.
+//
+// This mattered because ADR 0054 pays round(true_cost_usd x 1.20) from these
+// very numbers, so the inflation flowed into cost-plus rewards.
+//
+// `assistant_turns` is deliberately left as the LINE count (existing consumers
+// order on it); `api_calls` is the new honest step count. A transcript whose
+// messages carry no `id` degrades to exactly the old behaviour.
+function buildSessionDigest(entries, opts = {}) {
+  const extra = opts.extraSecrets || [];
+  const MAX_TURNS = opts.maxTurns || 4000;
+  // usageOnly — build the token metrics but no `detail`. For the callers that
+  // want ONLY a transcript's model_usage (the subagents-subtree fold, task
+  // 1003435), where the per-turn rows would be discarded anyway and the snippet
+  // scrubbing is the expensive part. It exists so that fold can reuse THIS
+  // function — the one place the token semantics live — instead of a second copy
+  // that could drift, without paying for output nobody reads. The waste is worth
+  // avoiding on both upload paths, and on the SessionEnd one it is load-bearing:
+  // that hook runs under a 6-second watchdog, so a slow pass there doesn't just
+  // cost time, it drops the upload.
+  const usageOnly = opts.usageOnly === true;
+  const seenMessageIds = new Set();
+  const m = {
+    assistant_turns: 0,
+    api_calls: 0, // distinct message.id — the real number of API round-trips
+    user_turns: 0,
+    tool_use_count: 0,
+    tool_result_count: 0,
+    tool_error_count: 0, // NET real errors (harness guardrail retries excluded)
+    harness_retry_count: 0, // benign harness guardrail retries (task 959)
+    tokens: { input: 0, output: 0, cache_read: 0, cache_creation: 0 },
+    model_usage: {}, // per-model token buckets for the cost-plus reward (task 1005)
+    // task 1676: tokens from turns with NO model id (not '<synthetic>'). Folded
+    // into a priceable bucket after the loop, then stripped from the digest.
+    _unlabeled: { input: 0, output: 0, cache_read: 0, cache_creation: 0 },
+  };
+  const detail = [];
+  let firstTs = null;
+  let lastTs = null;
+  let i = 0;
+  for (const e of Array.isArray(entries) ? entries : []) {
+    if (!e || typeof e !== 'object') continue;
+    const ts = typeof e.timestamp === 'string' ? e.timestamp : null;
+    if (ts) {
+      if (!firstTs) firstTs = ts;
+      lastTs = ts;
+    }
+    const msg = e.message;
+    if (e.type === 'assistant' && msg) {
+      m.assistant_turns++;
+      // Dedup usage per API call (see the note above buildSessionDigest). A
+      // repeat line contributes ZERO tokens but still gets its detail row, so
+      // the per-turn record stays faithful and summing detail stays correct.
+      const msgId = typeof msg.id === 'string' && msg.id ? msg.id : null;
+      const dupUsage = msgId !== null && seenMessageIds.has(msgId);
+      if (msgId !== null) seenMessageIds.add(msgId);
+      if (!dupUsage) m.api_calls++;
+      const u = dupUsage ? {} : (msg.usage || {});
+      const tin = u.input_tokens || 0;
+      const tout = u.output_tokens || 0;
+      const tcr = u.cache_read_input_tokens || 0;
+      const tcc = u.cache_creation_input_tokens || 0;
+      m.tokens.input += tin;
+      m.tokens.output += tout;
+      m.tokens.cache_read += tcr;
+      m.tokens.cache_creation += tcc;
+      // task 1005: per-model bucket for the cost-plus token reward, reusing the
+      // tin/tout/tcr/tcc already parsed above (no second pass). Skip synthetic
+      // turns (a grader 429 etc. emits no real model id AND no real spend).
+      const model = msg.model;
+      if (model === '<synthetic>') {
+        // synthetic: no real spend — exclude from BOTH model_usage and the
+        // task-1676 unlabeled-remainder fold below (don't price phantom tokens).
+      } else if (model) {
+        const mu = m.model_usage[model] || (m.model_usage[model] =
+          { input: 0, output: 0, cache_read: 0, cache_creation: 0 });
+        mu.input += tin; mu.output += tout; mu.cache_read += tcr; mu.cache_creation += tcc;
+      } else {
+        // task 1676: a token-bearing turn with NO model id. Previously dropped
+        // from model_usage (→ total_tokens>0 but priced $0 on the CI
+        // path; ADR 0097). Accumulate the unlabeled tokens so the digest can
+        // attribute them to a real, priceable family bucket after the loop.
+        m._unlabeled.input += tin; m._unlabeled.output += tout;
+        m._unlabeled.cache_read += tcr; m._unlabeled.cache_creation += tcc;
+      }
+      const tools = [];
+      let textLen = 0;
+      let firstText = '';
+      if (Array.isArray(msg.content)) {
+        for (const c of msg.content) {
+          if (c && c.type === 'tool_use') {
+            m.tool_use_count++;
+            tools.push(String(c.name || '?'));
+          } else if (c && c.type === 'text' && typeof c.text === 'string') {
+            textLen += c.text.length;
+            if (!firstText) firstText = c.text;
+          }
+        }
+      }
+      if (!usageOnly) {
+        const row = { i, role: 'assistant', ts, in: tin, out: tout, cache_read: tcr, cache_creation: tcc };
+        // Marks a line that shares its API call with an earlier one, so a reader
+        // can tell a genuinely-zero-usage turn from a de-duplicated repeat.
+        if (dupUsage) row.dup = 1;
+        if (tools.length) row.tools = tools;
+        if (textLen) row.text_len = textLen;
+        const snip = snippetOf(firstText, extra);
+        if (snip) row.snippet = snip;
+        detail.push(row);
+      }
+      i++;
+    } else if (e.type === 'user' && msg) {
+      m.user_turns++;
+      let results = 0;
+      let errors = 0;
+      let harnessRetries = 0;
+      let firstResult = '';
+      if (Array.isArray(msg.content)) {
+        for (const c of msg.content) {
+          if (c && c.type === 'tool_result') {
+            results++;
+            m.tool_result_count++;
+            const text = typeof c.content === 'string'
+              ? c.content
+              : Array.isArray(c.content)
+                ? c.content.map((p) => (p && typeof p.text === 'string' ? p.text : '')).join(' ')
+                : '';
+            if (c.is_error) {
+              // Split benign harness guardrail retries out of the net error count
+              // so order=tool_errors ranks on real friction (task 959).
+              if (HARNESS_RETRY_RE.test(text)) {
+                harnessRetries++;
+                m.harness_retry_count++;
+              } else {
+                errors++;
+                m.tool_error_count++;
+              }
+            }
+            if (!firstResult) firstResult = text;
+          }
+        }
+      }
+      if (!usageOnly) {
+        const row = { i, role: 'user', ts };
+        if (results) row.tool_results = results;
+        if (errors) row.tool_errors = errors;
+        if (harnessRetries) row.harness_retries = harnessRetries;
+        const snip = snippetOf(firstResult, extra);
+        if (snip) row.snippet = snip;
+        detail.push(row);
+      }
+      i++;
+    }
+  }
+  m.total_tokens = m.tokens.input + m.tokens.output + m.tokens.cache_read + m.tokens.cache_creation;
+  // task 1676 — cost-plus reward zero-out fix. The cost-plus session reward
+  // (ADR 0054) prices `model_usage` server-side. model_usage is keyed on msg.model
+  // and SKIPS any token-bearing turn whose model id is missing. On the CI
+  // agent path that gap was the difference between total_tokens>0 (so the digest
+  // passes the route's empty-session guard + gets stored) and model_usage={} (so
+  // priceModelUsage returns $0 → 0 drachmae) — ADR 0097's "upload no priced model
+  // usage" symptom. Fold the unlabeled remainder (NOT synthetic turns) into a real,
+  // priceable family bucket so the cost-plus reward reflects the true spend rather
+  // than silently dropping to $0. opus is the conservative family for an unlabeled
+  // turn (matches llm-pricing.js's unknown-model fallback) — this instance runs
+  // opus by default, and pricing an unlabeled turn as opus never UNDER-pays.
+  const un = m._unlabeled;
+  if (un.input + un.output + un.cache_read + un.cache_creation > 0) {
+    const fb = m.model_usage[UNATTRIBUTED_MODEL] || (m.model_usage[UNATTRIBUTED_MODEL] =
+      { input: 0, output: 0, cache_read: 0, cache_creation: 0 });
+    fb.input += un.input; fb.output += un.output;
+    fb.cache_read += un.cache_read; fb.cache_creation += un.cache_creation;
+  }
+  delete m._unlabeled; // scratch — never persisted to the digest
+  let boundedDetail = detail;
+  if (detail.length > MAX_TURNS) {
+    const head = Math.floor(MAX_TURNS * 0.7);
+    const tail = MAX_TURNS - head;
+    boundedDetail = detail.slice(0, head).concat(detail.slice(detail.length - tail));
+    m.detail_truncated = true;
+    m.detail_total_turns = detail.length;
+  }
+  let durationSeconds = null;
+  if (firstTs && lastTs) {
+    const d = (Date.parse(lastTs) - Date.parse(firstTs)) / 1000;
+    if (Number.isFinite(d) && d >= 0) durationSeconds = Math.round(d);
+  }
+  return {
+    startedAt: firstTs,
+    endedAt: lastTs,
+    durationSeconds,
+    totalTokens: m.total_tokens,
+    metrics: m,
+    detail: boundedDetail,
+  };
+}
+// mergeModelUsage — fold one model_usage map into another, in place, so a
+// session's tokens can be summed across the several transcripts one session
+// actually writes (the interactive thread + its subagent subtree — task
+// 1003435). PURE apart from mutating `target`, which the caller owns. The four
+// buckets are the session_records model_usage shape, NOT the transcript
+// *_input_tokens shape; keep them in step with buildSessionDigest above.
+function mergeModelUsage(target, addition) {
+  for (const [model, u] of Object.entries(addition || {})) {
+    const bucket = target[model] || (target[model] =
+      { input: 0, output: 0, cache_read: 0, cache_creation: 0 });
+    bucket.input += Number(u && u.input) || 0;
+    bucket.output += Number(u && u.output) || 0;
+    bucket.cache_read += Number(u && u.cache_read) || 0;
+    bucket.cache_creation += Number(u && u.cache_creation) || 0;
+  }
+  return target;
+}
+
+module.exports = { snippetOf, buildSessionDigest, mergeModelUsage, HARNESS_RETRY_RE, UNATTRIBUTED_MODEL };

package/scripts/bongos/session-digest.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+// scripts/bongos/session-digest.js — BFG 6D session capture on the SessionEnd seam
+// (ADR 0027; follow-up to #608/#617, idea #178).
+//
+// Uploads the FULL session digest to the BFG corpus (POST /api/bongos/sessions)
+// when a Claude Code session ENDS. Wired as a SessionEnd hook in
+// .claude/settings.json (sibling to session-cost.js), which pipes
+// { session_id, transcript_path, cwd, reason } as JSON on stdin.
+//
+// WHY (not just /builder-ship): the on-ship upload (ship.js) fires MID-session,
+// so it misses everything after the last ship — merge-mode landings, cleanup,
+// late work. SessionEnd fires once at the very end with the complete transcript,
+// so the corpus row reflects the WHOLE session.
+//
+// ONE RECORD PER SESSION (the invariant Lars asked to preserve): the server
+// upserts on session_id (UNIQUE) — task_ids UNION, detail/metrics/tokens
+// OVERWRITTEN. So this end-of-session upload UPDATES the single existing session
+// row in place to the final state; it never creates a duplicate "5th log".
+//
+// The transcript_path comes straight from the hook, so there is no path-guessing
+// (sidesteps the worktree-path class of bug #551 entirely).
+//
+// CONTRACT (mirrors session-cost.js): best-effort, NON-FATAL, idempotent.
+//   - exits 0 on every path (a SessionEnd hook must never break session exit).
+//   - no GDS session / missing transcript / network error → quiet skip.
+//   - idempotent: the upsert refreshes the one session row; re-running is safe.
+//   - complements (does NOT replace) the on-ship upload — SessionEnd is
+//     best-effort and a hard crash/kill can skip it.
+//
+// Also runnable by hand:
+//   node scripts/bongos/session-digest.js --transcript <path> [--session <id>]
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { cliClient, loadSession, arg } = require('./cli-lib');
+const { uploadSessionTranscript } = require('./session-transcript-upload');
+const { buildSessionDigest, collectEnvSecrets, foldSubagentUsage } = require('./ship');
+
+
+// Claude Code encodes a project transcript dir by replacing every non-alnum
+// char in the cwd with '-' (matches session-cost.js).
+function encodeCwd(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
+// parseHookInput — PURE. Resolve { transcriptPath, sessionId, cwd } from the
+// SessionEnd stdin payload + explicit CLI args (args win over stdin). No I/O, so
+// it is unit-tested (tests/session_digest.mjs). A non-JSON / empty stdin falls
+// back to the provided args.
+function parseHookInput(stdinRaw, opts = {}) {
+  let transcriptPath = opts.transcriptArg || null;
+  let sessionId = opts.sessionArg || null;
+  let cwd = opts.cwd || null;
+  if (stdinRaw) {
+    try {
+      const hook = JSON.parse(stdinRaw);
+      transcriptPath = transcriptPath || hook.transcript_path || null;
+      sessionId = sessionId || hook.session_id || null;
+      if (hook.cwd) cwd = hook.cwd;
+    } catch (_) {
+      /* not JSON — ignore, keep the args */
+    }
+  }
+  return { transcriptPath, sessionId, cwd };
+}
+
+// Fallback ONLY — the SessionEnd hook always supplies transcript_path, so this
+// runs just for a manual/hand invocation with no --transcript. n is bounded (a
+// project's transcript count) and this is a one-shot hook process, never a
+// server loop, so the per-file statSync is fine here.
+function newestTranscriptFor(cwd) {
+  const dir = path.join(os.homedir(), '.claude', 'projects', encodeCwd(cwd));
+  let files;
+  try {
+    files = fs.readdirSync(dir).filter((f) => f.endsWith('.jsonl'));
+  } catch (_) {
+    return null;
+  }
+  if (!files.length) return null;
+  const withMtime = files.map((f) => {
+    const full = path.join(dir, f);
+    return { full, mtime: fs.statSync(full).mtimeMs };
+  });
+  withMtime.sort((a, b) => b.mtime - a.mtime);
+  return withMtime[0].full;
+}
+
+// Read piped stdin (the SessionEnd hook payload); null on a TTY / nothing piped.
+function readStdin() {
+  return new Promise((resolve) => {
+    if (process.stdin.isTTY) return resolve(null);
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (c) => { data += c; });
+    process.stdin.on('end', () => resolve(data || null));
+    // guard: non-TTY but not actually piped — don't hang
+    setTimeout(() => resolve(data || null), 400);
+  });
+}
+
+function parseTranscript(transcriptPath) {
+  const raw = fs.readFileSync(transcriptPath, 'utf8');
+  const entries = [];
+  for (const line of raw.split('\n')) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      entries.push(JSON.parse(t));
+    } catch (_) {
+      /* skip a malformed line — best-effort */
+    }
+  }
+  return entries;
+}
+
+async function main() {
+  // Watchdog: a SessionEnd hook must never stall session exit. If the read or
+  // POST hangs (slow/offline network — fetch has no default timeout), bail. 25s,
+  // not the old 6s, because the full transcript (ADR 0051, up to ~12 MB) now
+  // uploads after the digest; the .claude/settings.json hook timeout (30s) is the
+  // outer bound, and a hang still just drops the upload, never blocks exit.
+  const watchdog = setTimeout(() => process.exit(0), 25000);
+  watchdog.unref();
+  try {
+    const stdinRaw = await readStdin();
+    let { transcriptPath, sessionId, cwd } = parseHookInput(stdinRaw, {
+      transcriptArg: arg('--transcript'),
+      sessionArg: arg('--session'),
+      cwd: process.cwd(),
+    });
+
+    if (!transcriptPath) transcriptPath = newestTranscriptFor(cwd || process.cwd());
+    if (!transcriptPath || !fs.existsSync(transcriptPath)) return; // nothing to capture
+    if (!sessionId) sessionId = path.basename(transcriptPath, '.jsonl');
+
+    // No GDS session → nothing to attribute the digest to; skip quietly.
+    const session = await loadSession();
+    if (!session || !session.token) return;
+
+    // Secret hygiene: buildSessionDigest (ship.js) is the PRIMARY scrubber — it
+    // redacts known secret PATTERNS + a high-entropy catch-all (task 1003).
+    // extraSecrets is defense-in-depth: literal dynamic values that wouldn't
+    // match a static shape — every secret-shaped env VALUE (Apple/MAC_* CI creds,
+    // baked GDS/DO token, ANTHROPIC_API_KEY, …) + this run's GDS session token.
+    // Mirrors ship.js's uploadSessionOnShip exactly — the same proven path.
+    const extraSecrets = collectEnvSecrets();
+    if (session.token) extraSecrets.push(session.token);
+
+    const entries = parseTranscript(transcriptPath);
+    const digest = buildSessionDigest(entries, { extraSecrets });
+    // task 1003435: fold this session's subagents subtree into model_usage, the
+    // same way the on-ship upload does — the whole session's tokens, not just the
+    // interactive thread's.
+    foldSubagentUsage(digest, transcriptPath, sessionId);
+
+    // task_ids:[] — the server upsert UNIONs task_ids, so the on-ship task
+    // attribution is preserved; this end-of-session upload's job is to refresh
+    // the digest to the COMPLETE session, not to (re)assign tasks.
+    const payload = {
+      session_id: sessionId,
+      task_ids: [],
+      total_tokens: digest.totalTokens,
+      duration_seconds: digest.durationSeconds,
+      started_at: digest.startedAt,
+      ended_at: digest.endedAt,
+      detail: digest.detail,
+      metrics: digest.metrics,
+      // model_usage is its OWN column, and the upsert overwrites it from the
+      // body — so omitting it here (as this hook did until task 1003435) wiped
+      // the map the on-ship upload had just stored, leaving the reward with
+      // nothing to price. It is the LAST upload of the session, so it must carry
+      // the fullest picture, not the emptiest.
+      model_usage: digest.metrics.model_usage || {},
+    };
+    const api = await cliClient({ allowUnauthenticated: true });
+    const r = await api.sessions.postSessions({ body: payload });
+    if (r && r.ok) {
+      console.error(
+        `session-digest: stored full session (${digest.metrics.assistant_turns} turns, ${digest.totalTokens} tokens, ${digest.metrics.tool_error_count} tool errors).`
+      );
+      // ADR 0051: every session's FULL scrubbed transcript, after the digest (the
+      // server builds the transcript row from the digest's). Non-fatal.
+      console.error(`session-digest: ${await uploadSessionTranscript(api, sessionId, entries, extraSecrets)}`);
+    } else {
+      console.error(`session-digest: skipped (POST ${r && r.status}${r && r.data && r.data.error ? ' ' + r.data.error : ''}).`);
+    }
+  } catch (e) {
+    console.error('session-digest: skipped —', e && e.message ? e.message : e);
+  } finally {
+    return;
+  }
+}
+
+// Drain instead of process.exit(): an exit while a socket/child handle is still closing aborts node on
+// Windows (UV_HANDLE_CLOSING, src\win\async.c) — 59 SessionStart/UserPromptSubmit runs died that way
+// (task 1003548). The unref'd backstop only fires if a hung request keeps the loop alive.
+if (require.main === module) main().catch(() => {}).finally(() => { process.exitCode = 0; setTimeout(() => process.exit(0), 1500).unref(); });
+
+module.exports = { parseHookInput };