@bahulam/code 0.1.6 → 0.1.8

package/src/context/prose-chunker.mjs

@@ -62,7 +62,8 @@ export const TEXT_MIMES = new Set([
   'text/tab-separated-values',
 ]);
 export const PDF_MIMES = new Set(['application/pdf']);
-export const DOCUMENT_MIMES = new Set([...TEXT_MIMES, ...PDF_MIMES]);
+export const NOTEBOOK_MIMES = new Set(['application/x-ipynb+json']);
+export const DOCUMENT_MIMES = new Set([...TEXT_MIMES, ...PDF_MIMES, ...NOTEBOOK_MIMES]);
 
 // Wider set the CLI already supports at the `read_attachment` tool layer.
 // Chunking works fine on any UTF-8 text — retrieval quality on structured
@@ -72,17 +73,26 @@ export const TEXT_LIKE_MIMES = new Set([
   'application/json',
   'application/x-yaml',
   'application/toml',
+  'application/xml',
+  'application/sql',
   'text/yaml',
   'text/html',
+  'text/xml',
   'text/x-log',
   'text/x-rst',
   'text/x-restructuredtext',
+  'text/x-sql',
+  'text/x-sh',
+  'text/x-ini',
+  'text/x-env',
+  'text/x-dockerfile',
 ]);
 
 // Extension → mime map. Kept small and explicit — Python's
 // mimetypes.guess_type varies by OS registry; this table is stable.
 const EXT_TO_MIME = new Map([
   ['.txt', 'text/plain'],
+  ['.text', 'text/plain'],
   ['.log', 'text/x-log'],
   ['.md', 'text/markdown'],
   ['.markdown', 'text/markdown'],
@@ -90,15 +100,114 @@ const EXT_TO_MIME = new Map([
   ['.csv', 'text/csv'],
   ['.tsv', 'text/tab-separated-values'],
   ['.json', 'application/json'],
+  ['.ipynb', 'application/x-ipynb+json'],
   ['.yaml', 'application/x-yaml'],
   ['.yml', 'application/x-yaml'],
   ['.toml', 'application/toml'],
   ['.html', 'text/html'],
   ['.htm', 'text/html'],
+  ['.xml', 'application/xml'],
   ['.rst', 'text/x-rst'],
   ['.pdf', 'application/pdf'],
+  // Config + shell + database extensions users actually paste in as
+  // attachments (Supabase seeds, .env for triage, Dockerfile review, …).
+  ['.sql', 'text/x-sql'],
+  ['.env', 'text/x-env'],
+  ['.ini', 'text/x-ini'],
+  ['.conf', 'text/plain'],
+  ['.cfg', 'text/plain'],
+  ['.properties', 'text/plain'],
+  ['.editorconfig', 'text/plain'],
+  ['.gitignore', 'text/plain'],
+  ['.gitattributes', 'text/plain'],
+  ['.dockerignore', 'text/plain'],
+  ['.dockerfile', 'text/x-dockerfile'],
+  ['.sh', 'text/x-sh'],
+  ['.bash', 'text/x-sh'],
+  ['.zsh', 'text/x-sh'],
 ]);
 
+function sourceToText(value) {
+  if (Array.isArray(value)) return value.map(part => String(part ?? '')).join('');
+  if (typeof value === 'string') return value;
+  return '';
+}
+
+function outputText(output) {
+  if (!output || typeof output !== 'object') return '';
+  if (output.output_type === 'error') {
+    const traceback = Array.isArray(output.traceback)
+      ? output.traceback.map(line => String(line ?? '')).join('\n')
+      : '';
+    const header = [output.ename, output.evalue].filter(Boolean).join(': ');
+    return [header, traceback].filter(Boolean).join('\n');
+  }
+  if (output.text) return sourceToText(output.text);
+  const data = output.data && typeof output.data === 'object' ? output.data : null;
+  if (data?.['text/plain']) return sourceToText(data['text/plain']);
+  if (data?.['text/markdown']) return sourceToText(data['text/markdown']);
+  if (data?.['text/html']) return sourceToText(data['text/html']).replace(/<[^>]*>/g, ' ');
+  return '';
+}
+
+function notebookLanguage(notebook) {
+  const languageInfo = notebook?.metadata?.language_info;
+  const kernelspec = notebook?.metadata?.kernelspec;
+  return String(languageInfo?.name || kernelspec?.language || '').trim() || 'python';
+}
+
+export function formatNotebookText(rawNotebook, { maxOutputChars = 12_000 } = {}) {
+  let notebook;
+  try {
+    notebook = typeof rawNotebook === 'string'
+      ? JSON.parse(rawNotebook)
+      : JSON.parse(Buffer.from(rawNotebook || '').toString('utf8'));
+  } catch {
+    return '';
+  }
+
+  const cells = Array.isArray(notebook?.cells) ? notebook.cells : [];
+  if (!cells.length) return '';
+
+  const language = notebookLanguage(notebook);
+  const parts = [
+    `Jupyter notebook (${cells.length} cell${cells.length === 1 ? '' : 's'}, language=${language})`,
+  ];
+
+  cells.forEach((cell, index) => {
+    const type = String(cell?.cell_type || 'raw').toLowerCase();
+    const execution = cell?.execution_count != null ? ` execution_count=${cell.execution_count}` : '';
+    const source = sourceToText(cell?.source).trimEnd();
+    parts.push('');
+    parts.push(`Cell ${index + 1} [${type}${execution}]`);
+    if (type === 'code') {
+      parts.push(`\`\`\`${language}`);
+      parts.push(source);
+      parts.push('```');
+    } else {
+      parts.push(source || '(empty)');
+    }
+
+    const outputs = Array.isArray(cell?.outputs) ? cell.outputs : [];
+    const renderedOutputs = outputs
+      .map(outputText)
+      .map(text => text.trimEnd())
+      .filter(Boolean);
+    if (renderedOutputs.length) {
+      let output = renderedOutputs.join('\n\n');
+      if (output.length > maxOutputChars) {
+        output = `${output.slice(0, maxOutputChars)}\n... [output truncated]`;
+      }
+      parts.push('Output:');
+      parts.push('```text');
+      parts.push(output);
+      parts.push('```');
+    }
+  });
+
+  return parts.join('\n').trim();
+}
+
 /**
  * Best-effort mime for a local file (extension-only, no magic-byte sniff).
  * Files with no matching extension return 'application/octet-stream',
@@ -200,6 +309,16 @@ export async function extractFromBytes(buffer, mime, opts = {}) {
     }));
   }
 
+  if (NOTEBOOK_MIMES.has(normalizedMime)) {
+    const text = formatNotebookText(buffer);
+    return chunkText(text).map(c => ({
+      page: null,
+      chunk_no: c.chunk_no,
+      text: c.text,
+      tokens: c.tokens,
+    }));
+  }
+
   if (PDF_MIMES.has(normalizedMime)) {
     const pages = await extractPdfPages(buffer);
     const out = [];
@@ -217,6 +336,32 @@ export async function extractFromBytes(buffer, mime, opts = {}) {
   return [];
 }
 
+// Sniff whether a buffer is UTF-8 text vs binary. Cheap heuristic used
+// only as a fallback when the file extension didn't map to a known text
+// mime — the goal is to let obscure but genuinely-textual files (.sql,
+// .env, Dockerfile, .terraformrc, whatever) through instead of dropping
+// them at the mime gate.
+//
+// Rules:
+//   * NUL byte in the first probe window → binary
+//   * Not decodable as strict UTF-8 → binary
+//   * Otherwise → text
+//
+// Probe window bounded to 8KB — enough to catch a binary header on
+// large files, small enough to be a no-op on the hot path.
+const _TEXT_PROBE_BYTES = 8192;
+function looksLikeText(buffer) {
+  if (!buffer || buffer.length === 0) return false;
+  const probe = buffer.length > _TEXT_PROBE_BYTES ? buffer.subarray(0, _TEXT_PROBE_BYTES) : buffer;
+  if (probe.includes(0x00)) return false;
+  try {
+    new TextDecoder('utf-8', { fatal: true }).decode(probe);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /**
  * Read a local file and chunk it. Returns { mime, chunks }; both empty
  * on unresolvable path or unsupported mime — same contract as Python's
@@ -237,12 +382,11 @@ export async function extractFromPath(absPath, opts = {}) {
   }
   if (!stat.isFile()) return { mime: '', chunks: [] };
 
-  const mime = guessMime(absPath);
+  let mime = guessMime(absPath);
   const textMimes = opts.textMimes || TEXT_LIKE_MIMES;
-  if (!textMimes.has(mime) && !PDF_MIMES.has(mime)) {
-    return { mime, chunks: [] };
-  }
 
+  // Read the buffer up front so the text-sniff fallback can see the
+  // actual bytes when the extension didn't map to a known mime.
   let buffer;
   try {
     buffer = fs.readFileSync(absPath);
@@ -250,6 +394,19 @@ export async function extractFromPath(absPath, opts = {}) {
     return { mime, chunks: [] };
   }
 
+  // Fallback for unknown extensions: if guessMime returned octet-stream
+  // (or any mime not in our allow-list), sniff the buffer. If the bytes
+  // look like valid UTF-8 text with no NULs in the first probe window,
+  // treat as text/plain. This unblocks .sql, .env, Dockerfile, and any
+  // other text file we haven't explicitly listed.
+  if (!textMimes.has(mime) && !PDF_MIMES.has(mime) && !NOTEBOOK_MIMES.has(mime)) {
+    if (looksLikeText(buffer)) {
+      mime = 'text/plain';
+    } else {
+      return { mime, chunks: [] };
+    }
+  }
+
   const chunks = await extractFromBytes(buffer, mime, opts);
   return { mime, chunks };
 }

package/src/core/agent-loop.mjs

@@ -191,6 +191,23 @@ export function createAgentLoop({ model, tools, permissions, settings, hooks })
                     result = await hooks.runPostToolUse(block.name, result);
                 }
 
+                const resultStagnation = stagnation.recordResult(block.name, block.input || {}, result);
+                if (resultStagnation.detected) {
+                    yield {
+                        type: 'stagnation',
+                        tool: block.name,
+                        count: resultStagnation.count,
+                        kind: resultStagnation.kind,
+                        target: resultStagnation.target,
+                    };
+                    result = {
+                        ...(typeof result === 'object' && result !== null ? result : {}),
+                        success: false,
+                        output: stagnationMessage(block.name, resultStagnation.count, resultStagnation),
+                        _stagnation: true,
+                    };
+                }
+
                 yield { type: 'result', tool: block.name, result };
 
                 toolResults.push({

package/src/core/attachments.mjs

@@ -3,6 +3,7 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import { createHash, randomUUID } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
+import { formatNotebookText } from '../context/prose-chunker.mjs';
 
 const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif']);
 // Text-first document formats we can extract client-side and inline into the
@@ -12,7 +13,7 @@ const DOCUMENT_EXTENSIONS = new Set([
   '.pdf',
   '.txt', '.md', '.mdx', '.rst',
   '.csv', '.tsv', '.log',
-  '.json', '.yaml', '.yml', '.toml', '.ini', '.env',
+  '.json', '.ipynb', '.yaml', '.yml', '.toml', '.ini', '.env',
   '.html', '.htm', '.xml',
 ]);
 const DEFAULT_MAX_IMAGE_BYTES = 8 * 1024 * 1024;
@@ -143,6 +144,53 @@ function sniffImage(buffer) {
   return null;
 }
 
+export function detectImageFile(filePath, { cwd = process.cwd() } = {}) {
+  const resolved = resolveAttachmentPath(filePath, cwd);
+  let stat;
+  try {
+    stat = fs.statSync(resolved);
+  } catch {
+    return null;
+  }
+  if (!stat.isFile() || stat.size <= 0) return null;
+
+  const ext = path.extname(resolved).toLowerCase();
+  const probe = Buffer.alloc(Math.min(64, stat.size));
+  let fd = null;
+  try {
+    fd = fs.openSync(resolved, 'r');
+    fs.readSync(fd, probe, 0, probe.length, 0);
+  } catch {
+    return null;
+  } finally {
+    if (fd !== null) {
+      try { fs.closeSync(fd); } catch {}
+    }
+  }
+
+  const sniffed = sniffImage(probe);
+  if (sniffed) {
+    return {
+      path: resolved,
+      mime_type: sniffed.mime_type,
+      bytes: stat.size,
+      ext: sniffed.ext,
+      verified: true,
+    };
+  }
+  if (!IMAGE_EXTENSIONS.has(ext)) return null;
+  const mimeType = ext === '.jpg' || ext === '.jpeg'
+    ? 'image/jpeg'
+    : `image/${ext.slice(1)}`;
+  return {
+    path: resolved,
+    mime_type: mimeType,
+    bytes: stat.size,
+    ext,
+    verified: false,
+  };
+}
+
 function pngDimensions(buffer) {
   if (buffer.length < 24) return {};
   return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
@@ -217,7 +265,7 @@ function powershellString(value) {
 }
 
 function ensureClipboardDir(baseDir = os.tmpdir()) {
-  const dir = path.join(baseDir, 'kepler-clipboard-images');
+  const dir = path.join(baseDir, 'bahulam-clipboard-images');
   fs.mkdirSync(dir, { recursive: true });
   return dir;
 }
@@ -510,6 +558,17 @@ function extractPlainText(filePath, { maxChars }) {
   };
 }
 
+function extractNotebookText(filePath, { maxChars }) {
+  const buffer = fs.readFileSync(filePath);
+  const raw = formatNotebookText(buffer);
+  const truncated = raw.length > maxChars;
+  return {
+    text: truncated ? raw.slice(0, maxChars) : raw,
+    pages: 0,
+    truncated,
+  };
+}
+
 /**
  * Load a single document attachment. Reads locally, extracts text, returns
  * a public metadata block plus the extracted text. Errors bubble as
@@ -537,9 +596,12 @@ export async function loadDocumentAttachment(filePath, {
 
   const ext = path.extname(resolved).toLowerCase();
   const isPdf = ext === '.pdf';
+  const isNotebook = ext === '.ipynb';
   const { text, pages, truncated } = isPdf
     ? await extractPdfText(resolved, { maxChars })
-    : extractPlainText(resolved, { maxChars });
+    : isNotebook
+      ? extractNotebookText(resolved, { maxChars })
+      : extractPlainText(resolved, { maxChars });
 
   const buffer = fs.readFileSync(resolved);
   const sha256 = createHash('sha256').update(buffer).digest('hex');
@@ -549,7 +611,7 @@ export async function loadDocumentAttachment(filePath, {
     path: resolved,
     name: path.basename(resolved),
     ext,
-    kind: isPdf ? 'pdf' : 'text',
+    kind: isPdf ? 'pdf' : isNotebook ? 'notebook' : 'text',
     bytes: stat.size,
     chars: text.length,
     pages,

package/src/core/backend-url.mjs

@@ -8,32 +8,29 @@
  */
 
 const BACKEND_URLS = {
-    // Four supported environments:
-    //   local     — Docker Compose backend on the developer's own machine.
-    //   dev       — Bahulam Cloud development (Azure Container Apps, eastus).
-    //   production — Bahulam Cloud live (Azure Container Apps, centralus).
-    //   bundled   — CLI-local Python runtime spawned as a subprocess. URL is
-    //               overridden by bundled-runtime.mjs at spawn time; sentinel
-    //               value below is only used if the runtime isn't up yet.
+    // Supported environments:
+    //   local      — Docker Compose backend on the developer's own machine.
+    //   production — Bahulam Cloud live (api.bahulam.ai).
+    //   bundled    — CLI-local Python runtime spawned as a subprocess. URL is
+    //                overridden by bundled-runtime.mjs at spawn time; sentinel
+    //                value below is only used if the runtime isn't up yet.
+    //
+    // For custom dev/staging URLs, set TARANG_BACKEND_URL directly.
     local:       'http://127.0.0.1:8150',
-    dev:         'https://codekepler-backend-dev.kindisland-9034322d.eastus.azurecontainerapps.io',
     production:  'https://api.bahulam.ai',
     bundled:     'http://127.0.0.1:0',   // sentinel — real URL comes from bundled-runtime.mjs
 };
 
 // Aliases (backwards compat + convenience)
 BACKEND_URLS.prod    = BACKEND_URLS.production;
-BACKEND_URLS.treetop = BACKEND_URLS.dev;             // legacy alias
-BACKEND_URLS.docker  = BACKEND_URLS.local;           // convenience alias
+BACKEND_URLS.docker  = BACKEND_URLS.local;
 
 const WEB_URLS = {
     local:       'http://localhost:3100',
-    dev:         'https://treetop.bahulam.ai',
     production:  'https://bahulam.ai',
     bundled:     'http://localhost:3100',   // bundled mode reuses local web if user runs it
 };
 WEB_URLS.prod    = WEB_URLS.production;
-WEB_URLS.treetop = WEB_URLS.dev;             // legacy alias
 WEB_URLS.docker  = WEB_URLS.local;
 
 /**
@@ -50,6 +47,8 @@ export function resolveWebUrl() {
 
 /**
  * Resolve the backend URL from environment.
+ *
+ * For dev/staging, set TARANG_BACKEND_URL=<your-url> explicitly.
  * @returns {string}
  */
 export function resolveBackendUrl() {

package/src/core/bundled-runtime.mjs

@@ -165,7 +165,7 @@ function _clearLicenseActivationState() {
   if (process.platform === 'darwin') {
     try {
       spawnSync('security',
-        ['delete-generic-password', '-s', 'com.axplusb.agent.runtime', '-a', 'af_state'],
+        ['delete-generic-password', '-s', 'ai.bahulam.agent.runtime', '-a', 'af_state'],
         { stdio: 'ignore' });
     } catch { /* best-effort */ }
   }

package/src/core/callback-client.mjs

@@ -1,5 +1,5 @@
 /**
- * Callback Client — POST tool results back to Tarang backend.
+ * Callback Client — POST tool results back to Bahulam backend.
  * Implements retry with backoff: 2 retries, 500ms delay.
  * 4xx: no retry. 5xx/network: retry.
  */

package/src/core/headless.mjs

@@ -11,17 +11,18 @@
  *   bahulam-code --headless --model deepseek/deepseek-chat-v3-0324 "Add tests"
  */
 
-import { TarangStreamClient } from './stream-client.mjs';
+import { BahulamStreamClient } from './stream-client.mjs';
 import { createToolExecutor } from './tool-executor.mjs';
 import { buildWorkScope, promptProjectRoots } from './work-scope.mjs';
 import { persistProjectArtifacts } from './project-artifacts.mjs';
-import { TarangAuth } from '../auth/tarang-auth.mjs';
+import { BahulamAuth } from '../auth/bahulam-auth.mjs';
 import { ApprovalManager } from './approval.mjs';
 // daemon wiring — headless (and `bahulam daemonize`) also starts the socket
 // server + relay bridge when eventlog is enabled. Without this the daemon
 // is invisible to attach clients and to paired mobile devices.
 import { tapSseEvent, registerBroadcaster } from '../daemon/event-tap.mjs';
 import { startSocketServer } from '../daemon/socket-server.mjs';
+import { startHttpDashboard } from '../daemon/http-dashboard.mjs';
 import { resolvePending } from '../daemon/approval-store.mjs';
 import { startRelayBridge } from '../daemon/relay-client.mjs';
 import { loadRemoteConfig } from '../commands/remote.mjs';
@@ -57,7 +58,7 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
     };
 
     // ── Auth ──
-    const auth = new TarangAuth();
+    const auth = new BahulamAuth();
     const creds = auth.loadCredentials();
     if (!creds.token) {
         emit({ type: 'error', error: 'Not logged in. Run: bahulam login' });
@@ -98,7 +99,7 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
         };
         log(`Local mode: ${localModel}`);
     } else {
-        client = new TarangStreamClient({
+        client = new BahulamStreamClient({
             baseUrl: creds.backendUrl,
             token: creds.token,
             toolExecutor,
@@ -348,6 +349,18 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
                             });
                             registerBroadcaster(evt => server.broadcastEvent(evt));
 
+                            // Optional HTTP browser dashboard (opt-in with BAHULAM_DASHBOARD=1)
+                            let dashboardUrl = null;
+                            if (process.env.BAHULAM_DASHBOARD === '1') {
+                                try {
+                                    const dashboard = await startHttpDashboard({ sessionId: _sid });
+                                    dashboardUrl = dashboard.url;
+                                    process.stderr.write(`[prd-092] dashboard: ${dashboard.url}\n`);
+                                } catch (err) {
+                                    try { process.stderr.write(`[prd-092] dashboard start: ${err.message}\n`); } catch {}
+                                }
+                            }
+
                             // Write meta.json + daemon.pid so `bahulam list` /
                             // `bahulam stop` and the mobile session directory
                             // can find this session.
@@ -361,6 +374,7 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
                                         sock_path: server.sockPath,
                                         opened_at: new Date().toISOString(),
                                         headless: true,
+                                        dashboard_url: dashboardUrl,
                                     },
                                 });
                                 fsSync.writeFileSync(

package/src/core/jsonl-writer.mjs

@@ -2,7 +2,7 @@
  * JSONL Writer — writes cc-lens compatible session transcripts to ~/.bahulam/.
  *
  * Format mirrors Claude Code's ~/.claude/ JSONL structure so that
- * cc-lens (CLAUDE_CONFIG_DIR=~/.bahulam npx cc-lens) can read Kepler sessions.
+ * cc-lens (CLAUDE_CONFIG_DIR=~/.bahulam npx cc-lens) can read Bahulam sessions.
  *
  * Design:
  * - Non-blocking: buffered writes, flushed every 500ms or on turn end
@@ -17,13 +17,13 @@ import { randomUUID } from 'node:crypto';
 import * as childProcessModule from 'node:child_process';
 import { bahulamHome } from './paths.mjs';
 
-const KEPLER_DIR = bahulamHome();
+const BAHULAM_DIR = bahulamHome();
 const FLUSH_INTERVAL_MS = 500;
 
 /**
  * Sanitize a cwd path into a project slug for the directory name.
  * /Users/sree/Sites/myproject → -Users-sree-Sites-myproject
- * Mirrors the Claude Code / kepler-cli convention.
+ * Mirrors the Claude Code / Bahulam CLI convention.
  */
 function sanitizePath(p) {
   return p.replace(/\//g, '-').replace(/^-/, '-');
@@ -67,7 +67,7 @@ export class JsonlWriter {
     this.version = version;
     this.sessionId = null; // set by setSessionId() when backend assigns it
     this.slug = sanitizePath(cwd);
-    this.projectDir = path.join(KEPLER_DIR, 'projects', this.slug);
+    this.projectDir = path.join(BAHULAM_DIR, 'projects', this.slug);
 
     // UUID chain for parent linking (cc-lens replay)
     this.lastUuid = null;
@@ -85,7 +85,7 @@ export class JsonlWriter {
     this._turnToolResults = []; // [{tool_use_id, content, is_error}, ...]
     this._turnUsage = null;
     this._turnModel = null;
-    this._pendingKeplerEvents = [];
+    this._pendingBahulamEvents = [];
 
     // Git branch (captured once at construction)
     this._gitBranch = this._detectGitBranch();
@@ -101,10 +101,10 @@ export class JsonlWriter {
     this.sessionId = id;
     this._transcriptPath = path.join(this.projectDir, `${id}.jsonl`);
     this._ready = true;
-    if (this._pendingKeplerEvents.length > 0) {
-      const pending = this._pendingKeplerEvents;
-      this._pendingKeplerEvents = [];
-      for (const event of pending) this.writeKeplerEvent(event);
+    if (this._pendingBahulamEvents.length > 0) {
+      const pending = this._pendingBahulamEvents;
+      this._pendingBahulamEvents = [];
+      for (const event of pending) this.writeBahulamEvent(event);
     }
     // Flush any buffered entries now that we have a path
     if (this._buffer.length > 0) this._flush();
@@ -143,10 +143,10 @@ export class JsonlWriter {
   }
 
   /**
-   * Write a Kepler UI/SSE event for exact-ish terminal replay on /resume.
-   * This is a Kepler extension; cc-lens readers should ignore unknown types.
+   * Write a Bahulam UI/SSE event for exact-ish terminal replay on /resume.
+   * This is a Bahulam extension; cc-lens readers should ignore unknown types.
    */
-  writeKeplerEvent(event) {
+  writeBahulamEvent(event) {
     if (!event || !event.type) return;
     const sanitized = sanitizeEventValue({
       type: event.type,
@@ -154,12 +154,12 @@ export class JsonlWriter {
     });
 
     if (!this.sessionId) {
-      this._pendingKeplerEvents.push(sanitized);
+      this._pendingBahulamEvents.push(sanitized);
       return;
     }
 
     const entry = {
-      type: 'kepler_event',
+      type: 'bahulam_event',
       timestamp: new Date().toISOString(),
       cwd: this.cwd,
       sessionId: this.sessionId,
@@ -204,8 +204,8 @@ export class JsonlWriter {
       content: normalizeToolResultContent(output),
       is_error: !!isError,
     };
-    const kepler = compactToolResultMetadata(metadata);
-    if (kepler) entry.bahulam = kepler;
+    const bahulamMeta = compactToolResultMetadata(metadata);
+    if (bahulamMeta) entry.bahulam = bahulamMeta;
     this._turnToolResults.push(entry);
   }
 
@@ -305,7 +305,7 @@ export class JsonlWriter {
       project: this.cwd,
       sessionId: this.sessionId,
     };
-    const historyPath = path.join(KEPLER_DIR, 'history.jsonl');
+    const historyPath = path.join(BAHULAM_DIR, 'history.jsonl');
     fs.promises.appendFile(historyPath, JSON.stringify(entry) + '\n', { mode: 0o600 })
       .catch(() => {}); // best effort
   }
@@ -393,7 +393,7 @@ export class JsonlWriter {
       fs.mkdirSync(this.projectDir, { recursive: true, mode: 0o700 });
     } catch { /* ignore */ }
     try {
-      fs.mkdirSync(path.join(KEPLER_DIR, 'projects'), { recursive: true, mode: 0o700 });
+      fs.mkdirSync(path.join(BAHULAM_DIR, 'projects'), { recursive: true, mode: 0o700 });
     } catch { /* ignore */ }
   }