@bahulam/code 0.1.6 → 0.1.7

package/src/terminal/repl-render.mjs

@@ -21,6 +21,7 @@ import { paint } from '../ui/palette.mjs';
 import { runtime, session } from './repl-state.mjs';
 import { fitAnsiLine } from './repl-format.mjs';
 import { exploreCategory, isExploreTool } from './repl-explore.mjs';
+import { watchState } from './watch-state.mjs';
 import {
   clearPinnedStatus,
   drawPinnedStatus,
@@ -36,21 +37,50 @@ import * as queue from '../ui/render-queue.mjs';
 // Max inner-tool lines shown under the spinner during a sub-agent run.
 const SUB_AGENT_WINDOW_ROWS = 7;
 
+function statusWidth() {
+  return Math.max(8, (process.stderr.columns || process.stdout.columns || 120) - 1);
+}
+
+function fitStatusLine(line) {
+  return fitAnsiLine(String(line ?? '').replace(/[\r\n]+/g, ' '), statusWidth());
+}
+
+function fitStatusLines(lines) {
+  return (Array.isArray(lines) ? lines : [lines]).map(fitStatusLine);
+}
+
 function presentStatus(rendered) {
+  // Watch panel override: when active, render the watch panel entries as a
+  // multi-line status block instead of the normal spinner/status line.
+  if (watchState.active) {
+    const lines = watchState.visible();
+    if (lines.length) {
+      const fitted = fitStatusLines(lines);
+      if (queue.isActive()) {
+        queue.statusBlock(fitted);
+      } else if (isInputDockMounted()) {
+        drawPinnedStatus(fitted.join('\n'));
+      } else {
+        inPlace(fitted.join('\n'));
+      }
+      return;
+    }
+  }
+  const fitted = fitStatusLine(rendered);
   if (queue.isActive()) {
     const win = runtime.subAgentWindow;
     if (win?.active && win.lines.length) {
       queue.statusBlock([
-        rendered,
-        ...win.lines.slice(-SUB_AGENT_WINDOW_ROWS).map(l => `    ${c.dim(l)}`),
+        fitted,
+        ...fitStatusLines(win.lines.slice(-SUB_AGENT_WINDOW_ROWS).map(l => `    ${c.dim(l)}`)),
       ]);
       return;
     }
-    queue.status(rendered);
+    queue.status(fitted);
     return;
   }
-  if (isInputDockMounted()) { drawPinnedStatus(rendered); return; }
-  inPlace(rendered);
+  if (isInputDockMounted()) { drawPinnedStatus(fitted); return; }
+  inPlace(fitted);
 }
 
 /** Push a line into the live sub-agent tool window (dedup consecutive). */

package/src/terminal/repl-state.mjs

@@ -62,6 +62,10 @@ export const runtime = {
   // N lines under the spinner) instead of appending to the transcript.
   // Full detail stays on the recorded cards (/expand, /last, `d`).
   subAgentWindow: { active: false, lines: [] },
+
+  // PRD-092: Watch panel — toggled by /watch. When active, the spinner
+  // area renders a compact agent-activity summary instead of the spinner.
+  watchPanelActive: false,
 };
 
 // Full session state for the current CLI process. Set by the REPL loop
@@ -73,6 +77,13 @@ export const session = {
   startTime: Date.now(),
   inputTokens: 0,
   outputTokens: 0,
+  // Per-turn context indicator for the dock strip. Updated at each
+  // AGENT_COMPLETE from the backend's usage.total_input_tokens (the
+  // cumulative input the primary agent sent this turn across all its
+  // internal inferences). Rough proxy for "how big is the prompt right
+  // now" — approximates what the NEXT user turn will pay before any
+  // growth. Reset by /new.
+  lastTurnInputTokens: 0,
   toolCalls: 0,        // primary-agent tool calls in the current turn
   subAgentToolCalls: 0,// forwarded internal sub-agent tool calls in the current turn
   totalToolCalls: 0,   // across all turns
@@ -85,6 +96,7 @@ export const session = {
   user: null,          // { github_username, email, role }
   model: null,         // from backend user profile
   modelLimits: {},     // role -> {model, context_length, max_output, source}
+  subAgentModels: {},  // role -> model from backend session_info
   blockedOps: 0,       // safety guardrail blocks
   delegations: [],     // agent delegation events: { from, to, time }
   phases: [],          // phase history: { name, time }

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.
  *
@@ -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) ─────────────────────
@@ -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.
@@ -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 {}
 }
@@ -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,
@@ -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) ──────────────────────────────
@@ -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(), '', {