@bahulam/code 0.1.6 → 0.1.8

package/src/terminal/repl.mjs

@@ -1,5 +1,5 @@
 /**
- * Kepler REPL — Full Claude-like terminal UX.
+ * Bahulam REPL — Full Claude-like terminal UX.
  *
  * Pure ANSI. No React. No Ink. No flickering.
  *
@@ -22,7 +22,7 @@ import { execSync as _execSync } from 'node:child_process';
 import { Writable as _WritableStream } from 'node:stream';
 import { c, progressBar, spinner, inPlace, renderMarkdown, renderDiff, formatElapsed, formatCost, stripAnsi } from './ansi.mjs';
 import { calculateCost, formatCostValue, formatTokens, costToCredits, formatCredits } from '../core/pricing.mjs';
-import { TarangStreamClient, EVENT_TYPES } from '../core/stream-client.mjs';
+import { BahulamStreamClient, EVENT_TYPES } from '../core/stream-client.mjs';
 import { AgentHistoryTurnBuilder } from '../core/agent-history.mjs';
 import { JsonlWriter } from '../core/jsonl-writer.mjs';
 import { tapSseEvent, registerBroadcaster } from '../daemon/event-tap.mjs';
@@ -53,7 +53,7 @@ import {
   MODES as V_MODES,
 } from '../state/verbosity.mjs';
 import { persistProjectArtifacts } from '../core/project-artifacts.mjs';
-import { TarangAuth } from '../auth/tarang-auth.mjs';
+import { BahulamAuth } from '../auth/bahulam-auth.mjs';
 import { ApprovalManager } from '../core/approval.mjs';
 import * as telemetry from '../telemetry/index.mjs';
 import { resolveBackendUrl } from '../core/backend-url.mjs';
@@ -67,6 +67,15 @@ import { createAgentFile, isVsCodeTerminal, listLocalAgents, openAgentFile, sync
 import { SessionManager } from '../core/session-manager.mjs';
 import { parseArgs } from '../config/cli-args.mjs';
 import { pickModelOverridesForm } from './repl-model-form.mjs';
+import {
+  MODEL_CATEGORY_ORDER,
+  formatCategoryBadge,
+  formatCategoryHeading,
+  modelCategory,
+  modelDisplayCategory,
+  modelMatchesCatalogFilter,
+  normalizeCatalogCategory,
+} from './model-catalog-display.mjs';
 import { loadEffectivePolicy, formatPolicySourceRows } from '../core/policy-resolver.mjs';
 import { loadProjectContext } from '../core/project-context-loader.mjs';
 import { buildContextEnvelope } from '../core/context-envelope.mjs';
@@ -92,6 +101,7 @@ import { exploreCategory, exploreCollapseEnabled, isExploreTool } from './repl-e
 import { session, orbitRef, sessionMgrRef, runtime } from './repl-state.mjs';
 import { safeCwd } from './repl-utils.mjs';
 import * as rqueue from '../ui/render-queue.mjs';
+import { watchState } from './watch-state.mjs';
 import {
   appendContent,
   bumpSpinnerProgress,
@@ -291,14 +301,15 @@ function renderKeyboardHelp() {
 
 const MODEL_ROLE_ALIASES = new Map([
   ['reasoning', 'reasoning'],
-  ['main', 'reasoning'],
   ['coder', 'reasoning'],
   ['coding', 'reasoning'],
   ['smart', 'reasoning'],
   ['fast', 'fast'],
   ['explorer', 'fast'],
-  ['orchestrator', 'orchestrator'],
-  ['planner', 'orchestrator'],
+  ['main', 'reasoning'],
+  ['orchestrator', 'plan'],
+  ['planner', 'plan'],
+  ['planning', 'plan'],
   ['local', 'local'],
   ['worker', 'worker'],
   ['explore', 'explore'],
@@ -306,25 +317,52 @@ const MODEL_ROLE_ALIASES = new Map([
   ['verify', 'verify'],
   ['debug', 'debug'],
   ['refactor', 'refactor'],
+  ['vision', 'image_analysis'],
+  ['image', 'image_analysis'],
+  ['image-analysis', 'image_analysis'],
+  ['image_analysis', 'image_analysis'],
+  ['analyze-image', 'image_analysis'],
+  ['analyze_image', 'image_analysis'],
+  ['image-generation', 'image_generation'],
+  ['image_generation', 'image_generation'],
+  ['image-gen', 'image_generation'],
+  ['generate-image', 'image_generation'],
+  ['generate_image', 'image_generation'],
 ]);
 
 const MODEL_ROLE_LABELS = {
   reasoning: 'coding',
   fast: 'fast',
-  orchestrator: 'orchestrator',
+  orchestrator: 'planning',
   local: 'local',
   worker: 'worker',
   explore: 'explore',
-  plan: 'plan',
+  plan: 'planning',
   verify: 'verify',
   debug: 'debug',
   refactor: 'refactor',
+  image_analysis: 'image analysis',
+  image_generation: 'image generation',
+};
+
+const MODEL_ROLE_DESCRIPTIONS = {
+  reasoning: 'coding model',
+  fast: 'fast low-cost work',
+  orchestrator: 'planning model (legacy role name)',
+  local: 'local fallback role',
+  worker: 'background worker role',
+  explore: 'read/search sub-agent',
+  plan: 'planning sub-agent',
+  verify: 'verification sub-agent',
+  debug: 'debugging sub-agent',
+  refactor: 'refactor sub-agent',
+  image_analysis: 'inspect screenshots and uploads',
+  image_generation: 'create visual assets',
 };
 
 const MODEL_ROLE_ORDER = [
   'reasoning',
   'fast',
-  'orchestrator',
   'local',
   'worker',
   'explore',
@@ -332,6 +370,8 @@ const MODEL_ROLE_ORDER = [
   'verify',
   'debug',
   'refactor',
+  'image_analysis',
+  'image_generation',
 ];
 
 function normalizeModelRole(value) {
@@ -349,7 +389,8 @@ function printModelCommandUsage() {
   process.stderr.write(`         /model <model>      set coding model directly\n`);
   process.stderr.write(`         /model <role> <model>\n`);
   process.stderr.write(`         /model ${NAMED_MODEL_MODES_LIST.join('|')}\n`);
-  process.stderr.write(`         /model list · status · refresh · clear [role]\n`);
+  process.stderr.write(`         /model list [text|image|image-analysis|image-generation|multimodal]\n`);
+  process.stderr.write(`         /model status · refresh · clear [role]\n`);
   process.stderr.write(`  ${c.gray('Roles:')} ${MODEL_ROLE_ORDER.map(role => MODEL_ROLE_LABELS[role]).join(', ')}\n`);
 }
 
@@ -461,6 +502,15 @@ function modelCreditBadge(model) {
   return `~${credits < 10 ? credits.toFixed(1) : String(Math.round(credits))} cr/M in`;
 }
 
+function printModelCatalogRows(rows) {
+  for (const m of rows) {
+    const badge = modelCreditBadge(m);
+    const category = formatCategoryBadge(modelDisplayCategory(m));
+    const price = badge ? c.dim(badge.padEnd(16)) : ''.padEnd(16);
+    process.stderr.write(`  ${c.brand(String(m.id || '').padEnd(38))} ${price} ${category}\n`);
+  }
+}
+
 async function warnIfNotCurated(model, ctx) {
   if (isByokModelRoute()) return;
   const catalog = await fetchModelCatalog(ctx);
@@ -470,28 +520,41 @@ async function warnIfNotCurated(model, ctx) {
     process.stderr.write(`  ${c.yellow('!')} ${c.dim(`${model} is not in the platform catalog — the backend may reject it. See /model list.`)}\n`);
   } else if (row.harness_validated === false) {
     process.stderr.write(`  ${c.yellow('!')} ${c.dim(`${model} is not harness-validated for the platform route — cost/quality untuned. See /model list.`)}\n`);
+  } else if (modelCategory(row) !== 'text') {
+    process.stderr.write(`  ${c.yellow('!')} ${c.dim(`${model} is categorized as ${modelCategory(row)}; it is listed for media tooling, not coding-model overrides.`)}\n`);
   }
 }
 
-async function printModelCatalog(ctx) {
+async function printModelCatalog(ctx, filterCategory = null) {
   const catalog = await fetchModelCatalog(ctx);
   if (!catalog) {
     process.stderr.write(`  ${c.yellow('!')} ${c.dim(`Model catalog unavailable — ${_modelCatalogError || 'unknown error'}.`)}\n`);
     return;
   }
   const curated = catalog.filter(m => m?.harness_validated);
+  const filter = filterCategory ? String(filterCategory).trim().toLowerCase() : null;
+  const visible = filter
+    ? curated.filter(m => modelMatchesCatalogFilter(m, filter))
+    : curated;
+
   process.stderr.write(`\n  ${c.bold('Platform catalog')} ${c.dim('(harness-validated, credit-priced)')}\n`);
   process.stderr.write(`  ${c.gray('─'.repeat(64))}\n`);
-  if (!curated.length) {
+  if (!visible.length) {
     process.stderr.write(`  ${c.dim('(none published yet)')}\n`);
   }
-  for (const m of curated) {
-    const badge = modelCreditBadge(m);
-    const tiers = Array.isArray(m.platform_access_tier) && m.platform_access_tier.length
-      ? c.dim(` [${m.platform_access_tier.join(', ')}]`)
-      : '';
-    process.stderr.write(`  ${c.brand(String(m.id || '').padEnd(38))} ${badge ? c.dim(badge.padEnd(16)) : ''.padEnd(16)}${tiers}\n`);
+
+  const categories = [...new Set(visible.map(modelDisplayCategory))].sort((a, b) => {
+    return (MODEL_CATEGORY_ORDER.indexOf(a) === -1 ? 999 : MODEL_CATEGORY_ORDER.indexOf(a)) -
+      (MODEL_CATEGORY_ORDER.indexOf(b) === -1 ? 999 : MODEL_CATEGORY_ORDER.indexOf(b)) ||
+      a.localeCompare(b);
+  });
+  for (const category of categories) {
+    const rows = visible.filter(m => modelDisplayCategory(m) === category);
+    if (!rows.length) continue;
+    process.stderr.write(`\n  ${formatCategoryHeading(category, rows.length)}\n`);
+    printModelCatalogRows(rows);
   }
+
   const rest = catalog.length - curated.length;
   if (rest > 0) {
     process.stderr.write(`  ${c.dim(`+${rest} more models available on the BYOK route (--route byok, own API key)`)}\n`);
@@ -552,10 +615,12 @@ function printModelStatus() {
   }
 
   const limits = session.modelLimits || {};
+  const subAgentModels = session.subAgentModels || {};
+  const planningModel = subAgentModels.plan || limits.planning?.model || limits.orchestrator?.model;
   const rows = [
-    ['coder', limits.coder?.model],
-    ['explorer', limits.explorer?.model],
-    ['orchestrator', limits.orchestrator?.model],
+    ['coding', limits.coder?.model],
+    ['explore', subAgentModels.explore || limits.explorer?.model],
+    ['planning', planningModel],
   ].filter(([, model]) => model);
   if (rows.length) {
     process.stderr.write(`\n  ${c.bold('Backend roles')}\n`);
@@ -577,20 +642,28 @@ function printModelStatus() {
   printModelCommandUsage();
 }
 
-const MODEL_FORM_ROLES = ['reasoning', 'fast', 'orchestrator', 'explore', 'plan'];
+const MODEL_FORM_ROLES = ['reasoning', 'fast', 'explore', 'plan'];
+const MODEL_MEDIA_FORM_ROLES = ['image_analysis', 'image_generation'];
 
 async function openModelForm(ctx) {
   const limits = session.modelLimits || {};
+  const subAgentModels = session.subAgentModels || {};
+  const planningModel = subAgentModels.plan || limits.planning?.model || limits.orchestrator?.model;
   const defaultsByRole = {
     reasoning: limits.coder?.model,
     fast: limits.explorer?.model,
-    orchestrator: limits.orchestrator?.model,
-    explore: limits.explorer?.model,
-    plan: limits.orchestrator?.model,
+    explore: subAgentModels.explore || limits.explorer?.model,
+    plan: planningModel,
+    image_analysis: 'backend tier default',
+    image_generation: 'backend tier default',
   };
-  const roles = MODEL_FORM_ROLES.map(role => ({
+  const roles = [...MODEL_FORM_ROLES, ...MODEL_MEDIA_FORM_ROLES].map(role => ({
     role,
     label: MODEL_ROLE_LABELS[role] || role,
+    description: MODEL_ROLE_DESCRIPTIONS[role] || '',
+    optionGroup: role === 'image_analysis'
+      ? 'image_analysis'
+      : (role === 'image_generation' ? 'image_generation' : 'text'),
     current: (session.modelOverrides || {})[role] || null,
     defaultLabel: defaultsByRole[role] || null,
   }));
@@ -616,7 +689,7 @@ async function openModelForm(ctx) {
   // Merge: form rows replace their roles; overrides on roles the form
   // doesn't show (verify/debug/…) are left untouched.
   const next = { ...(session.modelOverrides || {}) };
-  for (const role of MODEL_FORM_ROLES) delete next[role];
+  for (const role of [...MODEL_FORM_ROLES, ...MODEL_MEDIA_FORM_ROLES]) delete next[role];
   Object.assign(next, result.overrides);
   session.modelOverrides = next;
   if (result.overrides.reasoning) session.model = result.overrides.reasoning;
@@ -653,7 +726,14 @@ async function handleModelCommand(rest = '', ctx) {
   }
 
   if (parts[0] === 'list' || parts[0] === 'catalog') {
-    await printModelCatalog(ctx);
+    const category = parts[1]?.toLowerCase();
+    const normalizedCategory = normalizeCatalogCategory(category);
+    if (normalizedCategory && !['text', 'image', 'image_analysis', 'image_generation', 'multimodal', 'embedding', 'audio', 'video', 'other'].includes(normalizedCategory)) {
+      process.stderr.write(`  ${c.yellow('!')} ${c.dim(`Unknown model category: ${category}`)}\n`);
+      printModelCommandUsage();
+      return;
+    }
+    await printModelCatalog(ctx, normalizedCategory || null);
     return;
   }
 
@@ -1248,12 +1328,17 @@ function buildContextStrip() {
   // Cache hit % lives under /cache — keep the always-on strip focused on
   // volume + elapsed. Historical rate calc was double-counting the cache tokens
   // vs OpenRouter's convention (see computeCacheTotals) which was misleading.
-  const right = [
-    c.dim(`${formatTokens(totalTokens)} tok`),
-    c.dim(elapsed),
-  ].join(c.dim(' · '));
-
-  return right;
+  const parts = [];
+  // ctx: last turn's cumulative input tokens — approximates the CURRENT
+  // prompt size. Only shown once we've completed at least one turn (so
+  // the initial banner doesn't read '0 ctx'). This is the number the
+  // 160k summarize threshold compares against on the next turn.
+  if (session.lastTurnInputTokens > 0) {
+    parts.push(c.dim(`ctx ${formatTokens(session.lastTurnInputTokens)}`));
+  }
+  parts.push(c.dim(`${formatTokens(totalTokens)} tok`));
+  parts.push(c.dim(elapsed));
+  return parts.join(c.dim(' · '));
 }
 
 // ── Dock meta line (model · cwd ⎇ branch · turn N) ─────────────────────
@@ -1501,8 +1586,8 @@ function foldSubAgentToolResult(data = {}) {
     fold.entries.push(entry);
   }
   const durationMs = data?.duration_ms ?? (data?.duration_s != null ? data.duration_s * 1000 : null);
-  const summary = summarizeResult(tool, data);
   entry.args = entry.args && Object.keys(entry.args).length ? entry.args : args;
+  const summary = summarizeResult(tool, data, entry.args);
   entry.result = data;
   entry.durationMs = durationMs;
   entry.outcome = summary.text || '';
@@ -1784,6 +1869,9 @@ function renderEvent(event) {
 
     case 'tool_call':
     case 'tool_request': {
+      if (watchState.active) {
+        watchState.addEntry('tool', { label: data?.tool, detail: data?.args?.file_path || data?.args?.path || data?.args?.pattern || data?.args?.query || '' });
+      }
       const isInternal = Boolean(data?.internal || data?.sub_agent);
       if (isInternal) {
         session.subAgentToolCalls++;
@@ -1841,6 +1929,10 @@ function renderEvent(event) {
 
     case 'tool_result':
     case 'tool_done': {
+      if (watchState.active) {
+        const success = data?.success !== false;
+        watchState.addEntry('done', { label: data?.tool, detail: success ? '✓' : '✗' });
+      }
       if (shouldFoldSubAgentTool(data)) {
         foldSubAgentToolResult(data);
         break;
@@ -1936,6 +2028,9 @@ function renderEvent(event) {
     }
 
     case 'delegation': {
+      if (watchState.active) {
+        watchState.addEntry('handoff', { label: `${data?.from || '?'} → ${data?.to || '?'}` });
+      }
       stopSpinner();
       clearPendingHead();
       const from = data?.from || '';
@@ -1954,6 +2049,9 @@ function renderEvent(event) {
     // ── Sub-Agent Activity ──
 
     case 'sub_agent_start': {
+      if (watchState.active) {
+        watchState.addEntry('spawn', { type: data?.type, label: (data?.query || '').slice(0, 60) });
+      }
       stopSpinner();
       clearPendingHead();
       flushFoldedSubAgentTools();
@@ -1992,7 +2090,7 @@ function renderEvent(event) {
       // is visible by emitting a small dim transcript line too, dedup'd
       // per (agentType, tool). Queue-active mode keeps its clean spinner
       // + window; the fallback line is only for the "otherwise blind"
-      // case that surfaced in 2.6.17 reports.
+      // case that surfaced in earlier local terminal reports.
       if (!rqueue.isActive()) {
         const label = data?.label || '';
         const hint = label ? ` · ${label}` : '';
@@ -2014,6 +2112,12 @@ function renderEvent(event) {
     }
 
     case 'sub_agent_complete': {
+      if (watchState.active) {
+        const agentType = data?.type || 'sub-agent';
+        const toolCalls = data?.tool_calls || 0;
+        const durationS = data?.duration_s || 0;
+        watchState.addEntry('done', { type: agentType, detail: `${toolCalls} tools · ${durationS.toFixed(1)}s`, status: 'done' });
+      }
       setSubAgentWindowActive(false);
       stopSpinner();
       clearPendingHead();
@@ -2215,6 +2319,9 @@ function renderEvent(event) {
       if (data?.model_limits && typeof data.model_limits === 'object') {
         session.modelLimits = data.model_limits;
       }
+      if (data?.sub_agent_models && typeof data.sub_agent_models === 'object') {
+        session.subAgentModels = data.sub_agent_models;
+      }
       if (data?.user) session.user = { ...session.user, ...data.user };
       // BYOK users pay their model provider directly; the platform does not
       // charge them credits. Hide cost + credits when this flag is set.
@@ -2251,7 +2358,7 @@ function renderEvent(event) {
       break;
 
     // Live steering ack events (PRD-081 §5.2). renderEvent is called from
-    // the SSE loop (see `for await ... jsonlWriter.writeKeplerEvent(event)`
+    // the SSE loop (see `for await ... jsonlWriter.writeBahulamEvent(event)`
     // in the /execute path) so every event already lands in the transcript.
     // Here we only render the user-visible surface — no direct jsonlWriter
     // calls (it's out of scope in this top-level dispatcher anyway).
@@ -2309,6 +2416,10 @@ function renderEvent(event) {
         const out = usage.total_output_tokens || usage.output_tokens || 0;
         session.inputTokens += inp;
         session.outputTokens += out;
+        // Remember THIS turn's cumulative input for the dock strip's ctx
+        // indicator — approximates how big the prompt currently is (vs
+        // session.inputTokens which sums every turn since launch).
+        session.lastTurnInputTokens = inp;
 
         // Model-aware cost calculation
         const costResult = calculateCost(usage);
@@ -2827,6 +2938,19 @@ async function handleCommand(input, ctx) {
       return;
     }
 
+    case '/watch': {
+      const nowActive = !watchState.active;
+      watchState.active = nowActive;
+      runtime.watchPanelActive = nowActive;
+      watchState.clear();
+      process.stderr.write(`  ${c.green(nowActive ? '✓' : '✗')} ${c.dim(`Watch panel ${nowActive ? 'on' : 'off'}`)}\n`);
+      if (!nowActive) {
+        // Clear any watch panel status lines
+        if (rqueue.isActive()) rqueue.clearStatus();
+        else if (isInputDockMounted()) { clearPinnedStatus(); moveToContent(); }
+      }
+      return;
+    }
     case '/login':
       process.stderr.write(`${c.brand('Starting login flow...')}\n`);
       telemetry.track('login_shown', { method: 'repl_command' });
@@ -3328,40 +3452,48 @@ async function handleCommand(input, ctx) {
       return;
     }
 
-    case '/revoke': {
-      const wasActive = ctx.approval.revoke();
-      if (wasActive) {
-        process.stderr.write(`  ${c.green('✓')} ${c.dim('Auto-approvals revoked. All tool calls will prompt again.')}\n`);
-      } else {
-        process.stderr.write(`  ${c.gray('No auto-approvals were active.')}\n`);
-      }
-      return;
-    }
 
     case '/auto': {
-      // Session autopilot for long-running jobs: auto-approve routine
-      // writes/shell while STILL prompting for dangerous tiers (rm,
-      // force-push, command substitution, …) and never overriding hard
-      // safety blocks. Distinct from the launch-time
-      // --dangerously-skip-permissions flag, which approves everything
-      // including dangerous tiers.
+      // Session autopilot for long-running jobs. Three levels:
+      //   /auto        (or /auto on)  routine writes/shell auto-approve;
+      //                                dangerous tiers (rm/force-push/
+      //                                command substitution/protected
+      //                                files) still prompt.
+      //   /auto full                   approves EVERYTHING short of the
+      //                                unbypassable hard-safety blocks —
+      //                                mid-session equivalent of the
+      //                                --dangerously-skip-permissions
+      //                                launch flag. Long autonomous runs
+      //                                won't stall on a dangerous tier.
+      //   /auto off                    all approvals prompt again.
       const sub = (rest || '').trim().toLowerCase();
       if (sub === 'off') {
         ctx.approval.approveAll = false;
+        ctx.approval.autoApprove = false;
         process.stderr.write(`  ${c.green('✓')} ${c.dim('Auto mode off — approvals prompt again.')}\n`);
         return;
       }
+      if (sub === 'full' || sub === 'dangerous' || sub === 'yolo') {
+        ctx.approval.autoApprove = true;
+        ctx.approval.approveAll = true;
+        process.stderr.write(`  ${c.yellow('⚠')} ${c.bold('Auto FULL')} ${c.dim('— EVERY tool call auto-approves this session.')}\n`);
+        process.stderr.write(`    ${c.dim('Includes dangerous shell (rm/force-push/substitution) and protected files.')}\n`);
+        process.stderr.write(`    ${c.dim('Hard safety blocks are still enforced by the CLI safety layer.')}\n`);
+        process.stderr.write(`    ${c.dim('Disable with /auto off · this is the runtime equivalent of --dangerously-skip-permissions.')}\n`);
+        return;
+      }
       if (sub === '' || sub === 'on') {
+        ctx.approval.autoApprove = false;   // clear any prior /auto full
         ctx.approval.approveAll = true;
         process.stderr.write(`  ${c.green('✓')} ${c.bold('Auto mode on')} ${c.dim('— routine tool calls auto-approve this session.')}\n`);
         process.stderr.write(`    ${c.dim('Still prompts: dangerous shell (rm/force-push/substitution), protected files.')}\n`);
         process.stderr.write(`    ${c.dim('Hard safety blocks stay enforced. Disable with /auto off · inspect with /approvals.')}\n`);
-        process.stderr.write(`    ${c.dim('Tip: start your message with #auto to switch the backend agent into autonomous mode too.')}\n`);
+        process.stderr.write(`    ${c.dim('Need full autopilot mid-run? /auto full — same effect as --dangerously-skip-permissions.')}\n`);
         return;
       }
       // status / anything else → show current mode
       process.stderr.write(`  ${c.dim('Approval mode:')} ${ctx.approval.getModeLabel()}\n`);
-      process.stderr.write(`  ${c.dim('Usage: /auto [on|off|status]')}\n`);
+      process.stderr.write(`  ${c.dim('Usage: /auto [on|off|full|status]')}\n`);
       return;
     }
 
@@ -3632,7 +3764,7 @@ async function fetchUser(ctx) {
     });
     if (resp.ok) {
       session.user = await resp.json();
-      session.model = session.user.default_reasoning_model || session.user.default_orchestrator_model || null;
+      session.model = session.user.default_reasoning_model || null;
     }
   } catch {}
 }
@@ -3644,7 +3776,7 @@ export async function startTerminalRepl() {
   safeCwd(); // prime the cache in repl-utils.mjs for later recovery
 
   const cliArgs = parseArgs(process.argv.slice(2));
-  const auth = new TarangAuth();
+  const auth = new BahulamAuth();
 
   // Projects are registered and indexed on demand through get_project_overview.
   // CheckpointManager records per-file snapshots before edits so /undo works.
@@ -3696,7 +3828,7 @@ export async function startTerminalRepl() {
     });
   }
 
-  let toolExecutor = makeToolExecutor({ showIndexStatus: true });
+  let toolExecutor = null;
   const skipPerms = cliArgs.skipPermissions;
   let approval = new ApprovalManager({ autoApprove: skipPerms, cwd: safeCwd(), policy: effectivePolicy.policy });
 
@@ -3710,7 +3842,7 @@ export async function startTerminalRepl() {
   // Persistent stream client — session_id captured from backend on first turn
   let streamClient = null;
 
-  const ctx = { auth, toolExecutor, approval, jsonlWriter, sessionMgr, checkpoints, effectivePolicy, latestProjectContext, latestEnvelope, pendingVisionPaths: [] };
+  const ctx = { auth, toolExecutor: null, approval, jsonlWriter, sessionMgr, checkpoints, effectivePolicy, latestProjectContext, latestEnvelope, pendingVisionPaths: [] };
 
   let startupOutputRow = 1;
   let startupOutputCol = 1;
@@ -3773,6 +3905,7 @@ export async function startTerminalRepl() {
       user: session.user,
       model: session.model,
       modelLimits: session.modelLimits,
+      subAgentModels: session.subAgentModels,
       modelOverrides: session.modelOverrides,
       modelMode: session.modelMode,
       routePreference: session.routePreference,
@@ -3805,6 +3938,7 @@ export async function startTerminalRepl() {
       startTime: Date.now(),
       inputTokens: 0,
       outputTokens: 0,
+      lastTurnInputTokens: 0,
       toolCalls: 0,
       subAgentToolCalls: 0,
       totalToolCalls: 0,
@@ -3817,6 +3951,7 @@ export async function startTerminalRepl() {
       user: preserved.user,
       model: preserved.model,
       modelLimits: preserved.modelLimits,
+      subAgentModels: preserved.subAgentModels,
       modelOverrides: preserved.modelOverrides,
       modelMode: preserved.modelMode,
       routePreference: preserved.routePreference,
@@ -3988,7 +4123,7 @@ export async function startTerminalRepl() {
       && richHistory.summary
       && Number(richHistory.summaryCoveredMessageCount) > Number(richHistory.summaryCheckpointMessageCount || 0)
     ) {
-      jsonlWriter.writeKeplerEvent({
+      jsonlWriter.writeBahulamEvent({
         type: 'resume_summary',
         data: {
           session_id: sessionId,
@@ -4003,7 +4138,7 @@ export async function startTerminalRepl() {
         },
       });
     }
-    jsonlWriter.writeKeplerEvent({
+    jsonlWriter.writeBahulamEvent({
       type: 'resume_context',
       data: {
         session_id: sessionId,
@@ -4095,6 +4230,11 @@ export async function startTerminalRepl() {
       catch { /* preflight is best-effort */ }
     }
 
+    // Create the auto-indexing executor after the startup header is visible so
+    // the indexing status appears in the user's line of sight.
+    toolExecutor = makeToolExecutor({ showIndexStatus: true });
+    ctx.toolExecutor = toolExecutor;
+
     // ── Initialization ──
     process.stderr.write(`  ${c.brand('⠋')} ${c.dim('Initializing...')}\r`);
     await fetchUser(ctx);
@@ -4163,9 +4303,23 @@ export async function startTerminalRepl() {
     initialContentRow: dockCursor.row,
     initialContentCol: dockCursor.col,
   });
+  // 1 Hz live-tick for the elapsed clock in the dock's top strip.
+  // Only fires when the user is idle (inputActive === true) — while the
+  // agent is streaming content, skipping the tick avoids ANSI writes
+  // interleaving with the stream. Cheap: one renderIdleDockInput per
+  // second, only if mounted + idle. `unref()` so the timer never blocks
+  // process exit.
+  let _dockTickTimer = null;
   if (inputDockActive) {
     process.on('beforeExit', unmountInputDock);
     process.on('exit',       unmountInputDock);
+    _dockTickTimer = setInterval(() => {
+      if (!isInputDockMounted()) return;
+      if (!inputActive) return;
+      try { renderIdleDockInput(); } catch { /* one bad tick is not fatal */ }
+    }, 1000);
+    _dockTickTimer.unref?.();
+    process.on('exit', () => { if (_dockTickTimer) clearInterval(_dockTickTimer); });
   }
 
   // ── Bracketed paste (DEC private mode 2004) ──────────────────────────────
@@ -4270,7 +4424,7 @@ export async function startTerminalRepl() {
   // Proxy stream: swallows writes when the dock owns the input row so
   // readline's echoes and _refreshLine cursor moves can't fight the dock's
   // absolute cursor placement (PRD-081 §5.1 — cursor race). When the dock
-  // is not mounted (plain-mode fallback, KEPLER_FIXED_INPUT=0, non-TTY),
+  // is not mounted (plain-mode fallback, BAHULAM_FIXED_INPUT=0, non-TTY),
   // writes pass through so history navigation / backspace still redraw.
   const readlineOutputProxy = new _WritableStream({
     write(chunk, _enc, cb) {
@@ -4317,7 +4471,7 @@ export async function startTerminalRepl() {
     // 3 rows fits comfortably in the dock's reservation without leaking
     // past the safety row.
     if (isInputDockMounted()) return 3;
-    const raw = process.env.KEPLER_PROMPT_BOTTOM_PADDING ?? '5';
+    const raw = process.env.BAHULAM_PROMPT_BOTTOM_PADDING ?? '5';
     const n = Number.parseInt(raw, 10);
     if (!Number.isFinite(n) || n <= 0) return 0;
     return Math.min(8, n);
@@ -4590,14 +4744,14 @@ export async function startTerminalRepl() {
   //   1. If the terminal supports bracketed paste, we hold flushing until we
   //      see the ESC[201~ end marker — reliable regardless of paste latency.
   //   2. Otherwise we fall back to a short timer that merges bursts arriving
-  //      within KEPLER_PASTE_FLUSH_MS.
+  //      within BAHULAM_PASTE_FLUSH_MS.
   let _lineInFlight = false;
   const _queuedLines = [];
   let _pasteLines = [];
   let _pasteFlushTimer = null;
 
   function pasteFlushDelayMs() {
-    const raw = Number.parseInt(process.env.KEPLER_PASTE_FLUSH_MS || '35', 10);
+    const raw = Number.parseInt(process.env.BAHULAM_PASTE_FLUSH_MS || '35', 10);
     return Number.isFinite(raw) && raw >= 0 ? Math.min(250, raw) : 35;
   }
 
@@ -4743,7 +4897,7 @@ export async function startTerminalRepl() {
     // Create or reuse stream client — sessionId persists across turns.
     // The same client also owns the authenticated vision-analysis preflight.
     if (!streamClient || streamClient.baseUrl !== creds.backendUrl || streamClient.token !== creds.token) {
-      streamClient = new TarangStreamClient({
+      streamClient = new BahulamStreamClient({
         baseUrl: creds.backendUrl,
         token: creds.token,
         toolExecutor,
@@ -4767,7 +4921,7 @@ export async function startTerminalRepl() {
           `  ${c.brand('◇')} ${c.dim(`attached ${docPrep.documents.length} document${docPrep.documents.length === 1 ? '' : 's'}:`)} ` +
           `${docPrep.documents.map(documentSummaryLine).join(c.dim(' · '))}\n`
         );
-        jsonlWriter.writeKeplerEvent({
+        jsonlWriter.writeBahulamEvent({
           type: 'attachments',
           data: { documents: docPrep.documents.map(publicDocumentMetadata) },
         });
@@ -4783,7 +4937,7 @@ export async function startTerminalRepl() {
       });
       if (prepared.attachments.length) {
         process.stderr.write(`  ${c.brand('◇')} ${c.dim(`attached ${prepared.attachments.length} image${prepared.attachments.length === 1 ? '' : 's'}:`)} ${prepared.attachments.map(attachmentSummaryLine).join(c.dim(' · '))}\n`);
-        jsonlWriter.writeKeplerEvent({
+        jsonlWriter.writeBahulamEvent({
           type: 'attachments',
           data: { attachments: prepared.attachments.map(publicAttachmentMetadata) },
         });
@@ -4800,7 +4954,7 @@ export async function startTerminalRepl() {
           });
           process.stderr.write(`\r${' '.repeat(80)}\r`);
           process.stderr.write(`  ${c.green('✓')} ${c.dim(`Vision analysis completed for ${prepared.attachments.length} image${prepared.attachments.length === 1 ? '' : 's'}`)}${analysis.model ? c.dim(` · ${analysis.model}`) : ''}\n`);
-          jsonlWriter.writeKeplerEvent({
+          jsonlWriter.writeBahulamEvent({
             type: 'vision_analysis',
             data: {
               model: analysis.model || '',
@@ -4922,6 +5076,11 @@ export async function startTerminalRepl() {
       runtime.lastRenderedBlock = 'user';
     }
 
+    function isExecutionSlashCommand(instruction) {
+      const command = String(instruction || '').trim().split(/\s+/, 1)[0].toLowerCase();
+      return command === '/watch' || command === '/auto';
+    }
+
     async function submitExecutionInstruction() {
       const instruction = executionInputBuffer.trim();
       executionInputBuffer = '';
@@ -4940,6 +5099,25 @@ export async function startTerminalRepl() {
         executionInputVisible = false;
         return;
       }
+      if (isExecutionSlashCommand(instruction)) {
+        if (isInputDockMounted()) {
+          clearInputPrompt();
+          moveToContent();
+        } else if (executionInputVisible) {
+          process.stderr.write('\n');
+        }
+        executionInputVisible = false;
+        await handleCommand(instruction, ctx);
+        if (isInputDockMounted()) {
+          renderDockInput(executionInputPrefix(), '', {
+            context: buildContextStrip(),
+            meta: buildDockMeta(),
+            tips: executionInputTips(),
+          });
+          moveToContent();
+        }
+        return;
+      }
       printExecutionInstruction(instruction);
       if (isInputDockMounted()) {
         renderDockInput(executionInputPrefix(), '', {
@@ -4962,7 +5140,7 @@ export async function startTerminalRepl() {
       // Persist the local record regardless of outcome so the transcript
       // reflects what the user typed. Delivered/queued follow-ups will
       // get their SSE ack events written separately by the event handler.
-      jsonlWriter.writeKeplerEvent({
+      jsonlWriter.writeBahulamEvent({
         type: 'user_intervention',
         data: {
           instruction,
@@ -5333,7 +5511,7 @@ export async function startTerminalRepl() {
         _turnIterable = client.execute(input, execContext, session.agentHistory);
       }
       for await (const event of _turnIterable) {
-        jsonlWriter.writeKeplerEvent(event);
+        jsonlWriter.writeBahulamEvent(event);
         // . daemon event log. Env-var gated (off by default) —
         // when BAHULAM_DAEMON_EVENTLOG=1, mirror each SSE frame that maps
         // to a first-class type into ~/.bahulam/sessions/<id>/events.jsonl.