@pellux/goodvibes-agent 1.4.3 → 1.5.0

package/src/renderer/model-workspace.ts

@@ -8,10 +8,24 @@
 import type { ModelDefinition } from '@pellux/goodvibes-sdk/platform/providers';
 import type { ModelPickerModal } from '../input/model-picker.ts';
 import type { ModelPickerTargetInfo } from '../input/model-picker.ts';
+import { isLocalFitRecommendation, isProviderSignInRow, LOCAL_REC_PROVIDER } from '../input/model-picker-local-fit.ts';
+import { estimateModelBytes, fitAssessment, fitVerdictLabel, paramCountFromModel, readHardwareProfileSync, REPRESENTATIVE_7B_PARAMS } from '../core/hardware-profile.ts';
 import type { Line } from '../types/grid.ts';
-import { createEmptyLine, createStyledCell } from '../types/grid.ts';
+import { createStyledCell } from '../types/grid.ts';
 import { getDisplayWidth, wrapText } from '../utils/terminal-width.ts';
 import { GLYPHS, UI_TONES } from './ui-primitives.ts';
+import {
+  clamp,
+  clipDisplay,
+  contentLine,
+  fillRange,
+  makeLine,
+  padDisplay,
+  stableWindow,
+  writeText,
+  borderLine as primsBorderLine,
+  drawVerticalRule,
+} from './fullscreen-primitives.ts';
 
 const PALETTE = {
   border: '#64748b',
@@ -58,98 +72,30 @@ const MODEL_WORKSPACE_CONTEXT_CAP_INPUT_HELP = 'Type digits to set a cap. Enter
 const MODEL_WORKSPACE_FOOTER_SEARCH_ACTIVE = 'Typing filters search; Esc clears search';
 const MODEL_WORKSPACE_FOOTER_SEARCH_INACTIVE = '/ search';
 const MODEL_WORKSPACE_FOOTER_CONTROLS = 'Up/Down navigate • Left/Right pane • Enter select • <search> • Tab price • C caps • A available • B benchmark • G group • Esc close';
+const MODEL_WORKSPACE_LOCAL_ONLY_HEADER = 'No provider signed in — these run on your machine';
+const MODEL_WORKSPACE_LOCAL_ONLY_SIGN_IN = 'Sign in instead: select "Sign in to a provider" in the list below to connect a cloud or local provider.';
 
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}
-
-function fillRange(line: Line, startX: number, endX: number, bg: string): void {
-  for (let x = Math.max(0, startX); x <= Math.min(line.length - 1, endX); x += 1) {
-    const cell = line[x] ?? createStyledCell(' ');
-    line[x] = createStyledCell(cell.char, {
-      fg: cell.fg,
-      bg,
-      bold: cell.bold,
-      dim: cell.dim,
-      underline: cell.underline,
-      italic: cell.italic,
-      strikethrough: cell.strikethrough,
-      link: cell.link,
-    });
-  }
-}
-
-function makeLine(width: number, bg = ''): Line {
-  const line = createEmptyLine(width);
-  if (bg) fillRange(line, 0, width - 1, bg);
-  return line;
-}
-
-function writeText(line: Line, startX: number, maxWidth: number, text: string, style: Partial<Omit<Line[number], 'char'>> = {}): void {
-  let x = startX;
-  let used = 0;
-  for (const ch of text) {
-    const width = getDisplayWidth(ch);
-    if (width <= 0) continue;
-    if (used + width > maxWidth || x >= line.length) break;
-    line[x] = createStyledCell(ch, style);
-    if (width > 1 && x + 1 < line.length) {
-      line[x + 1] = createStyledCell(' ', style);
-    }
-    x += width;
-    used += width;
-  }
+/**
+ * Returns true when every model in the picker's list is a synthetic local
+ * fit recommendation (no real credentials configured).
+ */
+function isLocalOnlyList(picker: ModelPickerModal): boolean {
+  if (picker.mode !== 'model') return false;
+  const models = picker.models;
+  return models.length > 0 && models.every((m) => m.provider === LOCAL_REC_PROVIDER || isLocalFitRecommendation(m));
 }
 
+// Local wrappers that forward PALETTE.border as the fg/borderFg default, keeping
+// the same visual output as the deleted local copies.
 function borderLine(width: number, left: string, fill: string, right: string): Line {
-  const line = makeLine(width);
-  if (width <= 0) return line;
-  line[0] = createStyledCell(left, { fg: PALETTE.border });
-  for (let x = 1; x < width - 1; x += 1) {
-    line[x] = createStyledCell(fill, { fg: PALETTE.border });
-  }
-  if (width > 1) line[width - 1] = createStyledCell(right, { fg: PALETTE.border });
-  return line;
-}
-
-function contentLine(width: number, bg: string): Line {
-  const line = makeLine(width, bg);
-  if (width > 0) line[0] = createStyledCell(GLYPHS.frame.vertical, { fg: PALETTE.border });
-  if (width > 1) line[width - 1] = createStyledCell(GLYPHS.frame.vertical, { fg: PALETTE.border });
-  return line;
+  return primsBorderLine(width, left, fill, right, PALETTE.border);
 }
 
+// drawVertical intentionally keeps the original guard (x<=0) which differs from
+// drawVerticalRule in fullscreen-primitives (x<0). Callers rely on the <=0 skip.
 function drawVertical(line: Line, x: number, bg = ''): void {
   if (x <= 0 || x >= line.length - 1) return;
-  line[x] = createStyledCell(GLYPHS.frame.vertical, { fg: PALETTE.border, bg });
-}
-
-function clipDisplay(text: string, width: number): string {
-  if (width <= 0) return '';
-  let used = 0;
-  let output = '';
-  for (const ch of text) {
-    const chWidth = getDisplayWidth(ch);
-    if (chWidth <= 0) continue;
-    if (used + chWidth > width) break;
-    output += ch;
-    used += chWidth;
-  }
-  return output;
-}
-
-function padDisplay(text: string, width: number): string {
-  const clipped = clipDisplay(text, width);
-  return clipped + ' '.repeat(Math.max(0, width - getDisplayWidth(clipped)));
-}
-
-function stableWindow(total: number, selected: number, visible: number): { start: number; end: number } {
-  if (total <= 0 || visible <= 0) return { start: 0, end: 0 };
-  const clamped = clamp(selected, 0, total - 1);
-  const half = Math.floor(visible / 2);
-  const maxStart = Math.max(0, total - visible);
-  const start = clamp(clamped - half, 0, maxStart);
-  return { start, end: Math.min(total, start + visible) };
+  drawVerticalRule(line, x, PALETTE.border, bg);
 }
 
 function formatContext(value: number | undefined): string {
@@ -241,6 +187,8 @@ export function renderModelWorkspacePackageText(): string {
     'Detected context: <context>',
     'Override: <cap>',
     MODEL_WORKSPACE_CONTEXT_CAP_INPUT_HELP,
+    MODEL_WORKSPACE_LOCAL_ONLY_HEADER,
+    MODEL_WORKSPACE_LOCAL_ONLY_SIGN_IN,
     'Focus targets',
     'Focus list',
     modelWorkspaceFooterControls(MODEL_WORKSPACE_FOOTER_SEARCH_ACTIVE),
@@ -248,12 +196,66 @@ export function renderModelWorkspacePackageText(): string {
   ].join('\n');
 }
 
+/**
+ * Returns a plain-language hardware fit line for a local model, or an empty
+ * string when the model is not local or when the verdict is unknown.
+ * Uses the process-level cached hardware probe — never probes per render.
+ */
+/**
+ * Format a param count (e.g. 70e9) as a human-readable size token (e.g. '70B', '1.5B').
+ * Used to build the sizeDescriptor passed to fitVerdictLabel.
+ */
+function formatParamDescriptor(params: number): string {
+  const b = params / 1e9;
+  // Avoid floating-point noise: round to 1 decimal, strip trailing .0
+  const rounded = Math.round(b * 10) / 10;
+  return rounded === Math.floor(rounded) ? `${Math.floor(rounded)}B` : `${rounded}B`;
+}
+
+function modelHardwareFitLine(model: ModelDefinition): string {
+  const provider = (model.provider ?? '').toLowerCase();
+  // Anchor on known local-provider identities only; cloud providers that happen
+  // to serve Llama/local-named models (Groq 'llama-3.1-70b', Together
+  // 'meta-llama/...') are NOT local and must not be annotated.
+  const isLocal =
+    provider === 'ollama' ||
+    provider === 'vllm' ||
+    provider === 'llama-cpp' ||
+    provider === 'llama.cpp' ||
+    provider === 'lm-studio' ||
+    provider === 'lmstudio' ||
+    provider === 'localai' ||
+    provider === 'tgi' ||
+    provider === 'local-openai' ||
+    provider === 'openai-compatible-local';
+  if (!isLocal) return '';
+  // Use the actual param count from the model id/displayName when parseable;
+  // fall back to the shared 7B representative constant otherwise.
+  const parsedParams = paramCountFromModel(model);
+  const params = parsedParams ?? REPRESENTATIVE_7B_PARAMS;
+  const sizeBytes = estimateModelBytes(params);
+  // Build a human-readable size descriptor only when we could parse the real size.
+  const sizeDescriptor = parsedParams !== null
+    ? formatParamDescriptor(parsedParams)
+    : undefined;
+  const label = fitVerdictLabel(fitAssessment(sizeBytes, readHardwareProfileSync()), sizeDescriptor);
+  return label ? `Hardware: ${label}` : '';
+}
+
 function detailLines(picker: ModelPickerModal, width: number): string[] {
   const target = picker.getSelectedTargetInfo();
   const targetLabel = target?.label ?? targetLabelFor(picker.target);
   const targetState = target ? (target.enabled ? 'enabled' : 'disabled') : 'active';
   const selected = selectedModel(picker);
   const lines: string[] = [];
+
+  // Local-only header: shown when the list contains only synthetic fit recommendations.
+  // Never show when any real provider is configured.
+  if (isLocalOnlyList(picker)) {
+    lines.push(MODEL_WORKSPACE_LOCAL_ONLY_HEADER);
+    lines.push(MODEL_WORKSPACE_LOCAL_ONLY_SIGN_IN);
+  }
+
   lines.push(`Target: ${targetLabel} (${targetState})`);
   if (target) lines.push(`Current: ${targetSummary(target)}`);
   if (picker.mode === 'provider') {
@@ -269,7 +271,20 @@ function detailLines(picker: ModelPickerModal, width: number): string[] {
         caps.multimodal ? 'vision' : '',
         caps.toolCalling ? 'tools' : '',
       ].filter(Boolean).join(', ') || 'standard';
-      lines.push(`Selected: ${modelKey(selected)} | ${selected.displayName} | context ${formatContext(selected.contextWindow)} | ${capText}`);
+      // Suppress the key:id line for synthetic local recommendations — they have
+      // no real registry key and displaying the synthetic id would confuse users.
+      if (isProviderSignInRow(selected)) {
+        lines.push('Sign in to a provider to connect a cloud or local model.');
+        if (selected.description) lines.push(selected.description);
+      } else if (!isLocalFitRecommendation(selected)) {
+        lines.push(`Selected: ${modelKey(selected)} | ${selected.displayName} | context ${formatContext(selected.contextWindow)} | ${capText}`);
+      } else {
+        lines.push(`Selected: ${selected.displayName}`);
+        // Show the fit hint from the description (e.g. "not yet installed (fits in GPU memory)")
+        if (selected.description) lines.push(selected.description);
+      }
+      const fitLine = modelHardwareFitLine(selected);
+      if (fitLine) lines.push(fitLine);
     }
   } else if (picker.mode === 'effort') {
     lines.push(MODEL_WORKSPACE_REASONING_EFFORT_DETAIL);

package/src/{panels → renderer}/polish.ts

@@ -1,9 +1,9 @@
 import type { Line } from '../types/grid.ts';
 import { createEmptyLine, createStyledCell } from '../types/grid.ts';
 import { getDisplayWidth, wrapText } from '../utils/terminal-width.ts';
-import { getSurfaceContentRows, getTrackedVisibleWindow, getVisibleWindow, type VisibleWindow } from '../renderer/surface-layout.ts';
-import { GLYPHS, UI_TONES } from '../renderer/ui-primitives.ts';
-import { type StatusState, STATE_GLYPHS } from '../renderer/status-glyphs.ts';
+import { getSurfaceContentRows, getTrackedVisibleWindow, getVisibleWindow, type VisibleWindow } from './surface-layout.ts';
+import { GLYPHS, UI_TONES } from './ui-primitives.ts';
+import { type StatusState, STATE_GLYPHS } from './status-glyphs.ts';
 
 export interface PanelPalette {
   readonly label: string;

package/src/renderer/shell-surface.ts

@@ -36,17 +36,16 @@ export interface ShellFooterBuildResult {
   readonly height: number;
 }
 
-const FOOTER_BASE_ROWS = 9;
-const CONTEXT_PROGRESS_ROWS = 2;
+// Footer chrome: box top + box bottom + status line + hints line.
+const FOOTER_BASE_ROWS = 4;
 const PROCESS_INDICATOR_ROWS = 1;
 
 export function estimateShellFooterHeight(
   promptLineCount: number,
-  contextWindow?: number,
+  _contextWindow?: number,
 ): number {
   const safePromptLines = Math.max(1, promptLineCount);
-  const progressRows = contextWindow && contextWindow > 0 ? CONTEXT_PROGRESS_ROWS : 0;
-  return FOOTER_BASE_ROWS + safePromptLines + progressRows + PROCESS_INDICATOR_ROWS;
+  return FOOTER_BASE_ROWS + safePromptLines + PROCESS_INDICATOR_ROWS;
 }
 
 export function buildShellFooter(

package/src/renderer/status-token.ts

@@ -12,7 +12,8 @@
 // ---------------------------------------------------------------------------
 
 import type { Cell } from '../types/grid.ts';
-import { DEFAULT_PANEL_PALETTE } from '../panels/polish.ts';
+import { DEFAULT_PANEL_PALETTE } from './polish.ts';
+import { getDisplayWidth } from '../utils/terminal-width.ts';
 import { type StatusState, STATE_GLYPHS } from './status-glyphs.ts';
 
 // Re-export for downstream consumers that import from this module.
@@ -54,14 +55,33 @@ export function buildStatusToken(
   const suffix = opts?.count !== undefined ? ` (${opts.count})` : '';
   const text = `${glyph} ${label}${suffix}`;
 
-  return text.split('').map((char): Cell => ({
-    char,
-    fg: color,
-    bg: '',
-    bold: false,
-    dim: false,
-    underline: false,
-    italic: false,
-    strikethrough: false,
-  }));
+  const cells: Cell[] = [];
+  for (const char of text) {
+    const displayW = getDisplayWidth(char);
+    cells.push({
+      char,
+      fg: color,
+      bg: '',
+      bold: false,
+      dim: false,
+      underline: false,
+      italic: false,
+      strikethrough: false,
+    });
+    if (displayW > 1) {
+      // Continuation cell for wide characters (CJK, emoji) to occupy the
+      // second terminal column without introducing a broken surrogate half.
+      cells.push({
+        char: '',
+        fg: color,
+        bg: '',
+        bold: false,
+        dim: false,
+        underline: false,
+        italic: false,
+        strikethrough: false,
+      });
+    }
+  }
+  return cells;
 }

package/src/renderer/tab-strip.ts

@@ -1,6 +1,6 @@
 import type { Line } from '../types/grid.ts';
 import { getDisplayWidth } from '../utils/terminal-width.ts';
-import { buildStyledPanelLine, type StyledPanelSegment } from '../panels/polish.ts';
+import { buildStyledPanelLine, type StyledPanelSegment } from './polish.ts';
 
 export interface TabStripItem {
   readonly label: string;

package/src/renderer/tool-call.ts

@@ -3,9 +3,10 @@ import { LAYOUT, TOOL_STATUS } from './layout.ts';
 import { getDisplayWidth, truncateDisplay } from '../utils/terminal-width.ts';
 import type { ToolCall } from '@pellux/goodvibes-sdk/platform/types';
 import { stripDangerousAnsi } from './ansi-sanitize.ts';
+import { friendlyToolLabel } from './tool-labels.ts';
 
 const TOOL_NAME_MIN_WIDTH = 8;
-const TOOL_NAME_MAX_WIDTH = 20;
+const TOOL_NAME_MAX_WIDTH = 30;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
@@ -137,11 +138,11 @@ function extractKeyArg(toolCall: ToolCall): string {
     if (url) return url;
   }
   // Agent
-  if (typeof args.task === 'string') return args.task.slice(0, 40);
+  if (typeof args.task === 'string') return [...args.task].slice(0, 40).join('');
   if (typeof args.mode === 'string') return args.mode;
   // Fallback: first string value
   for (const val of Object.values(args)) {
-    if (typeof val === 'string' && val.length > 0) return val.slice(0, 40);
+    if (typeof val === 'string' && val.length > 0) return [...val].slice(0, 40).join('');
   }
   return '';
 }
@@ -200,13 +201,11 @@ export function renderToolCallBlock(
   }
   col += 2; // icon + space
 
-  // Tool name — extract short name for long MCP tool names, but keep a readable dynamic width.
-  const rawName = toolCall.name.includes('__')
-    ? toolCall.name.split('__').pop()!
-    : toolCall.name;
+  // Human phrase for the tool ("Searching the web") instead of the raw name.
+  const rawName = friendlyToolLabel(toolCall.name);
   const keyArg = stripDangerousAnsi(extractKeyArg(toolCall));
   const suffixText = status === 'error' && errorMsg
-    ? `- ${stripDangerousAnsi(errorMsg).slice(0, 40)}`
+    ? `- ${[...stripDangerousAnsi(errorMsg)].slice(0, 40).join('')}`
     : status === 'done' && resultSummary
       ? `(${stripDangerousAnsi(resultSummary)})`
       : '';

package/src/renderer/tool-labels.ts

@@ -0,0 +1,92 @@
+/**
+ * Friendly tool labels — turn internal tool names into the phrase a person
+ * would say. Shown on tool-call lines in the conversation; the raw tool name
+ * is still discoverable in the Agent workspace tool catalog.
+ */
+
+const TOOL_LABELS: Record<string, string> = {
+  // SDK file/shell/web tools
+  read: 'Reading files',
+  write: 'Writing a file',
+  edit: 'Editing a file',
+  exec: 'Running a command',
+  fetch: 'Fetching a web page',
+  web_search: 'Searching the web',
+  find: 'Searching files',
+  analyze: 'Analyzing code',
+  inspect: 'Inspecting files',
+
+  // Agent first-class tools
+  personal_ops: 'Checking your inbox & calendar',
+  research: 'Researching',
+  agent_research_runs: 'Researching',
+  agent_research_sources: 'Reviewing sources',
+  agent_research_report: 'Writing a research report',
+  schedule: 'Checking schedules',
+  agent_schedule_edit: 'Updating a schedule',
+  agent_autonomy_schedule: 'Scheduling background work',
+  agent_reminder_schedule: 'Setting a reminder',
+  autonomy: 'Checking background work',
+  channels: 'Checking message channels',
+  agent_channel_send: 'Sending a message',
+  notify: 'Sending a notification',
+  memory: 'Recalling memory',
+  agent_knowledge: 'Searching knowledge',
+  agent_knowledge_ingest: 'Saving to knowledge',
+  agent_learning_consolidation: 'Consolidating what I learned',
+  agent_local_registry: 'Checking notes & routines',
+  models: 'Checking models',
+  agent_model_compare: 'Comparing models',
+  settings: 'Adjusting settings',
+  agent_settings_import: 'Importing settings',
+  setup: 'Checking setup',
+  security: 'Reviewing safety',
+  sessions: 'Looking at past conversations',
+  computer: 'Using the browser',
+  device: 'Checking this device',
+  host: 'Checking the assistant service',
+  execution: 'Managing background work',
+  terminal_process: 'Watching a process',
+  support: 'Preparing a support bundle',
+  vibe: 'Reading your VIBE profile',
+  workspace: 'Driving the workspace',
+  agent_harness: 'Checking app internals',
+  route: 'Choosing the best route',
+  delegation: 'Handing work off',
+  audit: 'Reviewing evidence',
+  context: 'Reading project context',
+  agent_documents: 'Working on a document',
+  agent_artifacts: 'Managing saved files',
+  agent_media_generate: 'Generating media',
+  agent_operator_method: 'Calling the assistant service',
+  agent_operator_briefing: 'Preparing a briefing',
+  agent_operator_action: 'Running an approved action',
+  agent_work_plan: 'Organizing work',
+  agent_review_packet_presets: 'Preparing a review packet',
+  agent_review_packet_share: 'Sharing a review packet',
+  propose_skill_drafts: 'Proposing skill drafts',
+};
+
+/**
+ * Exported catalog of all registered tool IDs and their human phrases.
+ * Tests import this to enumerate the full set of tool IDs for coverage checks.
+ */
+export const TOOL_LABELS_CATALOG: Readonly<Record<string, string>> = TOOL_LABELS;
+
+function humanize(name: string): string {
+  const short = name.includes('__') ? name.split('__').pop()! : name;
+  return (short
+    .replace(/^agent[_-]/, '')
+    .replace(/[_-]+/g, ' ')
+    .trim())
+    .replace(/^./, (c) => c.toUpperCase());
+}
+
+/**
+ * Return the human phrase for a tool call, falling back to a humanized
+ * version of the raw name for unknown tools (including MCP tools).
+ */
+export function friendlyToolLabel(toolName: string): string {
+  const short = toolName.includes('__') ? toolName.split('__').pop()! : toolName;
+  return TOOL_LABELS[short] ?? TOOL_LABELS[toolName] ?? humanize(toolName);
+}

package/src/renderer/ui-factory.ts

@@ -215,113 +215,65 @@ export class UIFactory {
     const bottomLine = createBaseLine();
     for (let x = 0; x < boxWidth; x++) bottomLine[boxStartX + x] = { char: GLYPHS.surface.bottom, fg: BORDER_COLOR, bg: '', bold: false, dim: false, underline: false, italic: false, strikethrough: false };
     lines.push(bottomLine);
-    lines.push(createBaseLine());
-    const composerTokens: Array<{ text: string; fg: string; bold?: boolean; dim?: boolean }> = [];
-    if (composerMode) composerTokens.push({ text: ` ${GLYPHS.status.active} ${composerMode} `, fg: '#38bdf8', bold: true });
-    if (composerPendingRisk && composerPendingRisk !== 'none') {
-      const riskColor = composerPendingRisk === 'approval-wait'
-        ? '#f59e0b'
-        : composerPendingRisk === 'shell'
-          ? '#ef4444'
-          : composerPendingRisk === 'remote'
-            ? '#a78bfa'
-            : '#f59e0b';
-      composerTokens.push({ text: ` risk:${composerPendingRisk} `, fg: riskColor, bold: true });
-    }
-    if (composerStatus && composerStatus !== 'idle') composerTokens.push({ text: ` state:${composerStatus} `, fg: '244', dim: true });
-    if (composerFlags && composerFlags.length > 0) composerTokens.push({ text: ` flags:${composerFlags.join(',')} `, fg: '244', dim: true });
-    if (composerTokens.length > 0) {
-      const postureLine = createBaseLine();
-      let px = 2;
-      for (const token of composerTokens) {
-        for (const ch of token.text) {
-          if (px >= width) break;
-          postureLine[px] = {
-            char: ch,
-            fg: token.fg,
-            bg: '',
-            bold: token.bold ?? false,
-            dim: token.dim ?? false,
-            underline: false,
-            italic: false,
-            strikethrough: false,
-          };
-          px += getDisplayWidth(ch);
-        }
-        if (px >= width) break;
-      }
-      lines.push(postureLine);
-      lines.push(createBaseLine());
-    }
+
+    // ── Status line: model · context meter · tokens, with alerts on the right ──
     const isRecentlyCopied = Date.now() - lastCopyTime < 2000;
-    // Token usage line
-    const u = usage as { input?: number; output?: number; cacheRead?: number; cacheWrite?: number; up?: number; down?: number };
+    const u = usage as { input?: number; output?: number; up?: number; down?: number };
     const inp = u.input ?? u.up ?? 0;
     const out = u.output ?? u.down ?? 0;
-    const cr = u.cacheRead ?? 0;
-    const cw = u.cacheWrite ?? 0;
-    const total = inp + out + cr + cw;
-    const tokenSep = ` ${GLYPHS.navigation.pipeSeparator} `;
-    const tokenLine = ` Token Usage [ Input: ${fmtNum(inp)}${tokenSep}Output: ${fmtNum(out)}${tokenSep}Cache Read: ${fmtNum(cr)}${tokenSep}Cache Write: ${fmtNum(cw)}${tokenSep}Total: ${fmtNum(total)} ]`;
-    const copiedNotice = isRecentlyCopied ? ` [COPIED] ` : '';
-    const statsLine = '  ' + tokenLine + ' '.repeat(Math.max(0, width - 4 - getDisplayWidth(tokenLine) - getDisplayWidth(copiedNotice))) + copiedNotice;
-    lines.push(this.stringToLine(statsLine, width, { fg: isRecentlyCopied ? '81' : '244', bold: isRecentlyCopied }));
-    // Context usage progress bar
+    const statusTokens: Array<{ text: string; fg: string; bold?: boolean }> = [];
+    if (model) {
+      statusTokens.push({ text: provider ? `${model} · ${provider}` : model, fg: '245' });
+    }
     if (contextWindow && contextWindow > 0) {
       const ctxTokens = lastInputTokens ?? 0;
-      const label = '   Context Usage: ';
-      const suffix = ` [ ${fmtNum(ctxTokens)} / ${fmtNum(contextWindow)} ]`;
-      const barWidth = Math.max(10, Math.min(30, width - getDisplayWidth(label) - getDisplayWidth(suffix) - 8));
-      const ctxPct = Math.min(1, ctxTokens / contextWindow);
-      lines.push(createBaseLine());
-      lines.push(this.createProgressBarLine(label, ctxPct, barWidth, width, suffix));
+      const pct = Math.min(100, Math.round((ctxTokens / contextWindow) * 100));
+      const filled = Math.round((pct / 100) * 6);
+      const meter = GLYPHS.meter.filled.repeat(filled) + GLYPHS.meter.empty.repeat(6 - filled);
+      const meterFg = pct >= 85 ? '#ef4444' : pct >= 65 ? '#f59e0b' : '240';
+      statusTokens.push({ text: `context ${meter} ${pct}%`, fg: meterFg, bold: pct >= 85 });
+    }
+    if (inp > 0 || out > 0) {
+      statusTokens.push({ text: `↑${fmtNum(inp)} ↓${fmtNum(out)}`, fg: '240' });
+    }
+    if (composerPendingRisk === 'approval-wait') {
+      statusTokens.push({ text: 'waiting for your approval', fg: '#f59e0b', bold: true });
     }
-    // Context info line (working dir, model+provider, tools)
-    if (workingDir || model) {
-      const home = typeof process !== 'undefined' ? process.env.HOME ?? '' : '';
-      const displayDir = workingDir && home && workingDir.startsWith(home)
-        ? '~' + workingDir.slice(home.length)
-        : workingDir ?? '';
-      const ctxParts: string[] = [];
-      if (displayDir) ctxParts.push(displayDir);
-      if (model) {
-        ctxParts.push(model + (provider ? ` (${provider})` : ''));
+    const rightNotice = isRecentlyCopied
+      ? { text: `copied ${GLYPHS.status.success} `, fg: '81', bold: true }
+      : dangerMode
+        ? { text: '⚠ auto-approve is on ', fg: '#ef4444', bold: true }
+        : null;
+    const statusLine = createBaseLine();
+    let sx = 3;
+    const writeStatusText = (text: string, fg: string, bold = false) => {
+      for (const ch of text) {
+        if (sx >= width - 1) break;
+        statusLine[sx] = { char: ch, fg, bg: '', bold, dim: false, underline: false, italic: false, strikethrough: false };
+        sx += getDisplayWidth(ch);
+      }
+    };
+    statusTokens.forEach((token, index) => {
+      if (index > 0) writeStatusText(`  ${GLYPHS.navigation.pipeSeparator}  `, '238');
+      writeStatusText(token.text, token.fg, token.bold ?? false);
+    });
+    if (rightNotice) {
+      let col = Math.max(sx + 2, width - getDisplayWidth(rightNotice.text));
+      for (const ch of rightNotice.text) {
+        if (col >= width) break;
+        statusLine[col] = { char: ch, fg: rightNotice.fg, bg: '', bold: rightNotice.bold ?? false, dim: false, underline: false, italic: false, strikethrough: false };
+        col += getDisplayWidth(ch);
       }
-      if (toolCount) ctxParts.push(`${toolCount} tools`);
-      if (hitlMode) ctxParts.push(`hitl:${hitlMode}`);
-      if (composerMode) ctxParts.push(`mode:${composerMode}`);
-      if (composerStatus && composerStatus !== 'idle') ctxParts.push(`status:${composerStatus}`);
-      if (composerFlags && composerFlags.length > 0) ctxParts.push(composerFlags.join(','));
-      const ctxLine = '   ' + ctxParts.join(`  ${GLYPHS.navigation.pipeSeparator}  `);
-      lines.push(createBaseLine());
-      lines.push(this.stringToLine(truncateDisplay(ctxLine, width), width, { fg: '240', dim: true }));
-      lines.push(createBaseLine());
     }
+    lines.push(statusLine);
+
+    // ── Hints line ──
     if (showExitNotice) {
-      const notice = `   !!! Press Ctrl+C again to exit !!! `;
-      lines.push(this.stringToLine(fitDisplay(notice, width), width, { fg: '196', bold: true }));
+      lines.push(this.stringToLine(fitDisplay('   Press Ctrl+C again to exit ', width), width, { fg: '196', bold: true }));
     } else {
-      const help = `   /help for commands  -  Ctrl+C to quit `;
-      const dangerWarn = dangerMode ? `! DANGER MODE - ALL CHANGES AUTO-APPROVED ` : '';
-      const helpW = getDisplayWidth(help);
-      const dangerW = getDisplayWidth(dangerWarn);
-      const spacerW = Math.max(0, width - helpW - dangerW);
-      const combinedLine = help + ' '.repeat(spacerW) + dangerWarn;
-      const line = this.stringToLine(truncateDisplay(combinedLine, width), width, { fg: '240', dim: true });
-      // Overlay the danger warning in red bold
-      if (dangerMode && dangerW > 0) {
-        let col = helpW + spacerW;
-        for (const ch of dangerWarn) {
-          if (col >= width) break;
-          const cw = getDisplayWidth(ch);
-          line[col] = { char: ch, fg: '#ef4444', bg: '', bold: true, dim: false, underline: false, italic: false, strikethrough: false };
-          if (cw === 2 && col + 1 < width) line[col + 1] = { ...line[col], char: '' };
-          col += cw;
-        }
-      }
-      lines.push(line);
+      const hints = `   /help commands  ${GLYPHS.navigation.pipeSeparator}  Ctrl+P settings  ${GLYPHS.navigation.pipeSeparator}  Ctrl+O activity `;
+      lines.push(this.stringToLine(truncateDisplay(hints, width), width, { fg: '240', dim: true }));
     }
-    lines.push(createBaseLine());
     return lines;
   }