@sonnechasser/ntrp 0.2.2 → 0.3.0

package/dist/services/transcript-smoke.js

@@ -0,0 +1,897 @@
+#!/usr/bin/env node
+process.noDeprecation = true;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/output/formatters.ts
+function formatCurrency(value) {
+  if (value >= 1e6) return `$${(value / 1e6).toFixed(1)}M`;
+  if (value >= 1e3) return `$${(value / 1e3).toFixed(0)}K`;
+  return `$${value.toFixed(0)}`;
+}
+var VITAL_SIGN_LABELS;
+var init_formatters = __esm({
+  "src/output/formatters.ts"() {
+    "use strict";
+    VITAL_SIGN_LABELS = {
+      freshness: "Freshness",
+      flow_rate: "Flow Rate",
+      drop_rate: "Drop Rate",
+      signal_to_noise: "Signal:Noise",
+      thread_depth: "Thread Depth"
+    };
+  }
+});
+
+// src/services/transcript-smoke.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
+import { join as join3 } from "path";
+
+// src/services/terminal-capture.ts
+var MAX_LINES_DEFAULT = 2e4;
+var DROP_CHUNK = 500;
+var ANSI_ANY = (
+  // eslint-disable-next-line no-control-regex
+  /\x1B(?:\[[0-9;?]*[ -/]*[@-~]|\][^\x07\x1B]*(?:\x07|\x1B\\)?|[()][0-9A-Za-z]|[@-Z\\-_=><])/g
+);
+function stripAnsi(value) {
+  return value.replace(ANSI_ANY, "").replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+}
+var SECRET_PATTERNS = [
+  /\bsk-ant-[A-Za-z0-9_-]{8,}/g,
+  // Anthropic
+  /\bsk-or-[A-Za-z0-9_-]{8,}/g,
+  // OpenRouter
+  /\bsk-proj-[A-Za-z0-9_-]{8,}/g,
+  // OpenAI project keys
+  /\bsk-[A-Za-z0-9_-]{20,}/g,
+  // OpenAI / generic sk-
+  /\bgsk_[A-Za-z0-9_-]{8,}/g,
+  // Groq
+  /\bxai-[A-Za-z0-9_-]{8,}/g,
+  // xAI
+  /\bfw_[A-Za-z0-9_-]{8,}/g,
+  // Fireworks
+  /\bAIza[A-Za-z0-9_-]{10,}/g,
+  // Google
+  /\bNTRP-[A-Z0-9][A-Z0-9-]{8,}/g
+  // license keys
+];
+function redactSecrets(line) {
+  let out = line;
+  for (const pattern of SECRET_PATTERNS) {
+    out = out.replace(pattern, (m) => `${m.slice(0, 6)}\u2026[redacted]`);
+  }
+  return out;
+}
+var SCREEN_CLEAR_MARKER = "\u2500\u2500 screen cleared \u2500\u2500";
+var TerminalCapture = class {
+  constructor(maxLines = MAX_LINES_DEFAULT) {
+    this.maxLines = maxLines;
+  }
+  maxLines;
+  lines = [];
+  cur = "";
+  col = 0;
+  /** Partial escape sequence held across chunk boundaries. */
+  carry = "";
+  /** A bare \r at a chunk boundary — CRLF vs overwrite is decided by the next char. */
+  pendingCr = false;
+  dropped = 0;
+  /** Feed a raw chunk of terminal output. */
+  feed(chunk) {
+    const data = this.carry + chunk;
+    this.carry = "";
+    let i = 0;
+    while (i < data.length) {
+      const c = data[i];
+      if (this.pendingCr) {
+        this.pendingCr = false;
+        if (c === "\n") {
+          this.newline();
+          i++;
+          continue;
+        }
+        this.col = 0;
+      }
+      if (c === "\n") {
+        this.newline();
+        i++;
+        continue;
+      }
+      if (c === "\r") {
+        this.pendingCr = true;
+        i++;
+        continue;
+      }
+      if (c === "\x1B") {
+        const consumed = this.consumeEscape(data, i);
+        if (consumed === -1) {
+          this.carry = data.slice(i);
+          return;
+        }
+        i += consumed;
+        continue;
+      }
+      if (c === "\b") {
+        this.col = Math.max(0, this.col - 1);
+        i++;
+        continue;
+      }
+      if (c === "	") {
+        const next = Math.floor(this.col / 8) * 8 + 8;
+        while (this.col < next) this.writeChar(" ");
+        i++;
+        continue;
+      }
+      if (c < " " || c === "\x7F") {
+        i++;
+        continue;
+      }
+      this.writeChar(c);
+      i++;
+    }
+  }
+  /** Append a standalone line (operator input markers, section notes). */
+  note(line) {
+    this.commit(line);
+  }
+  /** Committed lines + the in-progress line (e.g. a live spinner row). */
+  snapshot() {
+    const out = [...this.lines];
+    if (this.cur.trim().length > 0) out.push(this.cur.trimEnd());
+    return out;
+  }
+  /** Lines evicted from the front once maxLines was exceeded. */
+  get droppedLineCount() {
+    return this.dropped;
+  }
+  // ----------------------------------------------------------
+  writeChar(c) {
+    if (this.col < this.cur.length) {
+      this.cur = this.cur.slice(0, this.col) + c + this.cur.slice(this.col + 1);
+    } else {
+      this.cur = this.cur.padEnd(this.col, " ") + c;
+    }
+    this.col++;
+  }
+  newline() {
+    this.commit(this.cur.trimEnd());
+    this.cur = "";
+    this.col = 0;
+  }
+  commit(line) {
+    this.lines.push(line);
+    if (this.lines.length > this.maxLines) {
+      this.lines.splice(0, DROP_CHUNK);
+      this.dropped += DROP_CHUNK;
+    }
+  }
+  /**
+   * Consume one escape sequence starting at data[start] (which is ESC).
+   * Returns the number of chars consumed, or -1 if the sequence is
+   * incomplete at the end of the chunk.
+   */
+  consumeEscape(data, start) {
+    if (start + 1 >= data.length) return -1;
+    const kind = data[start + 1];
+    if (kind === "[") {
+      let i = start + 2;
+      while (i < data.length && /[0-9;?]/.test(data[i])) i++;
+      while (i < data.length && data[i] >= " " && data[i] <= "/") i++;
+      if (i >= data.length) return -1;
+      const final = data[i];
+      const params = data.slice(start + 2, i).replace(/[?]/g, "");
+      this.applyCsi(params, final);
+      return i - start + 1;
+    }
+    if (kind === "]") {
+      let i = start + 2;
+      while (i < data.length) {
+        if (data[i] === "\x07") return i - start + 1;
+        if (data[i] === "\x1B" && data[i + 1] === "\\") return i - start + 2;
+        i++;
+      }
+      return -1;
+    }
+    if (kind === "(" || kind === ")") {
+      if (start + 2 >= data.length) return -1;
+      return 3;
+    }
+    return 2;
+  }
+  applyCsi(params, final) {
+    const first = Number.parseInt(params.split(";")[0] ?? "", 10);
+    const n = Number.isFinite(first) ? first : void 0;
+    switch (final) {
+      case "K":
+        if (n === 2) {
+          this.cur = "";
+        } else if (n === 1) {
+          const keep = this.cur.slice(this.col);
+          this.cur = " ".repeat(Math.min(this.col, this.cur.length)) + keep;
+        } else {
+          this.cur = this.cur.slice(0, this.col);
+        }
+        break;
+      case "G":
+        this.col = Math.max(0, (n ?? 1) - 1);
+        break;
+      case "J":
+        if (n === 2 || n === 3) {
+          if (this.cur.trim().length > 0) this.commit(this.cur.trimEnd());
+          this.commit(SCREEN_CLEAR_MARKER);
+          this.cur = "";
+          this.col = 0;
+        } else {
+          this.cur = this.cur.slice(0, this.col);
+        }
+        break;
+      case "C":
+        this.col += n ?? 1;
+        break;
+      case "D":
+        this.col = Math.max(0, this.col - (n ?? 1));
+        break;
+      case "E":
+      // next line
+      case "F":
+        this.col = 0;
+        break;
+      case "H":
+      // cursor home (row ignored — single-row model)
+      case "f":
+        this.col = 0;
+        break;
+      default:
+        break;
+    }
+  }
+};
+
+// src/services/transcript.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3, rmSync as rmSync2 } from "fs";
+import { join as join2 } from "path";
+
+// src/cli/context.ts
+import { basename, join, resolve, sep } from "path";
+import { existsSync, mkdirSync, writeFileSync as writeFileSync2, readFileSync, readdirSync, statSync, rmSync } from "fs";
+import { homedir } from "os";
+import { randomUUID } from "crypto";
+
+// src/services/context-doc.ts
+import { writeFileSync } from "fs";
+init_formatters();
+var AGENT_EXCERPT_CHARS = 400;
+function buildSessionContextDoc(file, opts = {}) {
+  const id = file.id;
+  const shortId = id.slice(-4);
+  const exchanges = file.exchange_count ?? Math.floor(file.messages.length / 2);
+  const lines = [];
+  lines.push(`# Session context \u2014 ${id}${file.name ? ` (${file.name})` : ""}`);
+  lines.push("");
+  lines.push("## Status");
+  lines.push("");
+  lines.push(`- Stage: ${file.stage ?? "new"}`);
+  lines.push(`- Created: ${file.created_at}`);
+  if (file.ended_at) lines.push(`- Ended: ${file.ended_at}`);
+  lines.push(`- Updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`- Exchanges: ${exchanges}`);
+  if (file.summary) lines.push(`- Summary: ${file.summary}`);
+  if (file.resumed_from) lines.push(`- Resumed from: ${file.resumed_from}`);
+  lines.push("");
+  lines.push("## Dataset");
+  lines.push("");
+  if (file.dataset?.label || file.dataset?.source) {
+    lines.push(`- Label: ${file.dataset.label ?? "(unlabeled)"}`);
+    if (file.dataset.source) lines.push(`- Source: ${file.dataset.source}`);
+    if (file.dataset.ingested_at) lines.push(`- Ingested: ${file.dataset.ingested_at}`);
+    const counts = Object.entries(file.dataset.counts ?? {}).filter(([, n]) => n > 0);
+    if (counts.length > 0) {
+      lines.push(`- Counts: ${counts.map(([k, n]) => `${n.toLocaleString()} ${k}`).join(", ")}`);
+    }
+  } else {
+    lines.push("- No data loaded.");
+  }
+  if (file.attachments && file.attachments.length > 0) {
+    for (const a of file.attachments) {
+      const detail = [a.entity_type, a.row_count != null ? `${a.row_count} rows` : null].filter(Boolean).join(", ");
+      lines.push(`- Attachment: ${a.path}${detail ? ` (${detail})` : ""}`);
+    }
+  }
+  lines.push("");
+  if (file.scope) {
+    lines.push("## Scope");
+    lines.push("");
+    lines.push(`- Intent: ${file.scope.intent_summary}`);
+    lines.push(`- Lens: ${file.scope.primary_lens}`);
+    if (file.scope.audience) lines.push(`- Audience: ${file.scope.audience}`);
+    if (file.scope.time_horizon) lines.push(`- Time horizon: ${file.scope.time_horizon}`);
+    if (file.scope.segments?.length) lines.push(`- Segments: ${file.scope.segments.join(", ")}`);
+    if (file.scope.confirmed_at) lines.push(`- Confirmed: ${file.scope.confirmed_at}`);
+    lines.push("");
+  }
+  lines.push("## Analysis");
+  lines.push("");
+  if (file.analysis) {
+    lines.push(`- Primary lens: ${file.analysis.primary}`);
+    lines.push(`- Completed: ${file.analysis.completed.join(", ") || "none"}`);
+    if (file.analysis.coverage) {
+      lines.push(
+        `- Coverage: ${file.analysis.coverage.distinct_months} months \xB7 recommended cadence ${file.analysis.coverage.recommended_cadence}`
+      );
+    }
+    if (file.analysis.data_source_type) {
+      lines.push(`- Data source type: ${file.analysis.data_source_type}`);
+    }
+    if (file.analysis.headline?.length) {
+      lines.push("");
+      lines.push("### Headline metrics");
+      lines.push("");
+      for (const h of file.analysis.headline) {
+        lines.push(`- ${h.label}: ${h.formatted}`);
+      }
+    }
+  } else {
+    lines.push("- No analysis recorded.");
+  }
+  const health = opts.snapshot?.aggregate;
+  if (health) {
+    lines.push("");
+    lines.push("### GTM health snapshot");
+    lines.push("");
+    lines.push(`- Overall: ${Math.round(health.overall_score)} (${health.overall_status})`);
+    lines.push(`- Gating vital sign: ${health.gating_vital_sign.replace(/_/g, " ")}`);
+    if (health.total_value_at_risk != null && health.total_value_at_risk > 0) {
+      lines.push(`- Total value at risk: ${formatCurrency(health.total_value_at_risk)}`);
+    }
+    for (const vs of health.vital_signs) {
+      const label = VITAL_SIGN_LABELS[vs.vital_sign] ?? vs.vital_sign;
+      const dollars = vs.dollar_value != null ? ` \u2014 ${formatCurrency(vs.dollar_value)}${vs.dollar_label ? ` ${vs.dollar_label}` : ""}` : "";
+      lines.push(`- ${label}: ${Math.round(vs.score)} (${vs.status})${dollars}`);
+    }
+  }
+  lines.push("");
+  if (file.strategist) {
+    lines.push("## Strategist (in flight)");
+    lines.push("");
+    lines.push(`- Step: ${file.strategist.step}`);
+    if (file.strategist.objective) lines.push(`- Objective: ${file.strategist.objective}`);
+    if (file.strategist.constraintsNote) {
+      lines.push(`- Constraints: ${file.strategist.constraintsNote}`);
+    }
+    if (file.strategist.origin) lines.push(`- Origin: ${file.strategist.origin}`);
+    lines.push("");
+  }
+  lines.push("## Deliverables");
+  lines.push("");
+  if (file.deliverables && file.deliverables.length > 0) {
+    for (const d of file.deliverables) {
+      const detail = [d.path, d.note].filter(Boolean).join(" \u2014 ");
+      lines.push(`- ${d.kind} (${d.at})${detail ? `: ${detail}` : ""}`);
+    }
+  } else {
+    lines.push("- None yet.");
+  }
+  lines.push("");
+  lines.push(`## Conversation (${exchanges} exchange${exchanges === 1 ? "" : "s"})`);
+  lines.push("");
+  if (file.messages.length === 0) {
+    lines.push("- No exchanges yet.");
+  } else {
+    let n = 0;
+    for (const msg of file.messages) {
+      if (msg.role === "user") {
+        n++;
+        lines.push(`${n}. \u276F ${excerpt(msg.content, AGENT_EXCERPT_CHARS)}`);
+      } else {
+        lines.push(`   \u21B3 ${excerpt(msg.content, AGENT_EXCERPT_CHARS)}`);
+      }
+    }
+  }
+  lines.push("");
+  lines.push("## Files");
+  lines.push("");
+  lines.push(`- Transcript (raw terminal): \`${transcriptPathForSession(id)}\``);
+  lines.push(`- Session data (JSON): \`${sessionJsonPath(id)}\``);
+  lines.push(`- Dataset (DuckDB): \`${datasetPathForSession(id)}\``);
+  lines.push("");
+  lines.push("## Pick up this session");
+  lines.push("");
+  lines.push(`Run \`ntrp\`, then \`/session ${shortId}\` \u2014 rebinds the dataset and reloads the`);
+  lines.push("conversation thread in place. Read the transcript above for the full terminal");
+  lines.push("history before continuing.");
+  lines.push("");
+  return lines.map(redactSecrets).join("\n");
+}
+function excerpt(content, max) {
+  const flat = content.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function sessionJsonPath(id) {
+  return `${getSessionsDir()}/${id}.json`;
+}
+function writeSessionContextDoc(ctx) {
+  if (ctx.oneShot) return;
+  try {
+    const file = buildSessionFileSnapshot(ctx);
+    const doc2 = buildSessionContextDoc(file, { snapshot: ctx.snapshot.computeResult });
+    writeFileSync(contextDocPathForSession(ctx.sessionId), doc2);
+  } catch {
+  }
+}
+
+// src/cli/context.ts
+var STALE_SESSION_MS = 14 * 24 * 60 * 60 * 1e3;
+function ntrpHomeDir() {
+  return process.env.NTRP_HOME ? resolve(process.env.NTRP_HOME) : join(homedir(), ".ntrp");
+}
+function getSessionsDir() {
+  const dir = join(ntrpHomeDir(), "sessions");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getDatasetsDir() {
+  const dir = join(ntrpHomeDir(), "datasets");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function datasetPathForSession(id) {
+  return join(getDatasetsDir(), `${id}.duckdb`);
+}
+function transcriptPathForSession(id) {
+  return join(getSessionsDir(), `${id}.transcript.md`);
+}
+function contextDocPathForSession(id) {
+  return join(getSessionsDir(), `${id}.context.md`);
+}
+function buildSessionFileSnapshot(ctx) {
+  const file = {
+    id: ctx.sessionId,
+    created_at: ctx.messages[0]?.at ?? (/* @__PURE__ */ new Date()).toISOString(),
+    messages: ctx.messages,
+    stage: ctx.stage
+  };
+  if (ctx.sessionName) file.name = ctx.sessionName;
+  if (ctx.dataset) file.dataset = ctx.dataset;
+  if (ctx.deliverables.length > 0) file.deliverables = ctx.deliverables;
+  if (ctx.conversation.length > 0) file.thread = ctx.conversation;
+  if (ctx.resumedFromId) file.resumed_from = ctx.resumedFromId;
+  if (ctx.analysis) file.analysis = ctx.analysis;
+  if (ctx.scope) file.scope = ctx.scope;
+  if (ctx.attachments && ctx.attachments.length > 0) file.attachments = ctx.attachments;
+  if (ctx.llm && Object.keys(ctx.llm).length > 0) file.llm = ctx.llm;
+  if (ctx.strategistState) file.strategist = ctx.strategistState;
+  return file;
+}
+function defaultSessionAnalysis(primary = "gtm_health") {
+  return { primary, completed: [] };
+}
+
+// src/services/transcript.ts
+var FLUSH_THROTTLE_MS = 250;
+var FLUSH_MAX_STALENESS_MS = 900;
+var state = null;
+var originalStdoutWrite = null;
+var originalStderrWrite = null;
+function startSessionTranscript(ctx) {
+  if (ctx.oneShot || state) return;
+  installTees();
+  state = createState(ctx.sessionId);
+  flushNow();
+}
+function rebindSessionTranscript(ctx) {
+  if (!state || state.sessionId === ctx.sessionId) return;
+  const priorJson = join2(getSessionsDir(), `${state.sessionId}.json`);
+  if (existsSync2(priorJson)) {
+    finalizeCurrentFile("switched session");
+  } else {
+    discardSessionTranscript(state.sessionId);
+  }
+  state = createState(ctx.sessionId);
+  flushNow();
+}
+function stopSessionTranscript() {
+  if (!state) return;
+  finalizeCurrentFile("session closed");
+  state = null;
+  removeTees();
+}
+function discardSessionTranscript(sessionId) {
+  if (state && state.sessionId === sessionId) {
+    state.discarded = true;
+    clearFlushTimer();
+  }
+  try {
+    rmSync2(transcriptPathForSession(sessionId), { force: true });
+  } catch {
+  }
+}
+function pauseTranscriptCapture() {
+  if (state) state.paused = true;
+}
+function resumeTranscriptCapture() {
+  if (state) state.paused = false;
+}
+function noteTranscriptInput(promptLabel, input) {
+  if (!state || state.discarded) return;
+  state.capture.note("");
+  state.capture.note(`\u276F ${stripAnsi(promptLabel)}${input}`.trimEnd());
+  flushNow();
+}
+function isTranscriptActive(sessionId) {
+  if (!state || state.discarded) return false;
+  return sessionId === void 0 || state.sessionId === sessionId;
+}
+function installTees() {
+  if (originalStdoutWrite) return;
+  originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  originalStderrWrite = process.stderr.write.bind(process.stderr);
+  const tee = (original) => (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ((chunk, encoding, callback) => {
+      try {
+        if (state && !state.paused && !state.discarded) {
+          const text = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf-8") : String(chunk);
+          state.capture.feed(text);
+          scheduleFlush();
+        }
+      } catch {
+      }
+      return original(chunk, encoding, callback);
+    })
+  );
+  process.stdout.write = tee(originalStdoutWrite);
+  process.stderr.write = tee(originalStderrWrite);
+}
+function removeTees() {
+  if (originalStdoutWrite) {
+    process.stdout.write = originalStdoutWrite;
+    originalStdoutWrite = null;
+  }
+  if (originalStderrWrite) {
+    process.stderr.write = originalStderrWrite;
+    originalStderrWrite = null;
+  }
+}
+function createState(sessionId) {
+  const filePath = transcriptPathForSession(sessionId);
+  let base = "";
+  if (existsSync2(filePath)) {
+    try {
+      base = readFileSync2(filePath, "utf-8").trimEnd() + "\n";
+    } catch {
+      base = "";
+    }
+  }
+  return {
+    sessionId,
+    filePath,
+    base,
+    segmentStartedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    capture: new TerminalCapture(),
+    paused: false,
+    discarded: false,
+    lastFlushMs: 0,
+    flushTimer: null
+  };
+}
+function renderHeader(sessionId) {
+  return [
+    `# ntrp transcript \u2014 ${sessionId}`,
+    "",
+    `- Session data: \`${sessionId}.json\` \xB7 Context brief: \`${sessionId}.context.md\``,
+    "- Raw terminal text (ANSI stripped, spinner frames collapsed). Lines starting with `\u276F` are operator input.",
+    "",
+    ""
+  ].join("\n");
+}
+function renderSegment(s, closedNote) {
+  const lines = s.capture.snapshot().map(redactSecrets);
+  const dropped = s.capture.droppedLineCount;
+  let longestRun = 0;
+  for (const line of lines) {
+    for (const match of line.matchAll(/`+/g)) {
+      if (match[0].length > longestRun) longestRun = match[0].length;
+    }
+  }
+  const fence = "`".repeat(Math.max(3, longestRun + 1));
+  const heading = s.base ? `## Continued \u2014 ${s.segmentStartedAt}` : `## Session start \u2014 ${s.segmentStartedAt}`;
+  const parts = [heading, ""];
+  if (dropped > 0) {
+    parts.push(`_(${dropped.toLocaleString()} earlier lines dropped to bound file size)_`, "");
+  }
+  parts.push(`${fence}text`, ...lines, fence, "");
+  parts.push(
+    closedNote ? `_Closed: ${(/* @__PURE__ */ new Date()).toISOString()} (${closedNote})_` : `_Last write: ${(/* @__PURE__ */ new Date()).toISOString()}_`
+  );
+  parts.push("");
+  return parts.join("\n");
+}
+function render(s, closedNote) {
+  const prefix = s.base ? s.base + "\n" : renderHeader(s.sessionId);
+  return prefix + renderSegment(s, closedNote);
+}
+function flushNow(closedNote) {
+  const s = state;
+  if (!s || s.discarded) return;
+  clearFlushTimer();
+  s.lastFlushMs = Date.now();
+  try {
+    getSessionsDir();
+    writeFileSync3(s.filePath, render(s, closedNote));
+  } catch {
+  }
+}
+function scheduleFlush() {
+  const s = state;
+  if (!s || s.discarded) return;
+  if (Date.now() - s.lastFlushMs >= FLUSH_MAX_STALENESS_MS) {
+    flushNow();
+    return;
+  }
+  if (s.flushTimer) return;
+  s.flushTimer = setTimeout(() => {
+    if (state) state.flushTimer = null;
+    flushNow();
+  }, FLUSH_THROTTLE_MS);
+  s.flushTimer.unref?.();
+}
+function clearFlushTimer() {
+  if (state?.flushTimer) {
+    clearTimeout(state.flushTimer);
+    state.flushTimer = null;
+  }
+}
+function finalizeCurrentFile(reason) {
+  if (!state) return;
+  clearFlushTimer();
+  if (!state.discarded) flushNow(reason);
+}
+
+// src/services/transcript-smoke.ts
+var failures = [];
+function assert(cond, msg) {
+  if (!cond) failures.push(msg);
+}
+{
+  const cap = new TerminalCapture();
+  cap.feed("plain line\n");
+  cap.feed("\x1B[31mcolored\x1B[39m line\n");
+  assert(cap.snapshot()[0] === "plain line", "plain line committed");
+  assert(cap.snapshot()[1] === "colored line", "SGR color codes removed");
+}
+{
+  const cap = new TerminalCapture();
+  cap.feed("\u280B Computing vitals\u2026");
+  cap.feed("\x1B[1G\x1B[2K\u2819 Computing vitals\u2026");
+  cap.feed("\x1B[1G\x1B[2K\u2714 Vitals computed\n");
+  const lines = cap.snapshot();
+  assert(lines.length === 1 && lines[0] === "\u2714 Vitals computed", `spinner frames collapse (got ${JSON.stringify(lines)})`);
+}
+{
+  const cap = new TerminalCapture();
+  cap.feed("abc\r\n");
+  cap.feed("abc\rxyz\n");
+  const lines = cap.snapshot();
+  assert(lines[0] === "abc", "CRLF commits the line unchanged");
+  assert(lines[1] === "xyz", "bare CR overwrites from column 0");
+}
+{
+  const cap = new TerminalCapture();
+  cap.feed("abc\r");
+  cap.feed("\n");
+  cap.feed("def\r");
+  cap.feed("z\n");
+  const lines = cap.snapshot();
+  assert(lines[0] === "abc", "chunk-split CRLF still one line");
+  assert(lines[1] === "zef", "chunk-split CR overwrite applies at col 0");
+}
+{
+  const cap = new TerminalCapture();
+  cap.feed("temp");
+  cap.feed("\x1B[");
+  cap.feed("2K\x1B[1Gfinal\n");
+  assert(cap.snapshot()[0] === "final", "chunk-split CSI erase applied");
+}
+{
+  const cap = new TerminalCapture();
+  cap.feed("abcdef\x1B[3G\x1B[0K123\n");
+  assert(cap.snapshot()[0] === "ab123", "cursor-column + erase-right repaint");
+}
+{
+  const cap = new TerminalCapture();
+  cap.feed("abcd\b\b  \n");
+  assert(cap.snapshot()[0] === "ab", "backspace + space erase");
+}
+{
+  const cap = new TerminalCapture();
+  cap.feed("before\n\x1B[2J\x1B[Hafter\n");
+  const lines = cap.snapshot();
+  assert(lines[0] === "before", "history preserved across screen clear");
+  assert(lines[1] === SCREEN_CLEAR_MARKER, "screen clear marker inserted");
+  assert(lines[2] === "after", "output continues after clear");
+}
+{
+  const cap = new TerminalCapture();
+  cap.feed("\x1B]0;ntrp\x07hello\x07 world");
+  const lines = cap.snapshot();
+  assert(lines[0] === "hello world", "OSC + BEL dropped, live line in snapshot");
+  cap.note("\u276F ntrp \u203A use demo data");
+  assert(cap.snapshot().includes("\u276F ntrp \u203A use demo data"), "note() appends standalone line");
+}
+{
+  const cap = new TerminalCapture(600);
+  for (let i = 0; i < 1200; i++) cap.feed(`line ${i}
+`);
+  assert(cap.droppedLineCount > 0, "old lines dropped past cap");
+  assert(cap.snapshot().length <= 700, "snapshot bounded");
+}
+assert(stripAnsi("\x1B[2mdim\x1B[22m \x1B]0;t\x07x") === "dim x", "stripAnsi removes CSI + OSC");
+assert(
+  redactSecrets("key sk-ant-api03-abcdefghijklmnop end").includes("sk-ant\u2026[redacted]"),
+  "anthropic key redacted"
+);
+assert(!redactSecrets("gsk_abcdefghijklmnop").includes("abcdefghijklmnop"), "groq key redacted");
+assert(
+  redactSecrets("NTRP-AAAA-BBBB-CCCC-DDDD").includes("NTRP-A\u2026[redacted]"),
+  "license key redacted"
+);
+assert(redactSecrets("normal text $3.1M at risk") === "normal text $3.1M at risk", "plain text untouched");
+var sessionFile = {
+  id: "2026-07-29-ab12",
+  created_at: "2026-07-29T10:00:00.000Z",
+  stage: "analyzed",
+  name: "board-prep",
+  dataset: {
+    label: "hidden_crisis demo",
+    source: "demo:hidden_crisis",
+    counts: { contacts: 4200, opportunities: 310 },
+    ingested_at: "2026-07-29T10:01:00.000Z"
+  },
+  scope: {
+    intent_summary: "Is our retention real for the board?",
+    primary_lens: "revenue_metrics",
+    audience: "board"
+  },
+  analysis: {
+    primary: "revenue_metrics",
+    completed: ["revenue_metrics"],
+    headline: [
+      { metric: "arr", label: "ARR", formatted: "$8.5M" },
+      { metric: "nrr", label: "Net Revenue Retention", formatted: "95%" },
+      { metric: "grr", label: "Gross Revenue Retention", formatted: "76%" }
+    ]
+  },
+  deliverables: [{ kind: "board_deck_prompt", at: "2026-07-29T10:30:00.000Z", path: "/tmp/deck.md" }],
+  messages: [
+    { role: "user", content: "is our retention real for the board?", at: "2026-07-29T10:02:00.000Z" },
+    { role: "agent", content: "Scope confirmed. Data check complete.", at: "2026-07-29T10:02:05.000Z" },
+    { role: "user", content: "what is ARR?", at: "2026-07-29T10:03:00.000Z" },
+    { role: "agent", content: "ARR is $12.4M based on the latest close history. ".repeat(30), at: "2026-07-29T10:03:10.000Z" }
+  ],
+  exchange_count: 2
+};
+var snapshot = {
+  aggregate: {
+    overall_score: 42,
+    overall_status: "red",
+    gating_vital_sign: "freshness",
+    total_value_at_risk: 31e5,
+    vital_signs: [
+      {
+        vital_sign: "freshness",
+        score: 29,
+        status: "red",
+        components: {},
+        entity_details: [],
+        dollar_value: 31e5,
+        dollar_label: "pipeline at risk"
+      }
+    ]
+  },
+  segments: []
+};
+var doc = buildSessionContextDoc(sessionFile, { snapshot });
+assert(doc.includes("# Session context \u2014 2026-07-29-ab12 (board-prep)"), "context doc title + name");
+assert(doc.includes("- Stage: analyzed"), "context doc stage");
+assert(doc.includes("hidden_crisis demo"), "context doc dataset label");
+assert(doc.includes("4,200 contacts"), "context doc entity counts");
+assert(doc.includes("Is our retention real for the board?"), "context doc scope intent");
+assert(doc.includes("- Gating vital sign: freshness"), "context doc gating vital");
+assert(doc.includes("$3.1M pipeline at risk"), "context doc dollar translation");
+assert(doc.includes("### Headline metrics"), "context doc headline section");
+assert(doc.includes("- ARR: $8.5M"), "context doc headline ARR value");
+assert(doc.includes("- Net Revenue Retention: 95%"), "context doc headline NRR value");
+assert(doc.includes("board_deck_prompt"), "context doc deliverable");
+assert(doc.includes("\u276F what is ARR?"), "context doc user question");
+assert(doc.includes("\u2026"), "context doc long agent answer truncated");
+assert(doc.includes("/session ab12"), "context doc pickup hint");
+assert(doc.includes(".transcript.md"), "context doc links transcript");
+function makeCtx(sessionId) {
+  return {
+    sessionId,
+    sessionFile: `${sessionId}.json`,
+    oneShot: false,
+    execution: { mode: "interactive", output: "terminal", progress: true, color: false, strictStdout: false, quiet: false },
+    snapshot: { computeResult: null, divergences: [] },
+    messages: [],
+    conversation: [],
+    stage: "new",
+    deliverables: [],
+    analysis: defaultSessionAnalysis(),
+    wizardDepth: 0,
+    attachments: []
+  };
+}
+var ctxA = makeCtx("2026-07-29-aaaa");
+var ctxB = makeCtx("2026-07-29-bbbb");
+startSessionTranscript(ctxA);
+assert(isTranscriptActive(ctxA.sessionId), "recorder active for session A");
+console.log("hello from session A");
+console.error("stderr also captured");
+console.log("inline key sk-ant-api03-abcdefghijklmnop here");
+pauseTranscriptCapture();
+console.log("PROMPT-ECHO-NOISE-SHOULD-NOT-APPEAR");
+resumeTranscriptCapture();
+noteTranscriptInput("ntrp \u203A ", "use demo data");
+writeFileSync4(join3(getSessionsDir(), `${ctxA.sessionId}.json`), "{}\n");
+writeFileSync4(join3(getSessionsDir(), `${ctxB.sessionId}.json`), "{}\n");
+rebindSessionTranscript(ctxB);
+console.log("hello from session B");
+stopSessionTranscript();
+var fileA = readFileSync3(transcriptPathForSession(ctxA.sessionId), "utf-8");
+var fileB = readFileSync3(transcriptPathForSession(ctxB.sessionId), "utf-8");
+assert(fileA.includes("# ntrp transcript \u2014 2026-07-29-aaaa"), "transcript A header");
+assert(fileA.includes("hello from session A"), "stdout captured in A");
+assert(fileA.includes("stderr also captured"), "stderr captured in A");
+assert(fileA.includes("sk-ant\u2026[redacted]"), "inline key redacted in transcript");
+assert(!fileA.includes("sk-ant-api03-abcdefghijklmnop"), "raw key absent from transcript");
+assert(!fileA.includes("PROMPT-ECHO-NOISE-SHOULD-NOT-APPEAR"), "paused output not captured");
+assert(fileA.includes("\u276F ntrp \u203A use demo data"), "input marker recorded with prompt label");
+assert(fileA.includes("(switched session)"), "A closed with switch note");
+assert(!fileA.includes("hello from session B"), "B output not in A");
+assert(fileB.includes("hello from session B"), "B transcript captured after rebind");
+assert(fileB.includes("(session closed)"), "B closed on stop");
+startSessionTranscript(ctxA);
+console.log("picked this back up");
+stopSessionTranscript();
+var fileA2 = readFileSync3(transcriptPathForSession(ctxA.sessionId), "utf-8");
+assert(fileA2.includes("hello from session A"), "continue keeps prior history");
+assert(fileA2.includes("## Continued \u2014 "), "continue adds Continued segment");
+assert(fileA2.includes("picked this back up"), "continue captures new output");
+var ctxC = makeCtx("2026-07-29-cccc");
+startSessionTranscript(ctxC);
+console.log("ephemeral");
+discardSessionTranscript(ctxC.sessionId);
+stopSessionTranscript();
+assert(!existsSync3(transcriptPathForSession(ctxC.sessionId)), "discarded transcript deleted");
+var ctxE = makeCtx("2026-07-29-eeee");
+var ctxF = makeCtx("2026-07-29-ffff");
+startSessionTranscript(ctxE);
+console.log("throwaway shell before pickup");
+rebindSessionTranscript(ctxF);
+stopSessionTranscript();
+assert(!existsSync3(transcriptPathForSession(ctxE.sessionId)), "unpersisted session transcript discarded on switch");
+var ctxD = makeCtx("2026-07-29-dddd");
+ctxD.messages.push({ role: "user", content: "why is freshness red?", at: (/* @__PURE__ */ new Date()).toISOString() });
+ctxD.messages.push({ role: "agent", content: "Because 61% of contacts are stale.", at: (/* @__PURE__ */ new Date()).toISOString() });
+writeSessionContextDoc(ctxD);
+var docD = readFileSync3(contextDocPathForSession(ctxD.sessionId), "utf-8");
+assert(docD.includes("# Session context \u2014 2026-07-29-dddd"), "live context doc written");
+assert(docD.includes("why is freshness red?"), "live context doc includes exchange");
+if (failures.length > 0) {
+  console.error(`FAIL transcript-smoke (${failures.length}):`);
+  for (const f of failures) console.error(`  - ${f}`);
+  process.exit(1);
+}
+console.log(
+  "PASS transcript-smoke (capture emulator, redaction, context brief, recorder lifecycle)"
+);
+//# sourceMappingURL=transcript-smoke.js.map