@bahulam/code 0.1.10 → 0.1.12

package/src/core/headless.mjs

@@ -17,6 +17,7 @@ import { buildWorkScope, promptProjectRoots } from './work-scope.mjs';
 import { persistProjectArtifacts } from './project-artifacts.mjs';
 import { BahulamAuth } from '../auth/bahulam-auth.mjs';
 import { ApprovalManager } from './approval.mjs';
+import { PluginRegistry } from '../plugins/registry.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.
@@ -46,7 +47,7 @@ import {
  * @param {number} [opts.maxCost] - abort if cost exceeds this USD amount
  * @param {boolean} [opts.verbose] - show progress on stderr
  */
-export async function runHeadless({ instruction, model, timeout = 300, maxCost, verbose = false, cacheReport = null, local = false, vision = [] }) {
+export async function runHeadless({ instruction, model, timeout = 300, maxCost, verbose = false, cacheReport = null, local = false, vision = [], agent = null, workflow = null }) {
     const startTime = Date.now();
 
     const log = (msg) => {
@@ -60,13 +61,67 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
     // ── Auth ──
     const auth = new BahulamAuth();
     const creds = auth.loadCredentials();
-    if (!creds.token) {
+    const graphTarget = agent || workflow;
+    const anthKey = process.env.ANTHROPIC_API_KEY || creds.anthropicKey;
+    const orKey = process.env.OPENROUTER_API_KEY || creds.openRouterKey;
+    // Graph runs execute locally and only need a model key; everything
+    // else still requires login (the backend runs the agent loop).
+    if (!creds.token && !(graphTarget && (anthKey || orKey))) {
         emit({ type: 'error', error: 'Not logged in. Run: bahulam login' });
         process.exit(1);
     }
 
+    // ── Deterministic graph target: --agent <slug> / --workflow <name> ──
+    if (graphTarget) {
+        const { dispatch } = await import('../orchestration/dispatch.mjs');
+        const { listLocalWorkflows } = await import('../agents/workflow_scaffold.mjs');
+        const pluginRegistry = new PluginRegistry().scan();
+        const toolExecutor = createToolExecutor({ pluginRegistry });
+        const timer = setTimeout(() => {
+            emit({ type: 'timeout', duration_s: timeout });
+            process.exit(2);
+        }, timeout * 1000);
+
+        const outcome = await dispatch({
+            type: 'invoke',
+            source: 'cli:headless',
+            target: agent ? { kind: 'agent', slug: agent } : { kind: 'workflow', slug: workflow },
+            params: { instruction: instruction || '' },
+            channel: null,
+            substrate: 'direct',
+        }, {
+            toolExecutor,
+            listRunnables: () => toolExecutor.listRunnables(),
+            listLocalWorkflows: () => listLocalWorkflows(process.cwd()),
+            renderEvent: (event) => emit({ type: event.type, ...event.data }),
+            credentials: { apiKey: anthKey, openRouterKey: orKey },
+            defaultModel: model || null,
+            cwd: process.cwd(),
+        });
+
+        clearTimeout(timer);
+        if (!outcome.dispatched) {
+            emit({ type: 'error', error: outcome.reason });
+            process.exit(1);
+        }
+        const result = outcome.result || {};
+        emit({
+            type: 'result',
+            status: result.status || (result.success === false ? 'failed' : 'completed'),
+            channel: outcome.channel,
+            output: result.output || '',
+            node_results: result.node_results || undefined,
+            duration_s: Math.round((Date.now() - startTime) / 1000),
+        });
+        process.exit(result.status === 'failed' || result.success === false ? 1 : 0);
+    }
+
+    // Scan plugins so client_agents and agent-scoped plugin tool schemas
+    // are sent to the backend.
+    const pluginRegistry = new PluginRegistry().scan();
+
     // Projects are registered and indexed only when the agent requests an overview.
-    const toolExecutor = createToolExecutor();
+    const toolExecutor = createToolExecutor({ pluginRegistry });
 
     // Auto-approve everything — no prompts
     const approval = new ApprovalManager({ autoApprove: true });
@@ -104,6 +159,7 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
             token: creds.token,
             toolExecutor,
             approvalManager: approval,
+            pluginRegistry,
         });
     }
 

package/src/core/local-agent.mjs

@@ -206,6 +206,11 @@ export class LocalAgent {
         maxTurns = null,
         stagnationDetection = false,
         stagnationThreshold = 3,
+        // Additional tool schemas beyond the built-in set — e.g. plugin
+        // tools a sub-agent node declares. Execution still routes through
+        // the (scoped) toolExecutor; this only makes the schemas visible
+        // to the model.
+        extraToolSchemas = [],
     }) {
         this.apiKey = apiKey;
         this.openRouterKey = openRouterKey;
@@ -218,6 +223,7 @@ export class LocalAgent {
         this.maxTurns = maxTurns || MAX_ITERATIONS;
         this.stagnationDetection = stagnationDetection;
         this.stagnationThreshold = stagnationThreshold;
+        this.extraToolSchemas = Array.isArray(extraToolSchemas) ? extraToolSchemas : [];
         this._cancelled = false;
         this.promptCache = new PromptCache();
     }
@@ -498,7 +504,10 @@ export class LocalAgent {
     }
 
     _buildToolDefs() {
-        return TOOL_SCHEMAS;
+        if (!this.extraToolSchemas.length) return TOOL_SCHEMAS;
+        const names = new Set(TOOL_SCHEMAS.map(t => t.name));
+        const extras = this.extraToolSchemas.filter(t => t?.name && !names.has(t.name));
+        return extras.length ? [...TOOL_SCHEMAS, ...extras] : TOOL_SCHEMAS;
     }
 
     _buildSystemPrompt(context, retrievedContext = null) {

package/src/core/local-store.mjs

@@ -10,9 +10,9 @@ import * as path from 'node:path';
 import * as readline from 'node:readline';
 import { bahulamHome } from './paths.mjs';
 
-const KEPLER_DIR = bahulamHome();
-const PROJECTS_DIR = path.join(KEPLER_DIR, 'projects');
-const REPLAY_EVENT_RECORD_TYPES = new Set(['bahulam_event', 'kepler_event']);
+const BAHULAM_DIR = bahulamHome();
+const PROJECTS_DIR = path.join(BAHULAM_DIR, 'projects');
+const REPLAY_EVENT_RECORD_TYPE = 'bahulam_event';
 
 function finiteNumber(value) {
   const n = Number(value);
@@ -28,7 +28,7 @@ function firstFiniteNumber(...values) {
 }
 
 function replayEventFromRecord(record) {
-  if (!record || !REPLAY_EVENT_RECORD_TYPES.has(record.type) || !record.event) return null;
+  if (!record || record.type !== REPLAY_EVENT_RECORD_TYPE || !record.event) return null;
   const event = record.event;
   if (!event || typeof event !== 'object' || !event.type) return null;
   return {
@@ -334,8 +334,7 @@ async function parseSessionMeta(filePath) {
         if (!meta.endTime || ts > meta.endTime) meta.endTime = ts;
       }
 
-      // Bahulam replay events may carry cost / error markers. Older local
-      // transcripts used the same payload under the legacy kepler_event type.
+      // Bahulam replay events may carry cost / error markers.
       const ev = replayEventFromRecord(obj);
       if (ev) {
         const data = ev.data || {};
@@ -518,7 +517,8 @@ export async function getSessionDetail(sessionId, options = {}) {
       continue;
     }
 
-    const message = obj.message || {};
+    if (!obj.message || typeof obj.message !== 'object') continue;
+    const message = obj.message;
     entries.push({
       order: entryOrder,
       type: obj.type || null,
@@ -965,7 +965,7 @@ export async function getModelBreakdown(days = 30) {
  * @param {number} n — max entries to return (most recent first)
  */
 export function getHistory(n = 50) {
-  const historyPath = path.join(KEPLER_DIR, 'history.jsonl');
+  const historyPath = path.join(BAHULAM_DIR, 'history.jsonl');
   try {
     const content = fs.readFileSync(historyPath, 'utf-8');
     const lines = content.trim().split('\n').filter(Boolean);
@@ -981,8 +981,8 @@ export function getHistory(n = 50) {
 
 export function getStorePaths() {
   return {
-    bahulamDir: KEPLER_DIR,
+    bahulamDir: BAHULAM_DIR,
     projectsDir: PROJECTS_DIR,
-    historyPath: path.join(KEPLER_DIR, 'history.jsonl'),
+    historyPath: path.join(BAHULAM_DIR, 'history.jsonl'),
   };
 }

package/src/core/paths.mjs

@@ -16,15 +16,8 @@
  *         hooks.json           — project-specific hooks
  *     projects.json            — slug → project path mapping
  *
- * ── Legacy fallback ─────────────────────────────────────────────────────
- * Pre-rename installs stored everything under ~/.kepler/. The resolver below
- * prefers the new path but falls back to the legacy directory when it
- * exists and the new one doesn't, so existing users keep their config,
- * agents, workflows, and history until they explicitly migrate.
- *
  * Env vars:
- *   BAHULAM_HOME  preferred; explicit override for ~/.bahulam
- *   KEPLER_HOME   legacy; still honored for backward compat
+ *   BAHULAM_HOME  explicit override for ~/.bahulam
  */
 
 import * as fs from 'node:fs';
@@ -32,58 +25,14 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import * as crypto from 'node:crypto';
 
-const NEW_HOME_NAME = '.bahulam';
-const LEGACY_HOME_NAME = '.kepler';
-
-let _legacyNoticeShown = false;
-
 /**
  * Resolve the CLI home directory. Priority:
- *   1. $BAHULAM_HOME (explicit new)
- *   2. $KEPLER_HOME  (explicit legacy — prints a one-time deprecation notice)
- *   3. ~/.bahulam    (if it exists)
- *   4. ~/.kepler     (if it exists — prints a one-time migration hint)
- *   5. ~/.bahulam    (fresh install, will be created on first write)
+ *   1. $BAHULAM_HOME (explicit override)
+ *   2. ~/.bahulam    (standard location, created on first write)
  */
 function resolveHome() {
   if (process.env.BAHULAM_HOME) return process.env.BAHULAM_HOME;
-  if (process.env.KEPLER_HOME) {
-    maybeNoticeLegacyEnv();
-    return process.env.KEPLER_HOME;
-  }
-  const home = os.homedir();
-  const newPath = path.join(home, NEW_HOME_NAME);
-  const legacyPath = path.join(home, LEGACY_HOME_NAME);
-  try {
-    if (fs.existsSync(newPath)) return newPath;
-  } catch {}
-  try {
-    if (fs.existsSync(legacyPath)) {
-      maybeNoticeLegacyDir(legacyPath, newPath);
-      return legacyPath;
-    }
-  } catch {}
-  return newPath;
-}
-
-function maybeNoticeLegacyEnv() {
-  if (_legacyNoticeShown || process.env.B0_QUIET_MIGRATION === '1') return;
-  _legacyNoticeShown = true;
-  try {
-    process.stderr.write(
-      '  \x1b[2mnote: KEPLER_HOME is deprecated; set BAHULAM_HOME instead.\x1b[0m\n'
-    );
-  } catch {}
-}
-
-function maybeNoticeLegacyDir(legacyPath, newPath) {
-  if (_legacyNoticeShown || process.env.B0_QUIET_MIGRATION === '1') return;
-  _legacyNoticeShown = true;
-  try {
-    process.stderr.write(
-      `  \x1b[2mnote: reading legacy ${legacyPath}. Move to ${newPath} when convenient (silence with B0_QUIET_MIGRATION=1).\x1b[0m\n`
-    );
-  } catch {}
+  return path.join(os.homedir(), '.bahulam');
 }
 
 /**
@@ -91,7 +40,6 @@ function maybeNoticeLegacyDir(legacyPath, newPath) {
  * Uses first 16 chars of SHA-256 (same as Claude Code).
  */
 export function projectHash(projectDir) {
-    // Resolve symlinks (macOS: /tmp → /private/tmp) so the hash is stable
     let resolved = projectDir;
     try {
         resolved = fs.realpathSync(projectDir);
@@ -104,14 +52,11 @@ export function projectHash(projectDir) {
         .slice(0, 16);
 }
 
-/** Root ~/.bahulam/ directory (or legacy ~/.kepler/ if that's what's present). */
+/** Root ~/.bahulam/ directory. */
 export function bahulamHome() {
     return resolveHome();
 }
 
-/** Backward-compat alias. Prefer `bahulamHome()` in new code. */
-export const keplerHome = bahulamHome;
-
 /** ~/.bahulam/projects/{hash}/ for a given project path. */
 export function projectDir(projectPath) {
     return path.join(bahulamHome(), 'projects', projectHash(projectPath));
@@ -163,20 +108,6 @@ export function historyPath() {
 }
 
 // ── 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() {
@@ -188,7 +119,7 @@ export function daemonSessionDir(sessionId) {
     return path.join(daemonSessionsRoot(), sessionId);
 }
 
-/** ~/.bahulam/sockets/ — root for daemon Unix sockets (Phase 1). */
+/** ~/.bahulam/sockets/ — root for daemon Unix sockets. */
 export function daemonSocketsDir() {
     return path.join(bahulamHome(), 'sockets');
 }
@@ -198,29 +129,12 @@ 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,
-// tasks/) used to live in .kepler/ inside the project. Same resolver logic
-// applies — prefer .bahulam/, fall back to .kepler/ when only the legacy
-// dir exists.
-
-const PROJECT_NEW_NAME = '.bahulam';
-const PROJECT_LEGACY_NAME = '.kepler';
+// ── Project-local config directory (.bahulam/ inside the project) ────
 
 /**
- * Resolve the project-local config directory for `cwd`. Same priority as
- * the home resolver. Returns an absolute path; the directory may not
- * exist yet (callers that write should mkdir -p first).
+ * Resolve the project-local config directory for `cwd`.
+ * Returns an absolute path; the directory may not exist yet.
  */
 export function projectConfigDir(cwd = process.cwd()) {
-    const newPath = path.join(cwd, PROJECT_NEW_NAME);
-    const legacyPath = path.join(cwd, PROJECT_LEGACY_NAME);
-    try {
-        if (fs.existsSync(newPath)) return newPath;
-    } catch {}
-    try {
-        if (fs.existsSync(legacyPath)) return legacyPath;
-    } catch {}
-    return newPath;
+    return path.join(cwd, '.bahulam');
 }

package/src/core/policy-resolver.mjs

@@ -5,7 +5,7 @@ import * as path from 'node:path';
 export const DEFAULT_POLICY = Object.freeze({
   version: 1,
   context: {
-    loadEveryTurn: ['KEPLER.md', 'project.md', 'style.md', 'goal.md', 'plan.md', 'tasks/*.md'],
+    loadEveryTurn: ['BAHULAM.md', 'project.md', 'style.md', 'goal.md', 'plan.md', 'tasks/*.md'],
     showReloadNotice: true,
     injectCommandOptions: true,
     injectActionableTips: true,

package/src/core/project-context-loader.mjs

@@ -69,8 +69,8 @@ export function loadProjectContext({ cwd = process.cwd(), previous = null } = {}
   const bahulamDir = projectConfigDir(cwd);
   const files = [];
   for (const file of loadBahulamMemory({ cwd })) {
-    const label = file.path.endsWith(path.join('.bahulam', 'KEPLER.md'))
-      ? 'KEPLER.md'
+    const label = file.path.endsWith(path.join('.bahulam', 'BAHULAM.md'))
+      ? 'BAHULAM.md'
       : path.basename(file.path);
     files.push({
       label,

package/src/core/risk-tier.mjs

@@ -63,6 +63,7 @@ const READ_TOOLS = new Set([
   'analyze_code',
   'validate_file', 'validate_structure',
   'agents_list', 'workflow_list',
+  'bahulam_info', 'job_output',
 ]);
 
 const READ_PATH_KEYS = [

package/src/core/stream-client.mjs

@@ -11,6 +11,7 @@
 
 import { llmToolResultContent, sendCallback, sendSkippedCallback, sendApprovalDecision } from './callback-client.mjs';
 import { ApprovalManager } from './approval.mjs';
+import { upsertFacts } from './memory-disk.mjs';
 import { normalizeBillingBrandCopy, quotaErrorDetail, rateLimitErrorMessage } from './rate-limit-display.mjs';
 import * as telemetry from '../telemetry/index.mjs';
 
@@ -93,6 +94,17 @@ function transportDebug(message, data = {}) {
     } catch {}
 }
 
+function memoryFactsFromComplete(data) {
+    const facts = data?.memory_facts_to_persist;
+    if (!Array.isArray(facts) || facts.length === 0) return [];
+    return facts.filter(fact => (
+        fact
+        && typeof fact === 'object'
+        && fact.fact_id
+        && String(fact.content || '').trim()
+    ));
+}
+
 // Full jitter around the scheduled delay: pick a value in [delay*0.5, delay*1.5].
 // Spreads out reconnect storms so N clients dropping simultaneously don't
 // synchronize their retries. Clamped to the same 30s ceiling as the base delay.
@@ -136,6 +148,7 @@ export class BahulamStreamClient {
         approvalManager = null,
         reconnectMaxElapsedMs = null,
         mode = null,
+        pluginRegistry = null,
     }) {
         this.baseUrl = (baseUrl || '').replace(/\/$/, '');
         this.token = token;
@@ -148,7 +161,7 @@ export class BahulamStreamClient {
         this.retryDelayMs = null;
         this.pendingToolCallbacks = new Map();
         this.reconnectMaxElapsedMs = reconnectMaxElapsedMs
-            ?? Number(process.env.KEPLER_RECONNECT_MAX_ELAPSED_MS || 300_000);
+            ?? Number(process.env.BAHULAM_RECONNECT_MAX_ELAPSED_MS || 300_000);
         // Set by backend on first turn, reused on subsequent turns. Headless mode
         // (which starts fresh per invocation) can pre-seed via TARANG_SESSION_ID
         // so multi-turn benchmarks share one backend session across `node` runs.
@@ -173,9 +186,107 @@ export class BahulamStreamClient {
             || (process.env.TARANG_ENV === 'remote' ? 'remote' : null)
             || (process.env.TARANG_ENV === 'bundled' ? 'bundled' : null)
             || 'remote';
+        this.pluginRegistry = pluginRegistry || null;
         this._bundledReady = false;
     }
 
+    _getPluginToolMap() {
+        const tools = new Map();
+        if (!this.pluginRegistry) return tools;
+        for (const tool of this.pluginRegistry.listTools?.() || []) {
+            const name = String(tool.name || '').trim();
+            if (!name || tools.has(name)) continue;
+            tools.set(name, tool);
+        }
+        return tools;
+    }
+
+    /**
+     * Plugin tools are intentionally not advertised as primary client_tools.
+     * They are executable by the local callback handler, but the primary model
+     * should reach them by delegating to an agent that declares them.
+     */
+    _getPluginToolSchemas() {
+        return [];
+    }
+
+    _collectAgentScopedToolRefs(context = {}, clientAgents = []) {
+        const refs = new Map();
+        const pluginTools = this._getPluginToolMap();
+        const addAgent = (agent = {}) => {
+            const slug = String(agent.slug || agent.command || agent.name || '').trim();
+            const tools = Array.isArray(agent.tools) ? agent.tools : [];
+            for (const toolName of tools) {
+                const name = String(toolName || '').trim();
+                if (!name || !pluginTools.has(name)) continue;
+                if (!refs.has(name)) refs.set(name, new Set());
+                if (slug) refs.get(name).add(slug);
+            }
+        };
+
+        for (const agent of clientAgents || []) addAgent(agent);
+        for (const agent of context?.agent_ctx?.available_agents || []) addAgent(agent);
+        for (const agent of context?.available_agents || []) addAgent(agent);
+        if (context?.sub_agent) addAgent(context.sub_agent);
+        return refs;
+    }
+
+    /**
+     * Plugin tool schemas scoped to sub-agents that declare those tools.
+     * This keeps plugin tools out of the primary model's direct tool surface
+     * while still giving delegated/custom/plugin agents the schemas they need.
+     *
+     * @returns {Array<{name: string, description: string, input_schema: object, source_scope: string, plugin_name: string|null, allowed_agents: string[]}>}
+     */
+    _getClientAgentToolSchemas(context = {}, clientAgents = []) {
+        const pluginTools = this._getPluginToolMap();
+        if (!pluginTools.size) return [];
+        const refs = this._collectAgentScopedToolRefs(context, clientAgents);
+        return [...refs.entries()].map(([name, allowedAgents]) => {
+            const tool = pluginTools.get(name) || {};
+            return {
+                name,
+                description: tool.description || '',
+                input_schema: tool.input_schema || { type: 'object', properties: {} },
+                source_scope: 'plugin',
+                plugin_name: tool._plugin_name || tool.plugin_name || null,
+                allowed_agents: [...allowedAgents],
+            };
+        });
+    }
+
+    /**
+     * Get plugin agent schemas for client_agents injection.
+     * @returns {Array<{slug: string, name: string, role: string, description: string, tools: string[]}>}
+     */
+    _getPluginAgentSchemas() {
+        if (!this.pluginRegistry) return [];
+        // Only plugin agents admitted to the main-loop registry (settings
+        // plugins.agent_allowlist, or the session plugin in workspace-channel
+        // executors) are advertised. Workspace-scoped plugin agents stay out
+        // of the main-turn payload; without an executor registry, fall back
+        // to advertising everything (legacy behavior).
+        const runnables = this.toolExecutor?.listRunnables?.();
+        const admitted = Array.isArray(runnables)
+            ? new Set(runnables.filter(a => a.source_scope === 'plugin').map(a => a.slug))
+            : null;
+        return this.pluginRegistry.listAgents()
+            .filter(a => !admitted || admitted.has(a.slug || a.name || ''))
+            .map(a => ({
+                slug: a.slug || a.name || '',
+                name: a.name || a.slug || '',
+                role: a.role || 'specialist',
+                description: a.description || '',
+                tools: Array.isArray(a.tools) ? a.tools : [],
+                system_prompt: a.system_prompt || a.systemPrompt || a.prompt || '',
+                model: a.model || null,
+                models: a.models || null,
+                source: a.source || (a._plugin_name ? `plugin:${a._plugin_name}` : 'plugin'),
+                source_scope: 'plugin',
+                plugin_name: a._plugin_name || null,
+            }));
+    }
+
     /**
      * Ensure the bundled runtime is spawned and this.baseUrl points at it.
      * No-op in remote mode. Callers that hit the backend should invoke this
@@ -251,6 +362,12 @@ export class BahulamStreamClient {
         const body = { instruction, context };
         if (messages && messages.length > 0) body.messages = messages;
         if (this.sessionId) body.session_id = this.sessionId;
+        const clientTools = this._getPluginToolSchemas();
+        if (clientTools.length > 0) body.client_tools = clientTools;
+        const clientAgents = this._getPluginAgentSchemas();
+        if (clientAgents.length > 0) body.client_agents = clientAgents;
+        const clientAgentTools = this._getClientAgentToolSchemas(context, clientAgents);
+        if (clientAgentTools.length > 0) body.client_agent_tools = clientAgentTools;
         const requestId = `cli-${_uuidLike()}`;
 
         // daemon cache-guard hook. If BAHULAM_CAPTURE_REQUEST is set to a file
@@ -461,6 +578,10 @@ export class BahulamStreamClient {
             return;
         }
 
+        if (event === EVENT_TYPES.COMPLETE) {
+            this._persistMemoryFactsFromComplete(data);
+        }
+
         // Tool requests — show to user, then execute locally and POST callback.
         if (event === EVENT_TYPES.TOOL_REQUEST || event === EVENT_TYPES.TOOL_CALL) {
             yield rendered;
@@ -486,6 +607,23 @@ export class BahulamStreamClient {
         }
     }
 
+    _persistMemoryFactsFromComplete(data) {
+        const facts = memoryFactsFromComplete(data);
+        if (facts.length === 0) return;
+        try {
+            upsertFacts(facts, process.cwd());
+            telemetry.track('memory.disk.upserted', { facts: facts.length });
+        } catch (err) {
+            telemetry.track('memory.disk.upsert_failed', {
+                facts: facts.length,
+                message: err?.message || String(err),
+            });
+            if (data && typeof data === 'object') {
+                data.memory_persist_error = err?.message || String(err);
+            }
+        }
+    }
+
     async *_reconnectAfterDrop(err) {
         const taskId = this.currentTaskId;
         if (!taskId || this.lastEventId == null) {
@@ -728,6 +866,7 @@ export class BahulamStreamClient {
         const callId = call_id || request_id;
         const toolName = tool;
         const isInternal = Boolean(data?.internal || data?.sub_agent);
+        const subAgentRunId = data?.run_id || data?.sub_agent_run_id || null;
 
         if (this.verbose) {
             process.stderr.write(`\x1b[2m[tool] ${toolName}(${JSON.stringify(args).slice(0, 80)}...)\x1b[0m\n`);
@@ -745,6 +884,8 @@ export class BahulamStreamClient {
                     _cancelled: true,
                     internal: isInternal,
                     sub_agent: data?.sub_agent || null,
+                    run_id: subAgentRunId,
+                    sub_agent_run_id: subAgentRunId,
                     local_callback: false,
                 },
             };
@@ -756,6 +897,10 @@ export class BahulamStreamClient {
         try {
             result = await this.toolExecutor.execute(toolName, args || {}, {
                 signal: this._toolAbort?.signal,
+                toolCallSource: 'model',
+                internal: isInternal,
+                subAgent: data?.sub_agent || null,
+                subAgentRunId,
             });
         } catch (err) {
             if (err?.name === 'AbortError' || this._cancelled) {
@@ -795,6 +940,8 @@ export class BahulamStreamClient {
                 duration_ms: durationMs,
                 internal: isInternal,
                 sub_agent: data?.sub_agent || null,
+                run_id: subAgentRunId,
+                sub_agent_run_id: subAgentRunId,
                 local_callback: true,
             },
         };