@bahulam/code 0.1.1 → 0.1.3

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',

package/src/core/tool-executor.mjs

@@ -24,9 +24,11 @@ import { sendApprovalDecision, sendCallback } from './callback-client.mjs';
 import { HookRunner } from '../config/hook-runner.mjs';
 import { buildFileDiff } from './file-diff.mjs';
 import { buildWorkScope } from './work-scope.mjs';
+import { loadDiskMemory, ensureBahulamDir, globalMemoryPath, projectMemoryPath } from './memory-disk.mjs';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import * as crypto from 'node:crypto';
 import { execSync } from 'node:child_process';
 
 /**
@@ -43,6 +45,35 @@ export function createToolExecutor({
     hookRunner = null,
     interactionHandler = null,
 } = {}) {
+    // Cross-session memory cache. Ships in getAgentContext() on every turn,
+    // so we need it to be byte-identical when the underlying disk file hasn't
+    // changed — otherwise the backend's prompt cache invalidates on every
+    // ExecuteRequest.
+    //
+    // Strategy: mtime-driven cache. Read the mtimes of the global +
+    // project memory files; if unchanged since the last call, return the
+    // cached snapshot. The `remember` tool writes to disk directly, which
+    // bumps mtime and forces a reload on the next getAgentContext() call.
+    //
+    // Self-heal ~/.bahulam/ once at construction; loadDiskMemory() also
+    // guards it, but doing it here means the first read is a plain fs stat
+    // rather than a mkdir round-trip.
+    try { ensureBahulamDir('global'); } catch { /* ignore */ }
+    let _memoryCache = null; // { key: string, facts: Fact[], digest: string }
+    function _readMemorySnapshot() {
+        const gPath = globalMemoryPath();
+        const pPath = projectMemoryPath(process.cwd());
+        const gStat = fs.existsSync(gPath) ? fs.statSync(gPath).mtimeMs : 0;
+        const pStat = fs.existsSync(pPath) ? fs.statSync(pPath).mtimeMs : 0;
+        const key = `${gStat}|${pStat}|${process.cwd()}`;
+        if (_memoryCache && _memoryCache.key === key) return _memoryCache;
+        const facts = loadDiskMemory(process.cwd());
+        const digest = crypto.createHash('sha256')
+            .update(JSON.stringify(facts.map(f => [f.fact_id, f.content, f.updated_at])))
+            .digest('hex').slice(0, 16);
+        _memoryCache = { key, facts, digest };
+        return _memoryCache;
+    }
     const occRegistry = createToolRegistry();
     const skillTool = occRegistry.get('Skill');
     if (skillTool) skillTool._skillsLoader = skillsLoader;
@@ -898,7 +929,7 @@ export function createToolExecutor({
 
             const observationTimeout = args.timeout == null && isLikelyLongRunningCommand(args.command);
             const effectiveTimeout = observationTimeout ? longRunningObservationTimeoutMs() : args.timeout;
-            const result = await occRegistry.call('Bash', {
+            const result = await occRegistry.call('shell', {
                 command: args.command,
                 timeout: effectiveTimeout,
                 description: args.description || `Run: ${(args.command || '').slice(0, 50)}`,
@@ -985,7 +1016,7 @@ export function createToolExecutor({
                         } catch { /* let Read handle the error */ }
                     }
 
-                    const result = await occRegistry.call('Read', {
+                    const result = await occRegistry.call('read_file', {
                         file_path: filePath,
                         offset,
                         limit,
@@ -993,12 +1024,20 @@ export function createToolExecutor({
                     const output = typeof result === 'string' ? result : String(result);
                     const content = output.replace(/^\s*\d+[→\t]/gm, '');
                     const actNudge = solutionNudge(filePath);
+                    // Set _total_lines so the tool-card display doesn't have
+                    // to compute line counts from the display-side `output`
+                    // (which contains nudges + line-number prefixes that
+                    // throw off the count and can render as "0 lines" when
+                    // downstream fallbacks miss the payload). Uses the
+                    // same split-by-newline convention as the >50-line
+                    // truncation branch above so both paths agree.
                     return {
                         success: !isError(output),
                         content,
                         output: output + nudge + actNudge,
                         _tool: 'read_file',
                         _output_type: 'file_content',
+                        _total_lines: content ? content.split('\n').length : 0,
                     };
                 },
             );
@@ -1019,14 +1058,14 @@ export function createToolExecutor({
             // OCC Write requires Read first for existing files — handle gracefully
             try {
                 if (fs.existsSync(filePath)) {
-                    await occRegistry.call('Read', { file_path: filePath, limit: 1 });
+                    await occRegistry.call('read_file', { file_path: filePath, limit: 1 });
                 }
             } catch { /* file may not exist yet */ }
             // Checkpoint before overwrite so /undo can restore the previous content.
             if (checkpoints && fs.existsSync(filePath)) {
                 try { checkpoints.save(filePath); } catch { /* best effort */ }
             }
-            const result = await occRegistry.call('Write', {
+            const result = await occRegistry.call('write_file', {
                 file_path: filePath,
                 content: args.content,
             });
@@ -1084,11 +1123,11 @@ export function createToolExecutor({
                     // Read first if exists (OCC Write requirement)
                     try {
                         if (fs.existsSync(filePath)) {
-                            await occRegistry.call('Read', { file_path: filePath, limit: 1 });
+                            await occRegistry.call('read_file', { file_path: filePath, limit: 1 });
                         }
                     } catch { /* file may not exist yet */ }
 
-                    await occRegistry.call('Write', { file_path: filePath, content });
+                    await occRegistry.call('write_file', { file_path: filePath, content });
                     const after = readTextIfExists(filePath);
                     diffs.push(buildResultFileDiff(filePath, before, after));
                     updateProjectIndex(filePath);
@@ -1137,7 +1176,7 @@ export function createToolExecutor({
             }
             // OCC Edit requires Read first
             try {
-                await occRegistry.call('Read', { file_path: filePath, limit: 1 });
+                await occRegistry.call('read_file', { file_path: filePath, limit: 1 });
             } catch { /* best effort */ }
 
             // Checkpoint before edit so /undo can restore the previous content.
@@ -1147,10 +1186,10 @@ export function createToolExecutor({
 
             let result;
             try {
-                result = await occRegistry.call('Edit', {
+                result = await occRegistry.call('edit_file', {
                     file_path: filePath,
-                    old_string: args.search,
-                    new_string: args.replace,
+                    search: args.search,
+                    replace: args.replace,
                     replace_all: args.replace_all || false,
                 });
             } catch (editErr) {
@@ -1231,7 +1270,7 @@ print('OK: replaced')
                             _format: 'tree',
                         };
                     }
-                    const result = await occRegistry.call('Glob', {
+                    const result = await occRegistry.call('list_files', {
                         pattern: args.pattern || '**/*',
                         path: searchPath,
                     });
@@ -1335,7 +1374,7 @@ print('OK: replaced')
                     { query, path: searchPath, mode: 'glob' },
                     { generation: _readOnlyCacheGeneration },
                     async () => {
-                        const result = await occRegistry.call('Glob', {
+                        const result = await occRegistry.call('list_files', {
                             pattern: query,
                             path: searchPath,
                         });
@@ -1356,7 +1395,7 @@ print('OK: replaced')
                 { query, path: searchPath, mode: 'grep' },
                 { generation: _readOnlyCacheGeneration },
                 async () => {
-                    const result = await occRegistry.call('Grep', {
+                    const result = await occRegistry.call('search_code', {
                         pattern: query,
                         path: searchPath,
                         output_mode: 'content',
@@ -1513,7 +1552,7 @@ print('OK: replaced')
                     else if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) cmd = 'cargo build';
                     else return { success: false, output: 'No build system detected', _tool: 'validate_build' };
                 }
-                const output = await occRegistry.call('Bash', {
+                const output = await occRegistry.call('shell', {
                     command: cmd,
                     timeout: Math.min(args.timeout || 120_000, 600_000),
                     description: `Validate build: ${cmd.slice(0, 80)}`,
@@ -1563,7 +1602,7 @@ print('OK: replaced')
                 else if (['.js', '.mjs', '.ts', '.tsx'].includes(ext)) cmd = `npx eslint "${filePath}" 2>&1 || true`;
                 else return { success: true, issues: [], message: 'No linter for this file type', _tool: 'lint_check' };
 
-                const output = await occRegistry.call('Bash', {
+                const output = await occRegistry.call('shell', {
                     command: cmd,
                     timeout: 30_000,
                     description: `Lint: ${path.basename(filePath)}`,
@@ -1587,7 +1626,7 @@ print('OK: replaced')
                 throwIfAborted(options.signal);
                 const cmd = args.command || 'npm test';
                 const cwd = await commandCwd(args);
-                const output = await occRegistry.call('Bash', {
+                const output = await occRegistry.call('shell', {
                     command: cmd,
                     timeout: Math.min(args.timeout || 120_000, 600_000),
                     description: `Run tests: ${cmd.slice(0, 80)}`,
@@ -2189,10 +2228,19 @@ print('OK: replaced')
 
         getAgentContext() {
             const global = projectRegistry.getGlobalContext();
+            const mem = _readMemorySnapshot();
             return {
                 identity: global.identity,
                 preferences: global.preferences,
                 global_skills: skillsLoader.list(),
+                // Cross-session memory read from disk (CLI-only source of truth).
+                // Backend prefers this over the Supabase agent_memory table when
+                // ctx.agent_ctx.source === 'cli'. `memory_digest` is a stable
+                // sha256 prefix so the backend can hash-compare without
+                // re-serializing — helps keep the prompt cacheable when memory
+                // hasn't changed between turns.
+                memory_facts: mem.facts,
+                memory_digest: mem.digest,
                 available_agents: listLocalAgents(process.cwd()).map(agent => ({
                     slug: agent.slug,
                     name: agent.name,