@bahulam/code 0.1.5 → 0.1.7

package/src/local-service/session-store.mjs

@@ -0,0 +1,221 @@
+/**
+ * Local workspace session store.
+ *
+ * A local service session grants one local directory to the browser shell and
+ * to the remote-agent bridge. If the user opens a single file, the grant root
+ * is the file's parent and focus_path records the selected file.
+ */
+
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import {
+  localServiceSessionDir,
+  localServiceSessionPath,
+  localServiceSessionsRoot,
+} from './paths.mjs';
+import { getLocalMachineIdentity } from './machine.mjs';
+
+const SESSION_PREFIX = 'lws';
+
+export function createLocalAccessToken() {
+  return crypto.randomBytes(24).toString('base64url');
+}
+
+export function hashLocalAccessToken(token) {
+  return crypto.createHash('sha256').update(String(token || '')).digest('hex');
+}
+
+export function verifyLocalAccessToken(session, token) {
+  if (!session?.token_hash || !token) return false;
+  const expected = Buffer.from(session.token_hash, 'hex');
+  const actual = Buffer.from(hashLocalAccessToken(token), 'hex');
+  return expected.length === actual.length && crypto.timingSafeEqual(expected, actual);
+}
+
+export function createLocalWorkspaceSession({
+  targetPath = process.cwd(),
+  cwd = process.cwd(),
+  kind = null,
+  title = null,
+  token = createLocalAccessToken(),
+} = {}) {
+  const grant = resolveGrant(targetPath, cwd);
+  const machine = getLocalMachineIdentity();
+  const now = new Date().toISOString();
+  const session = {
+    id: createSessionId(),
+    product: 'bahulam-local-service',
+    machine_id: machine.id,
+    machine_hostname: machine.hostname,
+    kind: kind || inferSessionKind(grant),
+    title: title || defaultSessionTitle(grant),
+    status: 'active',
+    root_path: grant.rootPath,
+    focus_path: grant.focusPath,
+    resource_type: grant.resourceType,
+    capabilities: inferCapabilities(grant),
+    created_at: now,
+    updated_at: now,
+    token_hash: hashLocalAccessToken(token),
+    remote_bridge: {
+      status: 'cli_relay',
+      contract: 'browser -> local-service -> cli-authenticated remote agent -> local tools',
+    },
+  };
+
+  writeLocalWorkspaceSession(session);
+  return { session: publicSession(session), token };
+}
+
+export function writeLocalWorkspaceSession(session) {
+  if (!session?.id) throw new Error('session.id is required');
+  const dir = localServiceSessionDir(session.id);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(localServiceSessionPath(session.id), `${JSON.stringify(session, null, 2)}\n`, {
+    mode: 0o600,
+  });
+}
+
+export function loadLocalWorkspaceSession(sessionId) {
+  if (!sessionId) return null;
+  const file = localServiceSessionPath(sessionId);
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export function listLocalWorkspaceSessions({ limit = 20 } = {}) {
+  let names = [];
+  try {
+    names = fs.readdirSync(localServiceSessionsRoot());
+  } catch {
+    return [];
+  }
+
+  return names
+    .map((name) => loadLocalWorkspaceSession(name))
+    .filter(Boolean)
+    .sort((a, b) => String(b.updated_at || '').localeCompare(String(a.updated_at || '')))
+    .slice(0, limit)
+    .map(publicSession);
+}
+
+export function touchLocalWorkspaceSession(sessionId, patch = {}) {
+  const session = loadLocalWorkspaceSession(sessionId);
+  if (!session) return null;
+  const updated = {
+    ...session,
+    ...patch,
+    updated_at: new Date().toISOString(),
+  };
+  writeLocalWorkspaceSession(updated);
+  return publicSession(updated);
+}
+
+export function publicSession(session) {
+  if (!session) return null;
+  const { token_hash, ...safe } = session;
+  return safe;
+}
+
+export function resolveGrant(inputPath, cwd = process.cwd()) {
+  const resolved = expandPath(inputPath || cwd, cwd);
+  let stat;
+  try {
+    stat = fs.statSync(resolved);
+  } catch {
+    throw new Error(`Path does not exist: ${resolved}`);
+  }
+
+  if (stat.isDirectory()) {
+    return {
+      rootPath: fs.realpathSync(resolved),
+      focusPath: '',
+      resourceType: 'directory',
+    };
+  }
+
+  if (stat.isFile()) {
+    const parent = fs.realpathSync(path.dirname(resolved));
+    return {
+      rootPath: parent,
+      focusPath: path.basename(resolved),
+      resourceType: 'file',
+    };
+  }
+
+  throw new Error(`Path is not a file or directory: ${resolved}`);
+}
+
+export function expandPath(inputPath, cwd = process.cwd()) {
+  let value = String(inputPath || '').trim();
+  if (!value) value = cwd;
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    value = value.slice(1, -1);
+  }
+  if (value === '~') value = os.homedir();
+  else if (value.startsWith('~/')) value = path.join(os.homedir(), value.slice(2));
+  if (!path.isAbsolute(value)) value = path.resolve(cwd, value);
+  return path.normalize(value);
+}
+
+function createSessionId() {
+  const stamp = Date.now().toString(36);
+  const rand = crypto.randomBytes(5).toString('hex');
+  return `${SESSION_PREFIX}_${stamp}_${rand}`;
+}
+
+function defaultSessionTitle(grant) {
+  if (grant.focusPath) return grant.focusPath;
+  return path.basename(grant.rootPath) || grant.rootPath;
+}
+
+function inferSessionKind(grant) {
+  if (grant.resourceType === 'file' && isDocumentLike(grant.focusPath)) return 'documents';
+  if (looksLikeCodeWorkspace(grant.rootPath)) return 'coding';
+  return 'workspace';
+}
+
+function inferCapabilities(grant) {
+  const caps = new Set([
+    'local_files',
+    'local_shell',
+    'browser_workspace',
+    'remote_agent_bridge',
+  ]);
+  if (grant.resourceType === 'file' && isDocumentLike(grant.focusPath)) caps.add('documents');
+  if (looksLikeCodeWorkspace(grant.rootPath)) caps.add('coding');
+  return [...caps];
+}
+
+function isDocumentLike(fileName) {
+  return /\.(?:pdf|docx?|xlsx?|pptx?|csv|tsv|rtf|odt|ods)$/i.test(String(fileName || ''));
+}
+
+function looksLikeCodeWorkspace(rootPath) {
+  const markers = [
+    '.git',
+    'package.json',
+    'pyproject.toml',
+    'requirements.txt',
+    'Cargo.toml',
+    'go.mod',
+    'pom.xml',
+    'Makefile',
+    'Dockerfile',
+    'AGENTS.md',
+    'CLAUDE.md',
+    'BAHULAM.md',
+  ];
+  return markers.some((marker) => {
+    try {
+      return fs.existsSync(path.join(rootPath, marker));
+    } catch {
+      return false;
+    }
+  });
+}

package/src/onboarding/preflight.mjs

@@ -4,7 +4,7 @@
  * Prints a non-blocking summary of the runtime environment before the REPL
  * starts so the user can see what is and is not aligned:
  *
- *   🔭 Bahulam Code v2.6.12 · initializing orbit
+ *   🔭 Bahulam Code v0.1.7 · initializing
  *
  *     [✓] Auth token
  *     [✓] OpenRouter key

package/src/terminal/analytics.mjs

@@ -202,11 +202,7 @@ export async function runHistoryCommand(args = []) {
   process.stdout.write(formatHistoryReport(history, limit));
 }
 
-// Dashboard removed — now using Bahulam Pulse (pulse/cli.js)
-
-export async function _runDashboardCommand_REMOVED() { /* see pulse/cli.js */ }
-
-export async function _OLD_runDashboardCommand(args = []) {
+export async function runDashboardCommand(args = []) {
   const requestedPort = parseNumber(readOption(args, '--port', '4318'), 4318);
   const host = readOption(args, '--host', '127.0.0.1') || '127.0.0.1';
   const shouldOpen = !hasFlag(args, '--no-open');
@@ -272,7 +268,7 @@ export async function _OLD_runDashboardCommand(args = []) {
   const actualPort = typeof address === 'object' && address ? address.port : requestedPort;
   const url = `http://${host}:${actualPort}`;
 
-  process.stderr.write(`\x1b[36mb0 dashboard\x1b[0m ${url}\n`);
+  process.stderr.write(`\x1b[36mBahulam dashboard\x1b[0m ${url}\n`);
   process.stderr.write(`\x1b[2mReading local analytics from ${getStorePaths().bahulamDir}\x1b[0m\n`);
   process.stderr.write(`\x1b[2mPress Ctrl+C to stop the dashboard server.\x1b[0m\n`);
 

package/src/terminal/ansi.mjs

@@ -2,7 +2,7 @@
  * ANSI Terminal Renderer — cursor control, box drawing, status bars.
  *
  * Color helpers (the `c` object) now route through the semantic palette
- * (`src/ui/palette.mjs`) so the entire CLI honors the Kepler brand and
+ * (`src/ui/palette.mjs`) so the entire CLI honors the Bahulam brand and
  * tier fallbacks (truecolor, ansi256, ansi16, none) without touching
  * each call site. Hot-swap-friendly: external semantics like `c.red`,
  * `c.bold`, `c.cyan` are preserved as the legacy contract; new code
@@ -35,7 +35,7 @@ export const cursor = {
 // ── Colors ──
 // Legacy color names re-mapped onto semantic palette tokens. The CLI's
 // branding is centralized in palette.mjs; this object is preserved only
-// so existing imports keep compiling. Internal Kepler color choices are
+// so existing imports keep compiling. Internal Bahulam color choices are
 // documented next to each mapping for the next code review.
 
 const identity = (s) => String(s ?? '');
@@ -132,12 +132,20 @@ export function inPlace(text) {
   }
   if (text) {
     write(text + '\n');
-    _lastLineCount = text.split('\n').length;
+    _lastLineCount = physicalLineCount(text);
   } else {
     _lastLineCount = 0;
   }
 }
 
+function physicalLineCount(text) {
+  const width = Math.max(1, process.stderr.columns || process.stdout.columns || 80);
+  return String(text || '').split('\n').reduce((total, line) => {
+    const cells = visibleWidth(line);
+    return total + Math.max(1, Math.ceil(cells / width));
+  }, 0);
+}
+
 // ── Status Bar (persistent bottom) ──
 
 export function statusBar(parts) {

package/src/terminal/main.mjs

@@ -8,6 +8,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { startTerminalRepl } from './repl.mjs';
 import {
+  runDashboardCommand,
   runSessionsCommand,
   runStatsCommand,
   runHistoryCommand,
@@ -123,16 +124,29 @@ async function main() {
   } catch {}
 
   if (subcommand === 'dashboard') {
-    // Launch Bahulam Pulse Next.js dashboard
-    const { spawn } = await import('node:child_process');
-    const { fileURLToPath } = await import('node:url');
-    const path = await import('node:path');
-    const cliPath = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'pulse', 'cli.js');
-    const child = spawn(process.execPath, [cliPath, ...subcommandArgs], {
-      stdio: 'inherit',
-      env: process.env,
-    });
-    child.on('exit', (code) => process.exit(code ?? 0));
+    // Try to open the live daemon's HTTP dashboard first
+    try {
+      const { findSessionForCwd } = await import('../daemon/daemonize.mjs');
+      const sid = await findSessionForCwd(process.cwd());
+      if (sid) {
+        const { daemonSessionDir } = await import('../core/paths.mjs');
+        const metaPath = path.join(daemonSessionDir(sid), 'meta.json');
+        if (fs.existsSync(metaPath)) {
+          const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+          if (meta.dashboard_url) {
+            process.stderr.write(`\x1b[2mOpening dashboard for session ${sid}…\x1b[0m\n`);
+            const { execSync } = await import('node:child_process');
+            const cmd = process.platform === 'darwin' ? 'open'
+                      : process.platform === 'win32' ? 'start'
+                      : 'xdg-open';
+            execSync(`${cmd} "${meta.dashboard_url}"`, { stdio: 'ignore', timeout: 3000 });
+            process.exit(0);
+            return;
+          }
+        }
+      }
+    } catch {}
+    await runDashboardCommand(subcommandArgs);
     return;
   }
 
@@ -227,6 +241,7 @@ async function main() {
                               Attach an image via the vision analysis pipeline
     bahulam --resume               Resume last conversation
     bahulam dashboard              Open analytics dashboard
+    bahulam workspace open [path]  Open a local browser workspace
     bahulam login                  Sign in via browser
     bahulam logout                 Sign out and clear credentials
     bahulam init                   Scaffold .bahulam config, memory, hooks, tasks
@@ -240,6 +255,11 @@ async function main() {
     bahulam remote enable      Enable relay connection
     bahulam remote disable     Disable relay connection (kill switch)
 
+  \x1b[1mLocal Workspaces:\x1b[0m
+    bahulam workspace open [path]  Start localhost workspace service
+    bahulam workspace list         List recent local workspace sessions
+    bahulam local open [path]      Alias for workspace open
+
   \x1b[1mAnalytics:\x1b[0m
     bahulam sessions               List recent local sessions
     bahulam stats                  Show aggregate local session stats
@@ -261,7 +281,7 @@ async function main() {
     /new                    Start a new session
     /clear                  Clear conversation history
     /safety                 Show safety guardrail status
-    /revoke                 Revoke auto-approvals
+    /approvals clear        Revoke all session auto-approvals
     /explore <query>        Spawn read-only codebase explorer
     /review <query>         Spawn code review agent
     /architect <query>      Spawn architecture planning agent
@@ -331,6 +351,12 @@ async function main() {
     return;
   }
 
+  if (subcommand === 'workspace' || subcommand === 'workspaces' || subcommand === 'local') {
+    const { runLocalWorkspaceCommand } = await import('../local-service/command.mjs');
+    await runLocalWorkspaceCommand(subcommandArgs, { cwd: process.cwd() });
+    return;
+  }
+
   //  auto-daemon spawn.
   //   bahulam daemonize [prompt]  → fork a detached bahulam child with
   //   the socket server up. Parent waits briefly for the child's session

package/src/terminal/model-catalog-display.mjs

@@ -0,0 +1,111 @@
+import { c } from './ansi.mjs';
+
+export const MODEL_CATEGORY_ORDER = [
+  'text',
+  'image_analysis',
+  'image_generation',
+  'image',
+  'multimodal',
+  'embedding',
+  'audio',
+  'video',
+  'other',
+];
+
+export function modelCategory(model) {
+  const category = String(model?.category || 'text').trim().toLowerCase();
+  return category === 'chat' ? 'text' : (category || 'text');
+}
+
+export function isImageGenerationModel(model) {
+  const text = `${model?.id || ''} ${model?.label || ''}`.toLowerCase();
+  return (
+    text.includes('image generation') ||
+    text.includes('generate image') ||
+    text.includes('gemini-3-pro-image') ||
+    text.includes('nano banana')
+  );
+}
+
+export function modelDisplayCategory(model) {
+  const category = modelCategory(model);
+  if (category === 'image') {
+    return isImageGenerationModel(model) ? 'image_generation' : 'image_analysis';
+  }
+  return category;
+}
+
+export function normalizeCatalogCategory(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (!raw) return null;
+  if (raw === 'chat') return 'text';
+  if (raw === 'image-analysis' || raw === 'vision') return 'image_analysis';
+  if (raw === 'image-generation' || raw === 'image-gen') return 'image_generation';
+  return raw;
+}
+
+export function modelMatchesCatalogFilter(model, filter) {
+  if (!filter) return true;
+  if (filter === 'image') return modelCategory(model) === 'image';
+  return modelDisplayCategory(model) === filter || modelCategory(model) === filter;
+}
+
+export function modelCategoryLabel(category, { plural = false } = {}) {
+  const labels = {
+    text: 'text',
+    image: 'image',
+    image_analysis: 'image analysis',
+    image_generation: 'image generation',
+    embedding: 'embedding',
+    audio: 'audio',
+    video: 'video',
+    other: 'other',
+    multimodal: 'multimodal',
+  };
+  const base = labels[String(category || '').trim().toLowerCase()] || 'other';
+  return plural ? `${base} models` : base;
+}
+
+function categoryColor(category) {
+  switch (String(category || '').trim().toLowerCase()) {
+    case 'text':
+      return c.brand;
+    case 'image':
+    case 'image_analysis':
+      return c.magenta;
+    case 'image_generation':
+      return c.yellow;
+    case 'multimodal':
+      return c.cyanBold;
+    case 'embedding':
+      return c.green;
+    case 'audio':
+      return c.cyanRegular;
+    case 'video':
+      return c.red;
+    default:
+      return c.gray;
+  }
+}
+
+export function formatCategoryBadge(category, { plural = false } = {}) {
+  const normalized = String(category || 'text').trim().toLowerCase() || 'text';
+  return categoryColor(normalized)(`[${modelCategoryLabel(normalized, { plural })}]`);
+}
+
+export function formatCategoryHeading(category, count = null) {
+  const label = modelCategoryLabel(category, { plural: true });
+  const countText = Number.isFinite(Number(count)) ? ` ${c.dim(`(${count})`)}` : '';
+  return `${categoryColor(category)(c.bold(label))}${countText}`;
+}
+
+export function cacheProfileLabel(value) {
+  if (!value) return '';
+  try {
+    const parsed = typeof value === 'string' ? JSON.parse(value) : value;
+    if (parsed?.type === 'prefix_hash') return 'prefix cache';
+  } catch {
+    // Fall through to the generic cache hint.
+  }
+  return 'cache';
+}

package/src/terminal/repl-format.mjs

@@ -11,6 +11,8 @@ import * as path from 'node:path';
 import { c, stripAnsi, formatElapsed, inPlace } from './ansi.mjs';
 import * as rqueue from '../ui/render-queue.mjs';
 
+const ANSI_RESET = '\x1b[0m';
+
 // Transient one-line status writer that is safe under the render queue.
 // Raw inPlace() writes get REDIRECTED into transcript content when the
 // queue is active (cursor codes stripped) — that leaked one line per
@@ -102,7 +104,7 @@ export function fitAnsiLine(text, maxColumns) {
     out += value[i];
     visible++;
   }
-  return `${out}${c.dim('…')}`;
+  return `${out}${ANSI_RESET}${c.dim('…')}`;
 }
 
 // ── PRD-068 §5.14 helpers ────────────────────────────────────────────
@@ -284,6 +286,7 @@ export function normalizeResumableSession(s) {
     resumeSummary: s.resumeSummary || null,    // latest resume_summary checkpoint metadata
     models: Array.isArray(s.models) ? s.models : [],
     modelLimits: s.modelLimits && typeof s.modelLimits === 'object' ? s.modelLimits : {},
+    subAgentModels: s.subAgentModels && typeof s.subAgentModels === 'object' ? s.subAgentModels : {},
     costUsd: typeof s.costUsd === 'number' ? s.costUsd : 0,
     partial: !!s.partial,                      // true if the transcript file was partially malformed
     source: 'transcript',

package/src/terminal/repl-model-form.mjs

@@ -8,8 +8,15 @@
  * mode on, redraw in place with cursor-up + erase-down, restore on exit.
  */
 
-import { c } from './ansi.mjs';
+import { c, stripAnsi } from './ansi.mjs';
 import { fitAnsiLine, writeOverlayFrame, eraseOverlayFrame } from './repl-format.mjs';
+import {
+  cacheProfileLabel,
+  formatCategoryBadge,
+  isImageGenerationModel,
+  modelCategory,
+  modelDisplayCategory,
+} from './model-catalog-display.mjs';
 
 const DEFAULT_SENTINEL = '__default__';
 
@@ -20,10 +27,33 @@ function creditBadge(row) {
   return `~${credits < 10 ? credits.toFixed(1) : String(Math.round(credits))} cr/M`;
 }
 
+function formatTokenLimit(value, label) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return '';
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1).replace(/\.0$/, '')}M ${label}`;
+  if (n >= 1_000) return `${Math.round(n / 1_000)}K ${label}`;
+  return `${Math.round(n)} ${label}`;
+}
+
+function optionRowsForRole(catalog, row) {
+  const curated = (catalog || []).filter(m => m?.harness_validated && m?.id);
+  const group = String(row?.optionGroup || 'text').toLowerCase();
+  if (group === 'image_analysis') {
+    return curated.filter(m => (
+      ['image', 'multimodal'].includes(modelCategory(m))
+      && !isImageGenerationModel(m)
+    ));
+  }
+  if (group === 'image_generation') {
+    return curated.filter(m => modelCategory(m) === 'image' && isImageGenerationModel(m));
+  }
+  return curated.filter(m => ['text', 'chat'].includes(modelCategory(m)));
+}
+
 /**
  * @param {object} opts
  * @param {object|null} opts.rl        readline instance to pause/resume
- * @param {Array}  opts.roles          [{ role, label, current, defaultLabel }]
+ * @param {Array}  opts.roles          [{ role, label, description, current, defaultLabel, optionGroup }]
  * @param {Array}  opts.catalog        raw /api/models rows (may be empty)
  * @param {Array}  [opts.fallbackIds]  model ids to cycle when no curated catalog
  * @param {string} [opts.unavailableNote] why the catalog is missing (shown in header)
@@ -33,25 +63,24 @@ export async function pickModelOverridesForm({ rl, roles, catalog, fallbackIds,
   if (!process.stdin.isTTY) return null;
   if (rl) rl.pause();
 
-  const curated = (catalog || []).filter(m => m?.harness_validated && m?.id);
-  const usingFallback = curated.length === 0;
-  const optionIds = usingFallback
-    ? [...new Set((fallbackIds || []).filter(Boolean))]
-    : curated.map(m => m.id);
-  const baseOptions = [DEFAULT_SENTINEL, ...optionIds];
-  const byId = new Map(curated.map(m => [m.id, m]));
+  const catalogRows = (catalog || []).filter(m => m?.harness_validated && m?.id);
+  const usingFallback = catalogRows.length === 0;
+  const byId = new Map(catalogRows.map(m => [m.id, m]));
 
   // Per-row option list; a current override that isn't in the curated list
   // is appended so it stays visible and selectable.
   const rows = roles.map(r => {
-    let opts = baseOptions;
+    const optionIds = usingFallback
+      ? [...new Set((fallbackIds || []).filter(Boolean))]
+      : optionRowsForRole(catalogRows, r).map(m => m.id);
+    let opts = [DEFAULT_SENTINEL, ...optionIds];
     let idx = 0;
     if (r.current) {
-      const found = baseOptions.indexOf(r.current);
+      const found = opts.indexOf(r.current);
       if (found >= 0) {
         idx = found;
       } else {
-        opts = [...baseOptions, r.current];
+        opts = [...opts, r.current];
         idx = opts.length - 1;
       }
     }
@@ -76,8 +105,38 @@ export async function pickModelOverridesForm({ rl, roles, catalog, fallbackIds,
       return `${c.brand(value)}${badge ? ` ${c.dim(badge)}` : ''}${flag}`;
     };
 
+    const valueDescription = (row) => {
+      const value = row.opts[row.idx];
+      if (value === DEFAULT_SENTINEL) {
+        return row.description || 'backend default for this role';
+      }
+      const meta = byId.get(value);
+      if (!meta) {
+        return usingFallback ? 'backend configured model' : 'custom override outside curated catalog';
+      }
+      const label = String(meta.label || '').trim();
+      const parts = [];
+      if (label && label !== value) parts.push(c.white(label));
+      if (meta.provider) parts.push(c.dim(String(meta.provider)));
+      const category = modelDisplayCategory(meta);
+      if (category) parts.push(formatCategoryBadge(category));
+      const context = formatTokenLimit(meta.context_length, 'ctx');
+      if (context) parts.push(c.dim(context));
+      const output = formatTokenLimit(meta.max_output, 'out');
+      if (output) parts.push(c.dim(output));
+      if (meta.supports_tools) parts.push(c.green('tools'));
+      if (meta.supports_reasoning) parts.push(c.yellow('reasoning'));
+      const cache = cacheProfileLabel(meta.cache_profile);
+      if (cache) parts.push(c.cyan(cache));
+      return parts.join(c.dim(' · '));
+    };
+
     const render = () => {
       const cols = Math.max(60, process.stderr.columns || 120);
+      const labelWidth = Math.min(
+        18,
+        Math.max(14, ...rows.map(row => stripAnsi(String(row.label || row.role)).length)),
+      );
       const lines = [];
       lines.push(`  ${c.bold('Models')} ${c.dim('· session overrides · curated platform catalog')}`);
       if (usingFallback) {
@@ -87,9 +146,17 @@ export async function pickModelOverridesForm({ rl, roles, catalog, fallbackIds,
       lines.push('');
       rows.forEach((row, i) => {
         const marker = i === cursor ? c.brand('▸') : ' ';
-        const rawLabel = String(row.label || row.role).padEnd(14, ' ');
+        const rawLabel = String(row.label || row.role).padEnd(labelWidth, ' ');
         const label = i === cursor ? c.brand(rawLabel) : rawLabel;
-        lines.push(fitAnsiLine(`  ${marker} ${label} ${c.dim('‹')} ${valueLabel(row)} ${c.dim('›')}`, cols - 1));
+        const prefix = `  ${marker} ${label} ${c.dim('‹')} `;
+        const suffix = ` ${c.dim('›')}`;
+        const descText = valueDescription(row);
+        const descMaxCols = Math.max(0, Math.min(72, cols - stripAnsi(prefix + suffix).length - 24));
+        const desc = descText && descMaxCols > 12
+          ? `  ${fitAnsiLine(descText, descMaxCols)}`
+          : '';
+        const maxValueCols = Math.max(18, cols - stripAnsi(prefix + suffix + desc).length - 1);
+        lines.push(fitAnsiLine(`${prefix}${fitAnsiLine(valueLabel(row), maxValueCols)}${suffix}${desc}`, cols - 1));
       });
       lines.push('');
       lines.push(fitAnsiLine(`  ${c.dim('↑↓ role · ←→ model · Enter apply · c defaults · Esc cancel')}`, cols - 1));