@bahulam/code 0.1.10 → 0.1.11

package/src/commands/plugin.mjs

@@ -0,0 +1,247 @@
+/**
+ * Plugin CLI Commands — open a workspace with a named plugin loaded.
+ *
+ * Commands:
+ *   bahulam-code plugin <name> [path]    Open workspace with plugin tools
+ *
+ * The named plugin is looked up in the standard plugin directories,
+ * verified to exist, then a local workspace is started at [path]
+ * (or the current directory) with the plugin's tools, handlers,
+ * and optionally sub-agents available.
+ */
+
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {
+  createLocalWorkspaceSession,
+  listLocalWorkspaceSessions,
+  loadLocalWorkspaceSession,
+  writeLocalWorkspaceSession,
+} from '../local-service/session-store.mjs';
+import { startLocalWorkspaceService } from '../local-service/server.mjs';
+import { openLocalBrowser } from '../local-service/browser.mjs';
+
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+
+/**
+ * Standard directories to search for plugins.
+ */
+const PLUGIN_SEARCH_DIRS = [
+  path.join(process.cwd(), '.bahulam', 'plugins'),
+  path.join(os.homedir(), '.bahulam', 'plugins'),
+];
+
+/**
+ * Find a plugin directory by name across all standard search paths.
+ * Returns the directory path and manifests on success, null on miss.
+ */
+function findPluginDir(name) {
+  const needle = String(name || '').trim().toLowerCase();
+  if (!needle) return null;
+
+  for (const searchDir of PLUGIN_SEARCH_DIRS) {
+    try {
+      if (!fs.existsSync(searchDir)) continue;
+      const entries = fs.readdirSync(searchDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const pluginDir = path.join(searchDir, entry.name);
+        // Check both plugin.yaml and plugin.json
+        const yamlPath = path.join(pluginDir, 'plugin.yaml');
+        const jsonPath = path.join(pluginDir, 'plugin.json');
+        let manifestPath = null;
+        if (fs.existsSync(yamlPath)) manifestPath = yamlPath;
+        else if (fs.existsSync(jsonPath)) manifestPath = jsonPath;
+
+        if (!manifestPath) continue;
+
+        // Quick name match — match against directory name first (fast path),
+        // then parse the manifest for its metadata.name if needed
+        if (entry.name.toLowerCase() === needle) {
+          return { dir: pluginDir, manifestPath, searchDir };
+        }
+
+        // Parse manifest to check metadata.name
+        const raw = fs.readFileSync(manifestPath, 'utf-8');
+        let manifest;
+        try {
+          manifest = JSON.parse(raw);
+        } catch {
+          // Might be YAML — try simple YAML top-level name extraction
+          // For speed, check for `name:` line patterns
+          const nameMatch = raw.match(/^(?:name|metadata\.name|metadata:\s*\n\s+name)\s*:\s*(.+)$/m);
+          if (nameMatch) {
+            const metaName = nameMatch[1].trim().replace(/^["']|["']$/g, '').toLowerCase();
+            if (metaName === needle) {
+              return { dir: pluginDir, manifestPath, searchDir };
+            }
+          }
+          continue;
+        }
+
+        const metaName = (
+          manifest?.metadata?.name ||
+          manifest?.name ||
+          ''
+        ).toLowerCase();
+        if (metaName === needle) {
+          return { dir: pluginDir, manifestPath, searchDir };
+        }
+      }
+    } catch {
+      // Skip unreadable directories
+    }
+  }
+  return null;
+}
+
+/**
+ * Main entry point for `bahulam-code plugin` subcommand.
+ * @param {object} args - parsed CLI args
+ * @param {object} [options]
+ * @param {string} [options.cwd]
+ */
+export async function handlePluginCommand(args, { cwd = process.cwd() } = {}) {
+  const pluginName = String(args.pluginName || '').trim();
+  const targetPath = String(args.targetPath || cwd).trim();
+
+  if (!pluginName || args.help) {
+    printPluginUsage();
+    process.exit(args.help ? 0 : 1);
+  }
+
+  // 1. Find the plugin
+  const found = findPluginDir(pluginName);
+  if (!found) {
+    process.stderr.write(
+      `${RED}✗ Plugin "${pluginName}" not found.${RESET}\n` +
+      `  ${DIM}Searched:${RESET}\n` +
+      PLUGIN_SEARCH_DIRS.map(d => `    ${d}`).join('\n') + '\n' +
+      `  ${DIM}Create a plugin.yaml or plugin.json in one of these directories.${RESET}\n`
+    );
+    process.exit(1);
+  }
+
+  // 2. Verify the target path exists
+  let resolvedPath;
+  try {
+    resolvedPath = path.resolve(cwd, targetPath);
+    if (!fs.existsSync(resolvedPath)) {
+      process.stderr.write(
+        `${RED}✗ Target path does not exist: ${resolvedPath}${RESET}\n`
+      );
+      process.exit(1);
+    }
+  } catch (err) {
+    process.stderr.write(
+      `${RED}✗ Invalid target path: ${err.message}${RESET}\n`
+    );
+    process.exit(1);
+  }
+
+  // 3. Create a local workspace session with plugin context
+  const sessionTitle = `${pluginName} plugin — ${path.basename(resolvedPath) || resolvedPath}`;
+  const { session, token } = createLocalWorkspaceSession({
+    targetPath: resolvedPath,
+    cwd,
+    kind: `plugin-${pluginName}`,
+    title: sessionTitle,
+  });
+
+  // Augment session with plugin metadata so the workspace knows which
+  // plugin to highlight
+  const stored = loadLocalWorkspaceSession(session.id);
+  if (stored) {
+    stored.plugin = {
+      name: pluginName,
+      plugin_dir: found.dir,
+      manifest_path: found.manifestPath,
+    };
+    writeLocalWorkspaceSession(stored);
+    session.plugin = stored.plugin;
+  }
+
+  // 4. Start the workspace service
+  const service = await startLocalWorkspaceService({
+    session,
+    token,
+    port: args.port || 0,
+  });
+
+  // 5. Output
+  const url = typeof service === 'object' ? service.url : '';
+  if (args.json) {
+    process.stdout.write(
+      `${JSON.stringify({ ok: true, session, plugin: pluginName, url, port: service.port }, null, 2)}\n`
+    );
+  } else {
+    process.stderr.write(`\n${BOLD}${CYAN}Bahulam Plugin Workspace${RESET}\n`);
+    process.stderr.write(`  ${DIM}plugin${RESET}    ${pluginName}\n`);
+    process.stderr.write(`  ${DIM}session${RESET}  ${session.id}\n`);
+    process.stderr.write(`  ${DIM}root${RESET}     ${session.root_path}\n`);
+    process.stderr.write(`  ${DIM}url${RESET}      ${CYAN}${url}${RESET}\n\n`);
+    process.stderr.write(
+      `${GREEN}ready${RESET} ${DIM}Plugin workspace started at 127.0.0.1:${service.port}. Press Ctrl+C to stop.${RESET}\n`
+    );
+  }
+
+  if (args.open !== false) {
+    openLocalBrowser(url);
+  }
+
+  // 6. Wait for shutdown
+  await new Promise((resolve) => {
+    let done = false;
+    const stop = async () => {
+      if (done) return;
+      done = true;
+      await service.close();
+      resolve();
+    };
+    process.once('SIGINT', stop);
+    process.once('SIGTERM', stop);
+  });
+}
+
+function printPluginUsage() {
+  process.stderr.write(
+    `${BOLD}PLUGIN COMMANDS${RESET}\n` +
+    `  ${CYAN}bahulam plugin <name> [path]${RESET}                Open a workspace with a plugin loaded\n` +
+    `  ${CYAN}bahulam plugin install <src>${RESET}                Install from git URL, tarball, local dir, or registry name\n` +
+    `  ${CYAN}bahulam plugin validate <path|name>${RESET}         Preflight without installing (schema + handlers + collisions)\n` +
+    `  ${CYAN}bahulam plugin list${RESET}                         List installed plugins\n` +
+    `  ${CYAN}bahulam plugin info <name>${RESET}                  Show manifest details\n` +
+    `  ${CYAN}bahulam plugin remove <name>${RESET}                Uninstall a plugin\n` +
+    `  ${CYAN}bahulam plugin enable|disable <name>${RESET}        Toggle without deleting\n` +
+    `  ${CYAN}bahulam plugin update <name>${RESET}                git pull the latest for git-installed plugins\n` +
+    `\n` +
+    `  ${DIM}Install source shapes:${RESET}\n` +
+    `    git URL          https://github.com/foo/bar.git\n` +
+    `    tarball URL      https://.../bar-1.0.0.tgz\n` +
+    `    local directory  ./my-plugin  or  /abs/path\n` +
+    `    registry name    seo-toolkit  (looked up in awesome-bahulam-plugins)\n` +
+    `\n` +
+    `  ${DIM}Options:${RESET}\n` +
+    `    --port <n>        (open) bind a specific localhost port\n` +
+    `    --no-open         (open) start service without opening the browser\n` +
+    `    --json            print machine-readable JSON\n` +
+    `    --project         install into <cwd>/.bahulam/plugins instead of ~/.bahulam/plugins\n` +
+    `    --global          install into ~/.bahulam/plugins (default)\n` +
+    `    --ref <tag|branch>  (install/update) pin a git ref\n` +
+    `    --force           overwrite existing install\n` +
+    `\n` +
+    `  ${DIM}Search paths (later overrides earlier):${RESET}\n` +
+    PLUGIN_SEARCH_DIRS.map(d => `    ${d}`).join('\n') + '\n' +
+    `\n` +
+    `  ${DIM}Example:${RESET}\n` +
+    `    bahulam plugin install https://github.com/community/seo-toolkit\n` +
+    `    bahulam plugin seo-toolkit ~/projects/client-site\n`
+  );
+}

package/src/config/env.mjs

@@ -116,6 +116,8 @@ export const ENV_SCHEMA = {
     // Extended: Plugins
     CLAUDE_CODE_PLUGIN_DIR: { type: 'string', description: 'Custom plugin directory' },
     CLAUDE_CODE_DISABLE_PLUGINS: { type: 'boolean', default: false, description: 'Disable all plugins' },
+    BAHULAM_PLUGIN_DIR: { type: 'string', description: 'Bahulam plugin directory (comma-separated paths)' },
+    BAHULAM_DISABLE_PLUGINS: { type: 'string', description: 'Comma-separated plugin names to disable' },
 
     // Extended: Session
     CLAUDE_CODE_SESSION_TTL: { type: 'number', default: 86400000, description: 'Session TTL in ms (default 24h)' },

package/src/config/hook-runner.mjs

@@ -1,6 +1,6 @@
 import { execFile } from 'node:child_process';
 import * as path from 'node:path';
-import { loadKeplerSettings } from './settings-loader.mjs';
+import { loadBahulamSettings } from './settings-loader.mjs';
 
 function asArray(value) {
   if (!value) return [];
@@ -46,11 +46,11 @@ export class HookRunner {
   constructor({ cwd = process.cwd(), settings = null, sessionId = null } = {}) {
     this.cwd = cwd;
     this.sessionId = sessionId;
-    this.settings = settings || loadKeplerSettings({ cwd }).settings;
+    this.settings = settings || loadBahulamSettings({ cwd }).settings;
   }
 
   reload() {
-    this.settings = loadKeplerSettings({ cwd: this.cwd }).settings;
+    this.settings = loadBahulamSettings({ cwd: this.cwd }).settings;
   }
 
   hooksFor(event) {
@@ -74,11 +74,11 @@ export class HookRunner {
       const env = {
         ...process.env,
         ...(this.settings?.env || {}),
-        KEPLER_TOOL_NAME: toolName,
-        KEPLER_TOOL_INPUT_FILE_PATH: input.tool_input.file_path || input.tool_input.path || '',
-        KEPLER_PROJECT_DIR: this.cwd,
-        KEPLER_SESSION_ID: this.sessionId || '',
-        KEPLER_TURN_ID: payload.turnId || '',
+        BAHULAM_TOOL_NAME: toolName,
+        BAHULAM_TOOL_INPUT_FILE_PATH: input.tool_input.file_path || input.tool_input.path || '',
+        BAHULAM_PROJECT_DIR: this.cwd,
+        BAHULAM_SESSION_ID: this.sessionId || '',
+        BAHULAM_TURN_ID: payload.turnId || '',
       };
       const result = await runCommand(hook.command, {
         cwd: path.resolve(this.cwd),

package/src/config/memory-loader.mjs

@@ -17,15 +17,19 @@ function readIfExists(filePath, maxChars = 12000) {
   }
 }
 
+function readMemoryFile(dir, maxChars) {
+  return readIfExists(path.join(dir, 'BAHULAM.md'), maxChars);
+}
+
 export function loadBahulamMemory({ cwd = process.cwd() } = {}) {
   const files = [];
-  const global = readIfExists(path.join(bahulamHome(), 'KEPLER.md'));
+  const global = readMemoryFile(bahulamHome());
   if (global) files.push({ source: 'global', ...global });
 
-  const topLevel = readIfExists(path.join(cwd, 'KEPLER.md'));
+  const topLevel = readMemoryFile(cwd);
   if (topLevel) files.push({ source: 'project-top-level', ...topLevel });
 
-  const project = readIfExists(path.join(projectConfigDir(cwd), 'KEPLER.md'));
+  const project = readMemoryFile(projectConfigDir(cwd));
   if (project) files.push({ source: 'project', ...project });
 
   return files;

package/src/config/settings-loader.mjs

@@ -2,7 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { deepMerge } from '../core/policy-resolver.mjs';
 
-export const DEFAULT_KEPLER_SETTINGS = Object.freeze({
+export const DEFAULT_BAHULAM_SETTINGS = Object.freeze({
   env: {},
   permissions: {
     shellAllowlist: [],
@@ -16,6 +16,7 @@ export const DEFAULT_KEPLER_SETTINGS = Object.freeze({
   },
 });
 
+
 function readJson(filePath) {
   try {
     if (!fs.existsSync(filePath)) return null;
@@ -25,10 +26,10 @@ function readJson(filePath) {
   }
 }
 
-export function loadKeplerSettings({ cwd = process.cwd() } = {}) {
+export function loadBahulamSettings({ cwd = process.cwd() } = {}) {
   const base = path.join(cwd, '.bahulam');
   const layers = [
-    { name: 'default', path: null, data: DEFAULT_KEPLER_SETTINGS },
+    { name: 'default', path: null, data: DEFAULT_BAHULAM_SETTINGS },
   ];
   for (const [name, file] of [
     ['project', path.join(base, 'settings.json')],
@@ -43,3 +44,4 @@ export function loadKeplerSettings({ cwd = process.cwd() } = {}) {
   for (const layer of layers) settings = deepMerge(settings, layer.data || {});
   return { settings, layers };
 }
+

package/src/core/attachments.mjs

@@ -419,8 +419,8 @@ export function loadImageAttachment(filePath, { cwd = process.cwd(), maxBytes =
 export function prepareImageAttachments(input, {
   cwd = process.cwd(),
   extraPaths = [],
-  maxImageBytes = envInt('KEPLER_VISION_MAX_IMAGE_BYTES', DEFAULT_MAX_IMAGE_BYTES),
-  maxTurnBytes = envInt('KEPLER_VISION_MAX_TURN_BYTES', DEFAULT_MAX_TURN_BYTES),
+  maxImageBytes = envInt('BAHULAM_VISION_MAX_IMAGE_BYTES', DEFAULT_MAX_IMAGE_BYTES),
+  maxTurnBytes = envInt('BAHULAM_VISION_MAX_TURN_BYTES', DEFAULT_MAX_TURN_BYTES),
 } = {}) {
   const parsed = parseImageReferences(input, { cwd });
   const paths = [

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.
@@ -65,8 +66,11 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
         process.exit(1);
     }
 
+    // Scan plugins so client_tools and client_agents 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 +108,7 @@ export async function runHeadless({ instruction, model, timeout = 300, maxCost,
             token: creds.token,
             toolExecutor,
             approvalManager: approval,
+            pluginRegistry,
         });
     }
 

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,