codehere 0.6.2 → 0.7.0

package/dist/infrastructure/hooks/claude-sdk-hook.js

@@ -13,7 +13,7 @@
  *
  * Docs: https://docs.anthropic.com/en/docs/claude-code/hooks
  */
-import { appendFileSync, chmodSync, existsSync, mkdirSync, openSync, closeSync, readSync, statSync, readFileSync, unlinkSync, } from 'fs';
+import { appendFileSync, chmodSync, existsSync, mkdirSync, openSync, closeSync, readFileSync, readSync, statSync, unlinkSync, } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { createHash } from 'crypto';
@@ -418,51 +418,6 @@ function canonicalizeForHash(entry) {
 export function computeEntryHash(entry) {
     return createHash('sha256').update(canonicalizeForHash(entry)).digest('hex');
 }
-/**
- * Read the last non-empty line from a file without loading the whole file.
- * Reads in 4 KB chunks from the end until a newline is found. Returns null
- * if the file is empty or unreadable.
- *
- * For audit-log size <100 KB this is fast (single readSync). Even at 10 MB
- * the worst case is ~3 reads to find a newline.
- */
-function readLastLine(filepath) {
-    try {
-        const stats = statSync(filepath);
-        if (stats.size === 0)
-            return null;
-        const fd = openSync(filepath, 'r');
-        try {
-            const chunkSize = 4096;
-            let position = stats.size;
-            let buffer = Buffer.alloc(0);
-            while (position > 0) {
-                const readSize = Math.min(chunkSize, position);
-                position -= readSize;
-                const chunk = Buffer.alloc(readSize);
-                readSync(fd, chunk, 0, readSize, position);
-                buffer = Buffer.concat([chunk, buffer]);
-                // Strip trailing newlines so the last "line" is the actual content
-                const text = buffer.toString('utf-8').replace(/\n+$/, '');
-                const lastNewline = text.lastIndexOf('\n');
-                if (lastNewline >= 0) {
-                    return text.slice(lastNewline + 1);
-                }
-                if (position === 0) {
-                    // Whole file fits in our buffer
-                    return text;
-                }
-            }
-            return null;
-        }
-        finally {
-            closeSync(fd);
-        }
-    }
-    catch {
-        return null;
-    }
-}
 /**
  * Read the chain tip (seq + entryHash of the last chained entry) from disk.
  * Walks BACKWARD from EOF looking for the most recent line that carries
@@ -472,17 +427,11 @@ function readLastLine(filepath) {
  * continuous across legacy-entry interleavings (rare but possible when
  * an out-of-band script appends raw JSON to the audit file).
  */
-function readChainTip(filepath) {
-    if (!existsSync(filepath))
-        return null;
-    let content;
-    try {
-        content = readFileSync(filepath, 'utf-8');
-    }
-    catch {
-        return null;
-    }
-    const lines = content.split('\n');
+/**
+ * The actual backward-walk: most recent line carrying chain fields wins.
+ * Pure over a set of lines so both the bounded and full readers share it.
+ */
+export function tipFromLines(lines) {
     for (let i = lines.length - 1; i >= 0; i--) {
         const raw = lines[i];
         if (!raw.trim())
@@ -500,6 +449,71 @@ function readChainTip(filepath) {
     }
     return null;
 }
+function readChainTipFull(filepath) {
+    let content;
+    try {
+        content = readFileSync(filepath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+    return tipFromLines(content.split('\n'));
+}
+/**
+ * Read the chain tip (seq + entryHash of the last chained entry) from disk.
+ *
+ * Hot path: appendAuditLog calls this on every tool call to compute the next
+ * seq/prevHash. Reading the whole file each time is O(filesize), and the audit
+ * log grows unbounded (one line per tool call), so a heavy user eventually
+ * pays a multi-MB read on every call — enough to blow the <50ms hook budget.
+ *
+ * So we read only the last `tailBytes` and run the SAME backward-walk on that
+ * window. The window starts mid-file, so its first line is probably truncated
+ * — we drop it (dropping the OLDEST line in the window never changes the most
+ * recent chain entry, which is what we return). If the window holds no chain
+ * entry (e.g. a long run of legacy entries, or the only entry was the dropped
+ * partial line), we fall back to a full read. The bounded read is therefore a
+ * pure optimization: it can never return a different tip than the full read,
+ * only reach it faster. Proven by the property test in
+ * test/unit/chain-tip-bounded.test.ts.
+ */
+export function readChainTip(filepath, tailBytes = 65536) {
+    if (!existsSync(filepath))
+        return null;
+    let size;
+    try {
+        size = statSync(filepath).size;
+    }
+    catch {
+        return null;
+    }
+    if (size === 0)
+        return null;
+    if (size <= tailBytes)
+        return readChainTipFull(filepath);
+    // Bounded tail read: last `tailBytes` ending at EOF (so the final line is
+    // never truncated; only the first line in the window may be).
+    let fd;
+    try {
+        fd = openSync(filepath, 'r');
+        const buf = Buffer.alloc(tailBytes);
+        const bytesRead = readSync(fd, buf, 0, tailBytes, size - tailBytes);
+        const lines = buf.toString('utf-8', 0, bytesRead).split('\n');
+        lines.shift(); // drop the possibly-truncated first line
+        const tip = tipFromLines(lines);
+        if (tip)
+            return tip;
+    }
+    catch {
+        // fall through to the full read
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+    // Pathological: no chain entry in the tail window. Pay the full read.
+    return readChainTipFull(filepath);
+}
 export function appendAuditLog(entry) {
     // Cross-process file locking. Multiple Claude Code sessions (e.g., two
     // terminals, or IDE + terminal) can trigger PreToolUse concurrently.
@@ -711,6 +725,8 @@ export function appendOverrideAudit(reason, partial = {}) {
         criticalFindings: partial.criticalFindings ?? 0,
         overrideReason: reason,
     };
+    if (partial.note && partial.note.trim())
+        entry.overrideNote = partial.note.trim().slice(0, 500);
     appendAuditLog(entry);
 }
 // ── Main hook handler ────────────────────────────────────────────────────────

package/dist/infrastructure/hooks/session-analyzer.js

@@ -39,18 +39,23 @@ export function analyzeSessions(entries) {
             if (e.criticalFindings > 0)
                 critical++;
         }
-        // Risk heuristics:
-        // - >50 calls in one session = possible amplification
-        // - >10 Bash calls = elevated risk
-        // - any blocked calls in a long session = suspicious
+        // Risk heuristics. The signal we care about is amplification — a runaway
+        // or injected session doing things the user didn't watch. Volume ALONE is
+        // weak signal: a normal attended dev session easily runs 40+ calls with
+        // 20+ Bash (git, build, test, curl) and is perfectly clean. Crying "medium"
+        // at that is the false alarm UX_OBSERVATIONS.md P1 warns against, and it
+        // erodes trust in the real alerts. So:
+        //   - any blocked call or critical finding is genuine security signal
+        //   - pure volume only flags at a high bar (the code's own ">50" threshold)
+        //   - Bash-heavy only flags when ALSO high-volume (raised 10→20, +calls>40)
         const bashCount = toolMix['Bash'] ?? 0;
         const callCount = sorted.length;
         let risk = 'low';
-        if (blocked > 0 && callCount > 20)
+        if ((blocked > 0 && callCount > 20) || critical > 0)
             risk = 'high';
-        else if (callCount > 50 || (bashCount > 10 && callCount > 20))
+        else if (blocked > 0)
             risk = 'medium';
-        else if (blocked > 0 || callCount > 25)
+        else if (callCount > 50 || (bashCount > 20 && callCount > 40))
             risk = 'medium';
         summaries.push({
             sessionId,
@@ -74,7 +79,7 @@ export function detectAmplificationAlerts(sessions) {
     for (const session of sessions) {
         if (session.amplificationRisk === 'low')
             continue;
-        let message = '';
+        let message;
         const risk = session.amplificationRisk;
         // rc.17 framing: don't accuse "injection" by default — that wording scares
         // users on perfectly normal long attended sessions. Reserve the strong
@@ -107,6 +112,58 @@ export function detectAmplificationAlerts(sessions) {
     }
     return alerts.slice(0, 5); // top 5 alerts
 }
+/**
+ * Real coding tools — the ones a genuine host terminal session uses. Synthetic
+ * audit-event types (WritePass.intent, pre_prompt, etc.) and seed fixtures only
+ * carry these internal names, so requiring a real tool filters them out.
+ */
+export const REAL_HOST_TOOLS = new Set([
+    'Bash',
+    'Edit',
+    'Write',
+    'MultiEdit',
+    'Read',
+    'Glob',
+    'Grep',
+    'Task',
+    'NotebookEdit',
+    'WebFetch',
+]);
+/**
+ * Is this a genuine host coding session worth surfacing — not a seed fixture or
+ * a stale log entry? Requires at least one real coding tool and recent activity.
+ * Surfacing stale/synthetic sessions as "running in your terminal" is the
+ * screen-lie the no-screen-lies rule bans.
+ */
+export function isRealHostSession(s, nowMs = Date.now(), recencyMs = 48 * 60 * 60 * 1000) {
+    const hasRealTool = Object.keys(s.toolMix).some((t) => REAL_HOST_TOOLS.has(t));
+    if (!hasRealTool)
+        return false;
+    const last = new Date(s.lastSeen).getTime();
+    if (!Number.isFinite(last))
+        return false;
+    return last >= nowMs - recencyMs;
+}
+/**
+ * Plain-English preview of a tool call for the host-session thread timeline.
+ * The hook stores toolInput as a (sometimes truncated) JSON string. Extract the
+ * meaningful field — the bash command, the file path — never dump raw JSON at
+ * the user. Falls back to a regex when the JSON is cut off mid-string.
+ */
+export function previewFromToolInput(toolInput, max = 140) {
+    if (!toolInput)
+        return '';
+    let out;
+    try {
+        const inp = JSON.parse(toolInput);
+        out = String(inp.command ?? inp.file_path ?? inp.path ?? inp.pattern ?? inp.url ?? '');
+    }
+    catch {
+        const m = toolInput.match(/"(?:command|file_path|path|pattern|url)"\s*:\s*"((?:[^"\\]|\\.)*)/);
+        out = m ? m[1].replace(/\\"/g, '"').replace(/\\n/g, ' ') : '';
+    }
+    return out.slice(0, max);
+}
 /**
  * Format session duration for display.
  */

package/dist/infrastructure/observability/execution-tracer.js

@@ -108,11 +108,6 @@ export class ExecutionTracer {
     /**
      * List recent runs
      */
-    listRecentRuns(limit = 10) {
-        // In a real implementation, we'd index runs by timestamp
-        // For now, return empty array (can be enhanced with an index file)
-        return [];
-    }
     /**
      * Reproduce a run (replay operations in sequence)
      * Enhanced: Actually replays operations with state restoration

package/dist/infrastructure/orchestration/aider-adapter.js

@@ -15,7 +15,9 @@
 import { spawn, execFileSync } from 'child_process';
 import { EventEmitter } from 'events';
 import { randomUUID } from 'crypto';
+import { startRecording } from './cassette-recorder.js';
 import { ProgressAggregator } from './progress-aggregator.js';
+import { resolveAgentSpawn } from './mocks/resolve-agent-spawn.js';
 import { applyMemoryPrefix } from './memory-injector.js';
 import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
 import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
@@ -26,36 +28,54 @@ const HEADLESS_FLAGS = [
     '--no-stream', // stream=false → one chunk per turn, cleaner stdout parsing
     '--no-auto-commits', // don't auto-commit — leave file changes for artifacts-extractor
 ];
+// v0.7 HIGH-1 fix — extended ERROR_PATTERNS for the 18+ provider families
+// Aider supports. Pre-fix: 4 regexes shaped only for Anthropic + OpenAI text.
+// Aider routes through LiteLLM which forwards each provider's native error
+// message, so DeepSeek "Insufficient Balance", Ollama "connection refused",
+// Bedrock "UnrecognizedClientException", Gemini "API key not valid", and even
+// Anthropic's actual "invalid x-api-key" all fell through and never fired
+// failover. Per docs/contracts/aider.md §3 + docs/contracts/00-FINDINGS.md HIGH-1.
 const ERROR_PATTERNS = [
     {
         code: 'credit_low',
-        // Aider has no subscription path — uses ANTHROPIC_API_KEY / OPENAI_API_KEY
-        // directly against the billed API. codehere users who run on a Claude Code
-        // subscription typically have a zero-credit API key and hit this fast.
-        regex: /credit balance is too low|insufficient.*credit|no credits|you exceeded your current quota/i,
-        message: 'The API key has no credit — Aider cannot run on a Claude Code subscription.',
-        recovery: 'Aider needs a billed API key (Anthropic or OpenAI). Either top up your key at ' +
-            'console.anthropic.com / platform.openai.com, or switch the task to Claude Code / Codex which use ' +
-            'subscription auth.',
+        // Anthropic + OpenAI canonical + DeepSeek ("Insufficient Balance").
+        regex: /credit balance is too low|insufficient.*credit|no credits|you exceeded your current quota|insufficient.balance/i,
+        message: 'The API key has no credit (or balance is too low).',
+        recovery: 'Aider needs a billed API key with balance. Top up at your provider (console.anthropic.com / ' +
+            'platform.openai.com / platform.deepseek.com), or switch the task to Claude Code / Codex / Gemini ' +
+            'which use subscription or free-tier auth.',
     },
     {
         code: 'auth_invalid',
-        regex: /invalid api key|authentication.*failed|401 unauth|Please provide your.*API key/i,
-        message: 'Aider auth missing or rejected.',
-        recovery: 'Set ANTHROPIC_API_KEY or OPENAI_API_KEY in your shell, then retry.',
+        // Anthropic + OpenAI + Anthropic's actual "invalid x-api-key" + Gemini's
+        // "API key not valid" + Bedrock's "UnrecognizedClientException" + generic.
+        regex: /invalid api key|invalid x-api-key|api key not valid|authentication.*failed|401 unauth|please provide your.*api key|unrecognizedclientexception|the security token included in the request is invalid/i,
+        message: 'Aider auth was rejected or missing.',
+        recovery: 'Check the API key for your model provider (ANTHROPIC_API_KEY, OPENAI_API_KEY, DEEPSEEK_API_KEY, ' +
+            'GEMINI_API_KEY, AWS_ACCESS_KEY_ID for Bedrock, etc.). Re-export and retry.',
     },
     {
         code: 'rate_limit',
-        regex: /rate.?limit(ed)?|429|too many requests/i,
-        message: 'Aider rate-limited the request.',
-        recovery: 'Wait a minute and retry, or switch --model via extraArgs.',
+        // Generic 429 + named providers (Gemini RESOURCE_EXHAUSTED, Bedrock ThrottlingException).
+        regex: /rate.?limit(ed)?|429|too many requests|resource.exhausted|throttlingexception/i,
+        message: 'Aider was rate-limited by the provider.',
+        recovery: 'Wait a minute and retry, or switch --model via extraArgs to a different provider.',
     },
     {
         code: 'model_unavailable',
-        regex: /model.*(not found|not available|unavailable|does not exist)/i,
+        regex: /model.*(not found|not available|unavailable|does not exist)|invalidmodelid/i,
         message: 'Aider could not find the model.',
         recovery: 'Run `aider --list-models` and pass `--model <name>` via extraArgs.',
     },
+    {
+        code: 'network_failure',
+        // Ollama (local), self-hosted, generic socket errors. Local providers
+        // typically fail at the transport layer with these strings.
+        regex: /connection refused|econnrefused|enotfound|fetch failed|getaddrinfo|network is unreachable/i,
+        message: "Aider couldn't reach the model provider.",
+        recovery: 'Network or provider endpoint issue. For local Ollama: confirm `ollama serve` is running. ' +
+            'For cloud providers: check internet + provider status page.',
+    },
 ];
 function scanForKnownError(text) {
     for (const p of ERROR_PATTERNS) {
@@ -175,7 +195,8 @@ export function spawnAider(prompt, options = {}) {
     const spawnEnv = { ...process.env, ...(options.env ?? {}) };
     let child;
     try {
-        child = spawn('aider', ['--message', finalPrompt, ...HEADLESS_FLAGS, ...(options.extraArgs ?? [])], {
+        const sp = resolveAgentSpawn('aider', 'aider', ['--message', finalPrompt, ...HEADLESS_FLAGS, ...(options.extraArgs ?? [])], finalPrompt);
+        child = spawn(sp.command, sp.args, {
             cwd,
             env: spawnEnv,
             stdio: ['ignore', 'pipe', 'pipe'],
@@ -210,9 +231,14 @@ export function spawnAider(prompt, options = {}) {
             },
         };
     }
+    // Organic cassette recording (S2b · capture-first plan) · no-op unless
+    // CODEHERE_RECORD_CASSETTES=1, so zero overhead by default.
+    const recorder = startRecording({ adapter: 'aider', sessionId, prompt: finalPrompt, cwd });
     let stdoutBuf = '';
     child.stdout?.on('data', (chunk) => {
-        stdoutBuf += chunk.toString('utf-8');
+        const text = chunk.toString('utf-8');
+        recorder.onStdout(text);
+        stdoutBuf += text;
         let idx;
         while ((idx = stdoutBuf.indexOf('\n')) >= 0) {
             const line = stdoutBuf.slice(0, idx).trim();
@@ -224,12 +250,14 @@ export function spawnAider(prompt, options = {}) {
     });
     child.stderr?.on('data', (chunk) => {
         const text = chunk.toString('utf-8');
+        recorder.onStderr(text);
         for (const line of text.split('\n')) {
             if (line.trim())
                 emit({ type: 'stderr', timestamp: Date.now(), data: { line } });
         }
     });
     child.on('exit', (code, signal) => {
+        recorder.onExit(code ?? -1, signal);
         // Preserve 'error' if we already flipped to it on codehere:error.
         statusValue =
             killRequested || signal !== null ? 'killed' : errorEmitted ? 'error' : code === 0 ? 'completed' : 'error';

package/dist/infrastructure/orchestration/artifacts-extractor.js

@@ -190,13 +190,44 @@ function lastMatch(s, re) {
         last = m;
     return last;
 }
-function parseTestSummary(stdout) {
+/** Parse a test pass/fail summary out of accumulated stdout. Best-effort and
+ *  runner-agnostic so "trust the result" holds across whatever the repo uses,
+ *  not just node runners. Exported for direct unit coverage. */
+export function parseTestSummary(stdout) {
     if (!stdout)
         return undefined;
     const s = stdout.slice(-8000); // only look at the tail
-    // vitest / jest: "Tests  47 passed, 1 failed (48)"  or  "passing" (mocha)
-    const passed = lastMatch(s, /(\d+)\s+pass(?:ed|ing)/i);
-    const failed = lastMatch(s, /(\d+)\s+fail(?:ed|ing)/i);
+    // Primary — "N passed" / "M failed": vitest, jest, pytest, mocha ("passing"),
+    // cargo ("5 passed; 0 failed"). Unchanged so existing matches never shift.
+    let passed = lastMatch(s, /(\d+)\s+pass(?:ed|ing)/i);
+    let failed = lastMatch(s, /(\d+)\s+fail(?:ed|ing)/i);
+    // Fallback A — reversed order "Passed: N" / "Failed: N" (dotnet test, some CI
+    // summaries). Only consulted when the primary matched nothing, so the common
+    // path is untouched.
+    if (!passed && !failed) {
+        passed = lastMatch(s, /pass(?:ed)?:\s*(\d+)/i);
+        failed = lastMatch(s, /fail(?:ed)?:\s*(\d+)/i);
+    }
+    // Fallback B — python unittest: "Ran 5 tests in 0.0s" then "OK" or
+    // "FAILED (failures=2, errors=1)". There is no "passed" word at all, so the
+    // earlier patterns never see it — this was a real drop the dogfood surfaced.
+    if (!passed && !failed) {
+        const ran = lastMatch(s, /Ran\s+(\d+)\s+tests?\b/i);
+        if (ran) {
+            const total = parseInt(ran[1], 10);
+            const f = lastMatch(s, /failures=(\d+)/i);
+            const e = lastMatch(s, /errors=(\d+)/i);
+            const failedCount = (f ? parseInt(f[1], 10) : 0) + (e ? parseInt(e[1], 10) : 0);
+            const unittest = {
+                passed: Math.max(0, total - failedCount),
+                failed: failedCount,
+            };
+            const d = lastMatch(s, /in\s+([\d.]+)s\b/i);
+            if (d)
+                unittest.durationMs = Math.round(parseFloat(d[1]) * 1000);
+            return unittest;
+        }
+    }
     if (!passed && !failed)
         return undefined;
     const result = {
@@ -290,6 +321,9 @@ export function extractArtifacts(snap, collectedStdout) {
     const agentLikely = filterBySpawnBaseline(snap, sessionScoped);
     const files = annotateTrust(snap, agentLikely);
     const tests = parseTestSummary(collectedStdout);
-    return { files, tests };
+    // Non-git cwd: files is empty because we can't diff, not because nothing
+    // changed. Flag it so the UI + Final Report say "can't track here" instead
+    // of silently implying "no files changed".
+    return { files, tests, ...(snap.isGitRepo ? {} : { noGitTracking: true }) };
 }
 //# sourceMappingURL=artifacts-extractor.js.map

package/dist/infrastructure/orchestration/cassette-recorder.js

@@ -0,0 +1,120 @@
+/**
+ * cassette-recorder · organic instrumentation for S2b of the capture-first plan.
+ *
+ * What it does:
+ *   When CODEHERE_RECORD_CASSETTES=1 is set, every adapter spawn writes the
+ *   raw stdout/stderr byte stream + exit to a JSONL cassette under
+ *   ~/.codehere/cassettes/<adapter>/<scenario>-<ISO>.jsonl. The schema matches
+ *   the locked L3b format (agent/src/testing/cassette.ts) so the same loader
+ *   + replay infrastructure works on captures from real production sessions.
+ *
+ * Why this exists:
+ *   Per chat 2026-05-23 (path 3 hybrid), we agreed cassettes accumulate from
+ *   the founder's normal use rather than from dedicated capture sessions
+ *   requiring fresh API keys. This module is the "accumulates" mechanism.
+ *
+ * Design choices:
+ *   - OFF by default. Zero overhead when the env var is unset. The 5 adapters
+ *     all call `startRecording()`, but it returns a no-op recorder if the
+ *     env var isn't set, so the per-chunk hooks become free function calls.
+ *   - Best-effort writes. A failed cassette never breaks the spawn path.
+ *   - No PII scrubbing here · the user is recording their own sessions on
+ *     their own machine. If we ever publish cassettes externally, scrubbing
+ *     belongs in an export tool, not in the recorder.
+ *   - One cassette per session (no append between sessions). Easier to reason
+ *     about lifecycle, easier to discard / re-run, easier to ship in a PR.
+ */
+import { appendFileSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join } from 'path';
+const ENV_FLAG = 'CODEHERE_RECORD_CASSETTES';
+const NULL_RECORDER = {
+    enabled: false,
+    path: '',
+    onStdout() { },
+    onStderr() { },
+    onExit() { },
+};
+export function startRecording(opts) {
+    if (process.env[ENV_FLAG] !== '1')
+        return NULL_RECORDER;
+    const outDir = opts.outDir ?? join(homedir(), '.codehere', 'cassettes', opts.adapter);
+    const scenario = `organic-${opts.sessionId.slice(0, 8)}`;
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const path = join(outDir, `${scenario}-${stamp}.jsonl`);
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+    }
+    catch {
+        return NULL_RECORDER;
+    }
+    const start = Date.now();
+    const header = {
+        t: 0,
+        meta: {
+            adapter: opts.adapter,
+            scenario,
+            captured_at: new Date().toISOString(),
+            binary_version: opts.binary_version ?? 'unknown',
+            origin: 'real',
+            prompt: opts.prompt,
+            cwd_hint: hintCwd(opts.cwd),
+            schema: 1,
+        },
+    };
+    try {
+        appendFileSync(path, JSON.stringify(header) + '\n', 'utf-8');
+    }
+    catch {
+        return NULL_RECORDER;
+    }
+    let sealed = false;
+    return {
+        enabled: true,
+        path,
+        onStdout(chunk) {
+            if (sealed)
+                return;
+            writeEvent(path, { t: Date.now() - start, stream: 'stdout', data: chunk });
+        },
+        onStderr(chunk) {
+            if (sealed)
+                return;
+            writeEvent(path, { t: Date.now() - start, stream: 'stderr', data: chunk });
+        },
+        onExit(exit_code, signal) {
+            if (sealed)
+                return;
+            sealed = true;
+            writeEvent(path, { t: Date.now() - start, exit_code, signal });
+        },
+    };
+}
+/* ──────────────────────────────────────────────────────────────────────── */
+/* Internals                                                                 */
+/* ──────────────────────────────────────────────────────────────────────── */
+function writeEvent(path, payload) {
+    try {
+        appendFileSync(path, JSON.stringify(payload) + '\n', 'utf-8');
+    }
+    catch {
+        // best-effort · never break the spawn path
+    }
+}
+function hintCwd(cwd) {
+    if (!cwd)
+        return '.';
+    const home = homedir();
+    if (cwd === home)
+        return '~';
+    if (cwd.startsWith(home + '/'))
+        return '~/' + cwd.slice(home.length + 1);
+    return cwd;
+}
+/** Probe used by tests + the future status command. */
+export function isRecordingEnabled() {
+    return process.env[ENV_FLAG] === '1';
+}
+/** Returns the env flag name so callers can document it consistently. */
+export const RECORD_ENV_FLAG = ENV_FLAG;
+//# sourceMappingURL=cassette-recorder.js.map