@bahulam/code 0.1.2 → 0.1.4

package/src/core/loop.mjs

@@ -0,0 +1,276 @@
+/**
+ * Thin Agent Loop — iterates turns against /v1/agent/* gateway endpoints.
+ *
+ * PRD-091 §6.2-6.3: CLI owns iteration. Gateway owns LLM calls,
+ * prompt assembly, memory management, and sub-agent orchestration.
+ *
+ * This loop replaces local-agent.mjs's direct LLM calls with a
+ * POST /v1/agent/turn to the gateway. Everything else — tool dispatch,
+ * message accumulation, event shapes — matches the existing patterns
+ * the REPL already consumes.
+ *
+ * Usage (replacing client.execute()):
+ *   const { createAgentLoop } = await import('../core/loop.mjs');
+ *   for await (const event of createAgentLoop({
+ *     sessionId: 'sess_...',
+ *     messages: session.agentHistory,
+ *     toolExecutor: executor,
+ *     gatewayFetch: (body) => fetch(`${GATEWAY_URL}/v1/agent/turn`, { ... }),
+ *   })) {
+ *     // same event types as client.execute() / LocalAgent.execute()
+ *   }
+ */
+
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+
+const MAX_TURNS = 999;
+
+// ── Auth / URL discovery ────────────────────────────────────────────────
+// Same precedence as bundled-runtime.mjs::_readCliToken so gateway calls
+// use the SAME credential the user's login saved. Kept inline here so
+// loop.mjs stays importable without pulling the bundled-runtime module.
+function _readCliToken() {
+    if (process.env.BAHULAM_API_KEY) return process.env.BAHULAM_API_KEY;
+    if (process.env.BAHULAM_CLI_TOKEN) return process.env.BAHULAM_CLI_TOKEN;
+    if (process.env.B0_TOKEN) return process.env.B0_TOKEN;
+    try {
+        const raw = fs.readFileSync(path.join(os.homedir(), '.bahulam', 'config.json'), 'utf8');
+        const parsed = JSON.parse(raw);
+        return (parsed && typeof parsed.token === 'string' && parsed.token.trim()) || null;
+    } catch {
+        return null;
+    }
+}
+
+function _gatewayUrl() {
+    return (process.env.BAHULAM_GATEWAY_URL || 'https://gateway.bahulam.ai/v1').replace(/\/+$/, '');
+}
+
+/**
+ * Create a session on the gateway. Returns the session config the loop
+ * uses on every subsequent /v1/agent/turn (server-owned prompt +
+ * tool_schemas + model). Called ONCE per REPL session before iterating.
+ */
+export async function createGatewaySession({
+    workspace = 'kepler-code',
+    model = process.env.BAHULAM_MODEL || undefined,
+    token = _readCliToken(),
+    gateway = _gatewayUrl(),
+} = {}) {
+    if (!token) {
+        throw new Error(
+            'Not logged in — set BAHULAM_API_KEY or run `bahulam login` first.',
+        );
+    }
+    const base = gateway.endsWith('/v1') ? gateway.slice(0, -3) : gateway;
+    const res = await fetch(`${base}/v1/agent/session`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+            'X-Bahulam-User-Id': process.env.BAHULAM_USER_ID || 'cli-user',
+            'X-Bahulam-Tier': process.env.BAHULAM_TIER || 'free',
+        },
+        body: JSON.stringify({ workspace, ...(model ? { model } : {}) }),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`session create failed (HTTP ${res.status}): ${text.slice(0, 300)}`);
+    }
+    return res.json();  // { session_id, workspace, prompt, tool_schemas, model, expires_at, ... }
+}
+
+/**
+ * Execute one turn against /v1/chat/completions (the standard OpenAI-shape
+ * gateway endpoint). This reuses the existing metering, entitlement, and
+ * provider translation the gateway already does for BYOK — we don't need
+ * a new /v1/agent/turn endpoint. Session config (prompt + tools + model)
+ * comes from createGatewaySession() once, then every turn just posts
+ * standard OpenAI messages + tools + model.
+ *
+ * The `session` param carries { prompt, tool_schemas, model } from
+ * createGatewaySession. We inject them into the request server prefers
+ * client to send explicitly so per-tier gating on the gateway side
+ * still works (gateway decides what a caller may use; client just
+ * echoes what it received).
+ */
+async function _callGateway({ session, messages }) {
+    const token = _readCliToken();
+    if (!token) throw new Error('Missing gateway token (BAHULAM_API_KEY / bahulam login).');
+    const base = _gatewayUrl();
+    // Support both `<host>` and `<host>/v1` in BAHULAM_GATEWAY_URL.
+    const url = base.endsWith('/v1')
+        ? `${base}/chat/completions`
+        : `${base}/v1/chat/completions`;
+
+    // Strip Bahulam-specific metadata from tool schemas before sending
+    // — server also strips defensively, but keep the wire clean.
+    const tools = (session.tool_schemas || []).map(t => ({
+        type: t.type || 'function',
+        function: t.function,
+    }));
+
+    const body = {
+        model: session.model,
+        messages,   // OpenAI-shape end-to-end — {role, content} or
+                    // assistant.tool_calls + tool.tool_call_id
+        ...(tools.length ? { tools, tool_choice: 'auto' } : {}),
+        temperature: 0.0,
+        stream: false,
+    };
+
+    const t0 = performance.now();
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+            'X-Bahulam-User-Id': process.env.BAHULAM_USER_ID || 'cli-user',
+            'X-Bahulam-Tier': process.env.BAHULAM_TIER || 'free',
+        },
+        body: JSON.stringify(body),
+    });
+    const roundTripMs = performance.now() - t0;
+
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`chat/completions failed (HTTP ${res.status}): ${text.slice(0, 400)}`);
+    }
+    const data = await res.json();
+    const choice = (data.choices || [{}])[0];
+    return {
+        message: choice.message || {},   // OpenAI assistant message shape
+        finish_reason: choice.finish_reason,
+        usage: data.usage || {},
+        timing_ms: { roundTrip: Math.round(roundTripMs * 10) / 10 },
+    };
+}
+
+/**
+ * Create an async generator that iterates turns against the gateway.
+ *
+ * Uses standard OpenAI /v1/chat/completions shape throughout — the same
+ * shape the gateway already speaks to upstream providers. No custom
+ * content-block conversion, no /v1/agent/turn endpoint needed.
+ *
+ * @param {Object} opts
+ * @param {Object} opts.session           - From createGatewaySession()
+ *                                          { session_id, prompt, tool_schemas, model, ... }
+ * @param {Array}  opts.messages          - Conversation history (mutated across turns).
+ *                                          Caller seeds with [{role:'user', content:input}].
+ * @param {Object} opts.toolExecutor      - From createToolExecutor() — .execute(name, input)
+ * @param {Function} [opts.gatewayFetch]  - Override for testing
+ * @param {number}  [opts.maxTurns]       - Max iterations (default 999)
+ * @yields {Object} Events matching the REPL event protocol
+ */
+export async function* createAgentLoop({
+    session,
+    messages,
+    toolExecutor,
+    gatewayFetch = _callGateway,
+    maxTurns = MAX_TURNS,
+} = {}) {
+    let toolCount = 0;
+    const startTime = Date.now();
+    let usage = { input_tokens: 0, output_tokens: 0 };
+
+    // Prepend the workspace system prompt if not already present. The
+    // messages array (caller-owned) may accumulate across REPL turns,
+    // so only inject once.
+    if (session?.prompt && !messages.some(m => m.role === 'system')) {
+        messages.unshift({ role: 'system', content: session.prompt });
+    }
+
+    for (let i = 0; i < maxTurns; i++) {
+        // ── Call gateway (/v1/chat/completions) ─────────────────────
+        const turn = await gatewayFetch({ session, messages });
+        const asst = turn.message || {};
+        usage = {
+            input_tokens: (usage.input_tokens || 0) + (turn.usage?.prompt_tokens || 0),
+            output_tokens: (usage.output_tokens || 0) + (turn.usage?.completion_tokens || 0),
+        };
+
+        // ── Push assistant response into message history (OpenAI shape)
+        // content=null when tool_calls exist (OpenAI protocol requirement),
+        // else the text string.
+        const openAiAsst = { role: 'assistant' };
+        if (asst.tool_calls && asst.tool_calls.length > 0) {
+            openAiAsst.content = asst.content ?? null;
+            openAiAsst.tool_calls = asst.tool_calls;
+        } else {
+            openAiAsst.content = asst.content ?? '';
+        }
+        messages.push(openAiAsst);
+
+        // ── Yield text content ──────────────────────────────────────
+        if (typeof asst.content === 'string' && asst.content) {
+            yield { type: 'content', data: { text: asst.content } };
+        }
+
+        // ── Handle tool calls ───────────────────────────────────────
+        const toolCalls = asst.tool_calls || [];
+        if (toolCalls.length > 0) {
+            for (const tc of toolCalls) {
+                const id = tc.id;
+                const name = tc.function?.name || '';
+                let input = {};
+                try { input = JSON.parse(tc.function?.arguments || '{}'); }
+                catch { input = { _raw: tc.function?.arguments }; }
+
+                yield { type: 'tool_call', data: { call_id: id, tool: name, args: input } };
+
+                // Execute locally via the existing tool executor
+                let result;
+                try {
+                    result = await toolExecutor.execute(name, input || {});
+                } catch (err) {
+                    result = { success: false, output: `Error: ${err.message}` };
+                }
+
+                yield { type: 'tool_done', data: { tool: name, duration_ms: 0 } };
+                toolCount++;
+
+                // Push tool response as a role='tool' message (OpenAI shape).
+                // tool_call_id links it to the assistant's tool_calls[i].id.
+                // MUST push one message per tool_call in the SAME order as
+                // the assistant's tool_calls, or OpenAI rejects the next
+                // turn with "tool_call_ids did not have response messages".
+                messages.push({
+                    role: 'tool',
+                    tool_call_id: id,
+                    content: typeof result.output === 'string'
+                        ? result.output
+                        : JSON.stringify(result.output ?? result),
+                });
+            }
+            // Loop continues to next iteration
+        } else {
+            // ── No tool calls → turn is done ────────────────────────
+            const duration = (Date.now() - startTime) / 1000;
+            yield {
+                type: 'complete',
+                data: {
+                    summary: 'Done',
+                    changes: toolCount,
+                    duration_s: duration,
+                    usage,
+                },
+            };
+            return;
+        }
+    }
+
+    // Max turns reached
+    yield { type: 'error', data: { message: `Max turns (${maxTurns}) reached.`, fatal: false } };
+    yield {
+        type: 'complete',
+        data: {
+            summary: 'Aborted (max turns)',
+            changes: toolCount,
+            duration_s: (Date.now() - startTime) / 1000,
+            usage,
+        },
+    };
+}

package/src/core/memory-disk.mjs

@@ -0,0 +1,210 @@
+/**
+ * Disk-backed cross-session memory for the CLI runtime.
+ *
+ * Cross-session memory lives on the user's disk (not Supabase) whenever a
+ * request originates from the CLI. Chat, cloud-IDE, and workspace surfaces
+ * continue to use the Supabase `agent_memory` table via the existing
+ * SupabaseMemoryBackend — this module is CLI-only.
+ *
+ * Files:
+ *   ~/.bahulam/memory.md          — user-global. Loaded for every session.
+ *   <cwd>/.bahulam/memory.md      — project-scoped. Merged on top of global
+ *                                    when the CLI is running inside a
+ *                                    directory that has one.
+ *
+ * Format (round-trippable with the Supabase agent_memory schema):
+ *
+ *   # Bahulam memory · <optional title>
+ *
+ *   <!-- fact:<slug> type:<fact_type> conf:<0..1> scope:<global|project>
+ *        source:<origin> tags:<a,b,c> project:<id-or-null>
+ *        created:<iso> updated:<iso> -->
+ *   <content body — one or more prose paragraphs until the next `<!-- fact:`
+ *   header or end of file>
+ *
+ * HTML comments carry the metadata so GitHub renders the file cleanly.
+ * Body text is the `content` field. Unknown metadata keys pass through
+ * verbatim (round-trip preserves anything the backend added).
+ *
+ * Reads are idempotent + tolerant: missing files return an empty list, a
+ * malformed fact block is skipped with a warning rather than throwing.
+ * Writes are append-only (new facts) or overwrite-in-place (updates to an
+ * existing fact_id) — see appendFacts() and its callers.
+ */
+
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+const FACT_HEADER_RE = /<!--\s*fact:([A-Za-z0-9._-]+)\s*([^>]*)-->/g;
+
+/** Where the global memory file lives. */
+export function globalMemoryPath() {
+  return path.join(os.homedir(), '.bahulam', 'memory.md');
+}
+
+/** Where the project memory file lives, if the cwd has a .bahulam dir. */
+export function projectMemoryPath(cwd = process.cwd()) {
+  return path.join(cwd, '.bahulam', 'memory.md');
+}
+
+/**
+ * Ensure `.bahulam/` exists at the requested root, creating it if missing.
+ * `scope='global'` → ~/.bahulam/; `scope='project'` → <cwd>/.bahulam/.
+ * Returns the directory path. Idempotent — safe to call on every access.
+ */
+export function ensureBahulamDir(scope = 'global', cwd = process.cwd()) {
+  const dir = scope === 'project'
+    ? path.join(cwd, '.bahulam')
+    : path.join(os.homedir(), '.bahulam');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// Parse `key:value key:value` from the header comment. Values are strings;
+// callers coerce as needed. `tags:a,b,c` → array, `project:null` → null.
+function _parseMeta(raw) {
+  const meta = {};
+  const trimmed = String(raw || '').trim();
+  if (!trimmed) return meta;
+  // Simple space-separated key:value tokenizer. Values cannot contain
+  // spaces — matches how appendFacts() serializes below.
+  for (const tok of trimmed.split(/\s+/)) {
+    const idx = tok.indexOf(':');
+    if (idx < 0) continue;
+    const key = tok.slice(0, idx);
+    let value = tok.slice(idx + 1);
+    if (value === 'null' || value === '') value = null;
+    else if (key === 'tags') value = value.split(',').filter(Boolean);
+    else if (key === 'conf' || key === 'confidence') {
+      const n = Number(value);
+      value = Number.isFinite(n) ? n : null;
+    }
+    meta[key] = value;
+  }
+  return meta;
+}
+
+/**
+ * Parse one memory.md file into an array of Fact records matching the
+ * Supabase schema shape. Missing file → []. Malformed blocks are skipped.
+ */
+export function parseMemoryFile(filePath) {
+  let text;
+  try {
+    text = fs.readFileSync(filePath, 'utf-8');
+  } catch {
+    return [];
+  }
+
+  const facts = [];
+  // Reset regex state — using .exec in a loop.
+  FACT_HEADER_RE.lastIndex = 0;
+  const headers = [];
+  let m;
+  while ((m = FACT_HEADER_RE.exec(text)) !== null) {
+    headers.push({
+      slug: m[1],
+      metaRaw: m[2],
+      commentStart: m.index,
+      commentEnd: m.index + m[0].length,
+    });
+  }
+
+  for (let i = 0; i < headers.length; i++) {
+    const h = headers[i];
+    const bodyStart = h.commentEnd;
+    const bodyEnd = i + 1 < headers.length ? headers[i + 1].commentStart : text.length;
+    const body = text.slice(bodyStart, bodyEnd).trim();
+    const meta = _parseMeta(h.metaRaw);
+    facts.push({
+      fact_id: h.slug,
+      content: body,
+      fact_type: meta.type || 'other',
+      confidence: typeof meta.conf === 'number'
+        ? meta.conf
+        : (typeof meta.confidence === 'number' ? meta.confidence : null),
+      source: meta.source || 'disk',
+      tags: Array.isArray(meta.tags) ? meta.tags : [],
+      metadata: {},
+      project_id: meta.project || null,
+      memory_scope: meta.scope || (meta.project ? 'project' : 'global'),
+      created_at: meta.created || null,
+      updated_at: meta.updated || null,
+      _source_file: filePath,
+    });
+  }
+  return facts;
+}
+
+/**
+ * Load global + project memory, merging by fact_id. Project entries
+ * shadow global entries with the same fact_id, matching how the
+ * Supabase project_only scope shadows global scope.
+ */
+export function loadDiskMemory(cwd = process.cwd()) {
+  // Self-heal: create ~/.bahulam/ on first read so subsequent writes
+  // don't race on the mkdir. Silent if it already exists.
+  try { ensureBahulamDir('global'); } catch { /* ignore mkdir errors */ }
+  const globalFacts = parseMemoryFile(globalMemoryPath());
+  const projectFacts = parseMemoryFile(projectMemoryPath(cwd));
+  const merged = new Map();
+  for (const f of globalFacts) merged.set(f.fact_id, f);
+  for (const f of projectFacts) merged.set(f.fact_id, f);
+  return Array.from(merged.values());
+}
+
+// Serialize one fact to the wire format described at the top of this file.
+export function serializeFact(fact) {
+  const parts = [];
+  if (fact.fact_type) parts.push(`type:${fact.fact_type}`);
+  if (typeof fact.confidence === 'number') parts.push(`conf:${fact.confidence}`);
+  if (fact.memory_scope) parts.push(`scope:${fact.memory_scope}`);
+  if (fact.source) parts.push(`source:${fact.source}`);
+  if (Array.isArray(fact.tags) && fact.tags.length) parts.push(`tags:${fact.tags.join(',')}`);
+  parts.push(`project:${fact.project_id || 'null'}`);
+  if (fact.created_at) parts.push(`created:${fact.created_at}`);
+  if (fact.updated_at) parts.push(`updated:${fact.updated_at}`);
+  const header = `<!-- fact:${fact.fact_id} ${parts.join(' ')} -->`;
+  return `${header}\n${String(fact.content || '').trim()}\n`;
+}
+
+/**
+ * Append or overwrite one or more facts on disk. Global scope → global
+ * file; project scope → project file (creates .bahulam/ if needed).
+ * Overwrites in place when a fact_id already exists in the target file.
+ */
+export function upsertFacts(facts, cwd = process.cwd()) {
+  const byFile = new Map();  // filePath → Map(fact_id → fact)
+
+  const globalPath = globalMemoryPath();
+  const projectPath = projectMemoryPath(cwd);
+
+  // Seed from existing files so we can round-trip untouched facts.
+  for (const f of parseMemoryFile(globalPath)) {
+    if (!byFile.has(globalPath)) byFile.set(globalPath, new Map());
+    byFile.get(globalPath).set(f.fact_id, f);
+  }
+  for (const f of parseMemoryFile(projectPath)) {
+    if (!byFile.has(projectPath)) byFile.set(projectPath, new Map());
+    byFile.get(projectPath).set(f.fact_id, f);
+  }
+
+  for (const raw of facts) {
+    if (!raw || !raw.fact_id) continue;
+    const scope = raw.memory_scope || (raw.project_id ? 'project' : 'global');
+    const target = scope === 'project' ? projectPath : globalPath;
+    if (!byFile.has(target)) byFile.set(target, new Map());
+    byFile.get(target).set(String(raw.fact_id), { ...raw, memory_scope: scope });
+  }
+
+  for (const [filePath, factMap] of byFile.entries()) {
+    if (factMap.size === 0) continue;
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const title = filePath.endsWith(projectPath)
+      ? '# Bahulam memory · project scope\n\n'
+      : '# Bahulam memory · global\n\n';
+    const body = Array.from(factMap.values()).map(serializeFact).join('\n');
+    fs.writeFileSync(filePath, `${title}${body}`, 'utf-8');
+  }
+}

package/src/core/paths.mjs

@@ -162,6 +162,42 @@ export function historyPath() {
     return path.join(bahulamHome(), 'history.jsonl');
 }
 
+// ── daemon session paths ─────────────────────────────────────
+//
+// Daemon-owned sessions (bahulamd, detach/attach) live at:
+//   ~/.bahulam/sessions/<sess_id>/            per-session dir
+//     meta.json                                cwd, model, opened_at, ...
+//     events.jsonl (+ events-1.jsonl, ...)    append-only event log
+//     snapshot-<seq>.json                      periodic compacted snapshot
+//     approvals/                               pending + decided approvals
+//     input-lock.json                          who holds input right now
+//     daemon.pid                               pid of the owning daemon
+//   ~/.bahulam/sockets/<sess_id>.sock          Unix socket (0600)
+//
+// These are DIFFERENT from the projects/<hash>/sessions/ archive above.
+// The archive is a historical index keyed on project path; daemon sessions
+// are keyed on session id and are the live source of truth while running.
+
+/** ~/.bahulam/sessions/ — root for daemon-owned sessions. */
+export function daemonSessionsRoot() {
+    return path.join(bahulamHome(), 'sessions');
+}
+
+/** ~/.bahulam/sessions/<sess_id>/ — per-session dir. */
+export function daemonSessionDir(sessionId) {
+    return path.join(daemonSessionsRoot(), sessionId);
+}
+
+/** ~/.bahulam/sockets/ — root for daemon Unix sockets (Phase 1). */
+export function daemonSocketsDir() {
+    return path.join(bahulamHome(), 'sockets');
+}
+
+/** ~/.bahulam/sockets/<sess_id>.sock — Unix socket path for a session. */
+export function daemonSocketPath(sessionId) {
+    return path.join(daemonSocketsDir(), `${sessionId}.sock`);
+}
+
 // ── Project-local config directory (.bahulam/ next to CLAUDE.md/etc) ────
 //
 // Project-scoped stuff (agents/*.yaml, memory/*.md, hooks/, settings.json,

package/src/core/stream-client.mjs

@@ -143,23 +143,19 @@ export class TarangStreamClient {
         this._toolAbort = null;
 
         // Transport mode:
-        //   'bundled' → local Python runtime (PRD-091 §6). Framework calls
-        //     the Bahulam Gateway directly. Metering runs. THIS IS THE
-        //     PUBLIC CLI DEFAULT.
         //   'remote' → cloud backend runs the agent loop server-side.
         //     Backend calls Bahulam Gateway with service-token attribution;
-        //     metering still runs at the gateway boundary.
+        //     metering runs at the gateway boundary.
+        //   'bundled' → legacy: local Python runtime (PRD-091 §6, deprecated).
+        //     Only used when BAHULAM_RUNTIME_MODE=bundled is explicitly set.
         //
-        // Explicit opt precedence: constructor arg > env vars > sniff runtime
-        // package availability > default 'bundled'.
+        // Explicit opt precedence: constructor arg > env vars > default 'remote'.
         this.mode = mode
             || (process.env.BAHULAM_RUNTIME_MODE === 'remote' ? 'remote' : null)
             || (process.env.BAHULAM_RUNTIME_MODE === 'bundled' ? 'bundled' : null)
             || (process.env.TARANG_ENV === 'remote' ? 'remote' : null)
             || (process.env.TARANG_ENV === 'bundled' ? 'bundled' : null)
-            || 'bundled';
-        // Bundled runtime binds to a random localhost port on first use. Cached
-        // here so every method sees the same baseUrl without re-spawning.
+            || 'remote';
         this._bundledReady = false;
     }
 
@@ -238,6 +234,29 @@ export class TarangStreamClient {
         if (messages && messages.length > 0) body.messages = messages;
         if (this.sessionId) body.session_id = this.sessionId;
 
+        // daemon cache-guard hook. If BAHULAM_CAPTURE_REQUEST is set to a file
+        // path, serialize the exact body that would go to /api/execute, write
+        // it there, and exit(0) before making the network call. Zero credits
+        // spent, zero backend state changed. Used to capture a byte-exact
+        // baseline before the Slice B refactor so we can assert byte identity
+        // after the daemon extraction. See the security model note
+        // about no daemon-added fields leaking into the payload).
+        if (process.env.BAHULAM_CAPTURE_REQUEST) {
+            const fs = await import('node:fs');
+            const target = process.env.BAHULAM_CAPTURE_REQUEST;
+            const serialized = JSON.stringify(body, null, 2);
+            try {
+                fs.writeFileSync(target, serialized, { mode: 0o600 });
+                process.stderr.write(
+                    `[BAHULAM_CAPTURE_REQUEST] wrote ${target} (${Buffer.byteLength(serialized, 'utf-8')} bytes, ${Object.keys(body).length} top-level keys)\n`
+                );
+            } catch (err) {
+                process.stderr.write(`[BAHULAM_CAPTURE_REQUEST] write failed: ${err.message}\n`);
+                process.exit(1);
+            }
+            process.exit(0);
+        }
+
         const headers = this._headers({
             'Accept': 'text/event-stream',
             'Content-Type': 'application/json',