@pellux/goodvibes-agent 1.0.39 → 1.0.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/main.ts

@@ -41,6 +41,7 @@ import {
 import type { SessionSnapshot } from '@/runtime/index.ts';
 import { handleBlockingShellInput, type PendingPermissionState } from './shell/blocking-input.ts';
 import { createOnboardingFullscreenComposite } from './shell/onboarding-fullscreen.ts';
+import { getTerminalSize } from './shell/terminal-size.ts';
 import { wireShellUiOpeners } from './shell/ui-openers.ts';
 import { deriveComposerState } from './core/composer-state.ts';
 import { buildPersistedSessionContext, formatReturnContextForDisplay, getReturnContextMode, maybeAssistReturnContextSummary } from '@/runtime/index.ts';
@@ -115,7 +116,7 @@ async function main() {
     sessionLineageTracker: ctx.services.sessionLineageTracker,
     idempotencyStore: ctx.services.idempotencyStore,
   });
-  let activeConversationWidth = stdout.columns || 80;
+  let activeConversationWidth = getTerminalSize(stdout).width;
   conversation.setWidthProvider(() => activeConversationWidth);
   {
     const hitlMode = configManager.get('behavior.hitlMode') as HITLMode | undefined;
@@ -166,17 +167,18 @@ async function main() {
   let scrollLocked = true;
 
   const getPromptContentWidth = () => {
-    const w = stdout.columns || 80;
+    const w = getTerminalSize(stdout).width;
     const boxMargin = 2;
     const boxWidth = w - (boxMargin * 2);
     return boxWidth - 4 - 3; // minus padding (4) minus prefix width (3: ' > ')
   };
 
   const getViewportHeight = (): number => {
-    if (input.onboardingWizard.active) return stdout.rows || 24;
+    const { height } = getTerminalSize(stdout);
+    if (input.onboardingWizard.active) return height;
     const promptLines: number = input.getVisiblePromptLineCount(getPromptContentWidth());
     const currentModel = providerRegistry.getCurrentModel();
-    return (stdout.rows || 24) - 2 - estimateShellFooterHeight(promptLines, currentModel.contextWindow);
+    return height - 2 - estimateShellFooterHeight(promptLines, currentModel.contextWindow);
   };
 
   const scroll = (delta: number) => {
@@ -469,8 +471,7 @@ async function main() {
   };
 
   const render = () => {
-    const width = stdout.columns || 80;
-    const height = stdout.rows || 24;
+    const { width, height } = getTerminalSize(stdout);
 
     if (input.onboardingWizard.active) {
       input.setPanelMouseLayout(null);

package/src/renderer/compositor.ts

@@ -44,6 +44,7 @@ export interface CompositeRequest {
   header: Line[];
   viewport: Line[];
   footer: Line[];
+  forceFullRedraw?: boolean;
   selection?: SelectionInfo;
   search?: SearchInfo;
   panel?: PanelCompositeData;
@@ -74,12 +75,15 @@ export class Compositor {
   }
 
   public composite(params: CompositeRequest): void {
-    const { width, height, header, viewport, footer, selection, search, panel, panelWidth } = params;
+    const { width, height, header, viewport, footer, forceFullRedraw, selection, search, panel, panelWidth } = params;
+    const previousFrontBuffer = forceFullRedraw ? null : this.frontBuffer;
+    if (forceFullRedraw) this.diffEngine.reset();
+
     // R3: Reuse back-buffer instead of allocating each frame
     if (!this.backBuffer) {
       this.backBuffer = new TerminalBuffer(width, height);
     } else {
-      this.backBuffer.reset(width, height, this.frontBuffer);
+      this.backBuffer.reset(width, height, previousFrontBuffer);
     }
     const newBuffer = this.backBuffer;
 
@@ -275,7 +279,7 @@ export class Compositor {
 
     // 4. Diff and Render
     // R3: Diff against front-buffer (last-rendered), then swap front/back — no clone() needed
-    const diff = this.diffEngine.diff(this.frontBuffer, newBuffer);
+    const diff = this.diffEngine.diff(previousFrontBuffer, newBuffer);
     if (diff) {
       allowTerminalWrite(() => this.stdout.write(diff));
     }

package/src/renderer/onboarding/onboarding-wizard.ts

@@ -6,7 +6,7 @@ import {
   stableWindow,
   WORKSPACE_PALETTE as PALETTE,
   type WorkspaceRow,
-} from '../fullscreen-workspace.ts';
+} from './onboarding-workspace.ts';
 import { GLYPHS } from '../ui-primitives.ts';
 import {
   type OnboardingWizardController,

package/src/renderer/onboarding/onboarding-workspace.ts

@@ -0,0 +1,199 @@
+import type { Line } from '../../types/grid.ts';
+import { GLYPHS } from '../ui-primitives.ts';
+import {
+  borderLine,
+  clamp,
+  contentLine,
+  drawHorizontalRule,
+  drawVerticalRule,
+  fillRange,
+  FULLSCREEN_PALETTE,
+  makeLine,
+  writeText,
+} from '../fullscreen-primitives.ts';
+
+export {
+  borderLine,
+  clamp,
+  contentLine,
+  fillRange,
+  makeLine,
+  padDisplay,
+  stableWindow,
+  writeText,
+} from '../fullscreen-primitives.ts';
+export { FULLSCREEN_PALETTE as WORKSPACE_PALETTE } from '../fullscreen-primitives.ts';
+
+const WORKSPACE_PALETTE = FULLSCREEN_PALETTE;
+
+export interface WorkspaceRow {
+  readonly text: string;
+  readonly selected?: boolean;
+  readonly bold?: boolean;
+  readonly dim?: boolean;
+  readonly fg?: string;
+  readonly bg?: string;
+  readonly kind?: 'group' | 'item' | 'more' | 'empty';
+}
+
+export interface FullscreenWorkspaceRenderOptions {
+  readonly width: number;
+  readonly height: number;
+  readonly title: string;
+  readonly stateLabel?: string;
+  readonly leftHeader: string;
+  readonly mainHeader: string;
+  readonly leftRows: readonly WorkspaceRow[];
+  readonly contextRows: readonly WorkspaceRow[];
+  readonly controlRows: readonly WorkspaceRow[];
+  readonly footer: string;
+  readonly leftWidth?: number;
+  readonly contextRatio?: number;
+  readonly minContextRows?: number;
+}
+
+export interface FullscreenWorkspaceMetrics {
+  readonly safeWidth: number;
+  readonly safeHeight: number;
+  readonly leftWidth: number;
+  readonly centerWidth: number;
+  readonly bodyRows: number;
+  readonly contextWidth: number;
+  readonly contextRows: number;
+  readonly controlRows: number;
+}
+
+export function drawVertical(line: Line, x: number, bg = ''): void {
+  if (x <= 0 || x >= line.length - 1) return;
+  drawVerticalRule(line, x, WORKSPACE_PALETTE.border, bg);
+}
+
+export function drawHorizontalRange(line: Line, startX: number, endX: number, bg = ''): void {
+  drawHorizontalRule(line, Math.max(1, startX), Math.min(line.length - 2, endX), WORKSPACE_PALETTE.border, bg);
+}
+
+function leftWidthFor(width: number, explicit?: number): number {
+  if (explicit !== undefined) return clamp(explicit, 14, Math.max(14, width - 24));
+  return width < 80
+    ? clamp(Math.round(width * 0.32), 14, Math.max(14, width - 24))
+    : clamp(Math.round(width * 0.22), 24, 34);
+}
+
+export function getFullscreenWorkspaceMetrics(options: Pick<
+  FullscreenWorkspaceRenderOptions,
+  'width' | 'height' | 'leftWidth' | 'contextRatio' | 'minContextRows'
+>): FullscreenWorkspaceMetrics {
+  const safeWidth = Math.max(1, options.width);
+  const safeHeight = Math.max(12, options.height);
+  const leftWidth = leftWidthFor(safeWidth, options.leftWidth);
+  const centerWidth = Math.max(20, safeWidth - leftWidth - 3);
+  const bodyTop = 3;
+  const footerY = safeHeight - 2;
+  const bodyRows = Math.max(4, footerY - bodyTop);
+  const contextWidth = Math.max(10, centerWidth - 2);
+  const maxContextRows = Math.max(3, bodyRows - 4);
+  const minContextRows = clamp(options.minContextRows ?? 10, 3, maxContextRows);
+  const contextRows = clamp(
+    Math.round(bodyRows * (options.contextRatio ?? 0.4)),
+    Math.min(minContextRows, maxContextRows),
+    maxContextRows,
+  );
+  const controlRows = Math.max(3, bodyRows - contextRows - 1);
+  return { safeWidth, safeHeight, leftWidth, centerWidth, bodyRows, contextWidth, contextRows, controlRows };
+}
+
+function rowFg(row: WorkspaceRow, fallback: string): string {
+  if (row.fg) return row.fg;
+  if (row.kind === 'group') return WORKSPACE_PALETTE.subtitle;
+  if (row.kind === 'more') return WORKSPACE_PALETTE.dim;
+  return fallback;
+}
+
+export function renderFullscreenWorkspace(options: FullscreenWorkspaceRenderOptions): Line[] {
+  const { safeWidth, safeHeight, leftWidth, centerWidth, bodyRows, contextWidth, contextRows } = getFullscreenWorkspaceMetrics(options);
+  const leftStart = 1;
+  const dividerX = leftWidth + 1;
+  const centerStart = dividerX + 1;
+  const centerEnd = safeWidth - 2;
+  const bodyTop = 3;
+  const separatorY = bodyTop + contextRows;
+  const lines: Line[] = [];
+
+  const top = borderLine(safeWidth, GLYPHS.frame.topLeft, GLYPHS.frame.horizontal, GLYPHS.frame.topRight);
+  writeText(top, 2, safeWidth - 4, ` ${options.title} `, { fg: WORKSPACE_PALETTE.title, bold: true });
+  if (options.stateLabel) {
+    writeText(top, Math.max(2, safeWidth - options.stateLabel.length - 4), options.stateLabel.length, options.stateLabel, {
+      fg: WORKSPACE_PALETTE.subtitle,
+    });
+  }
+  lines.push(top);
+
+  const header = contentLine(safeWidth, WORKSPACE_PALETTE.footerBg);
+  drawVertical(header, dividerX, WORKSPACE_PALETTE.footerBg);
+  writeText(header, leftStart + 1, leftWidth - 2, options.leftHeader, {
+    fg: WORKSPACE_PALETTE.subtitle,
+    bold: true,
+    bg: WORKSPACE_PALETTE.footerBg,
+  });
+  writeText(header, centerStart + 1, centerWidth - 2, options.mainHeader, {
+    fg: WORKSPACE_PALETTE.subtitle,
+    bold: true,
+    bg: WORKSPACE_PALETTE.footerBg,
+  });
+  lines.push(header);
+
+  const headerSep = contentLine(safeWidth, '');
+  drawVertical(headerSep, dividerX);
+  drawHorizontalRange(headerSep, 1, safeWidth - 2);
+  lines.push(headerSep);
+
+  for (let row = 0; row < bodyRows; row += 1) {
+    const y = bodyTop + row;
+    const inContext = y < separatorY;
+    const inSeparator = y === separatorY;
+    const bg = inSeparator ? '' : inContext ? WORKSPACE_PALETTE.contextBg : WORKSPACE_PALETTE.controlsBg;
+    const line = contentLine(safeWidth, bg);
+    fillRange(line, 1, dividerX - 1, WORKSPACE_PALETTE.categoryBg);
+    drawVertical(line, dividerX, bg);
+
+    const leftRow = options.leftRows[row] ?? { text: '', kind: 'empty' as const };
+    if (leftRow.selected) fillRange(line, leftStart, dividerX - 1, WORKSPACE_PALETTE.selectedBg);
+    writeText(line, leftStart + 1, leftWidth - 3, leftRow.text, {
+      fg: leftRow.selected ? WORKSPACE_PALETTE.text : rowFg(leftRow, WORKSPACE_PALETTE.muted),
+      bg: leftRow.selected ? WORKSPACE_PALETTE.selectedBg : WORKSPACE_PALETTE.categoryBg,
+      bold: leftRow.bold ?? (leftRow.selected || leftRow.kind === 'group'),
+      dim: leftRow.dim,
+    });
+
+    if (inSeparator) {
+      drawHorizontalRange(line, centerStart, centerEnd);
+    } else if (inContext) {
+      const contextRow = options.contextRows[row] ?? { text: '', kind: 'empty' as const };
+      writeText(line, centerStart + 1, contextWidth, contextRow.text, {
+        fg: rowFg(contextRow, WORKSPACE_PALETTE.text),
+        bg,
+        bold: contextRow.bold,
+        dim: contextRow.dim ?? contextRow.text.length === 0,
+      });
+    } else {
+      const controlRow = options.controlRows[row - contextRows - 1] ?? { text: '', kind: 'empty' as const };
+      if (controlRow.selected) fillRange(line, centerStart, centerEnd, WORKSPACE_PALETTE.selectedBg);
+      writeText(line, centerStart + 1, contextWidth, controlRow.text, {
+        fg: controlRow.selected ? WORKSPACE_PALETTE.text : rowFg(controlRow, WORKSPACE_PALETTE.text),
+        bg: controlRow.selected ? WORKSPACE_PALETTE.selectedBg : bg,
+        bold: controlRow.bold ?? controlRow.selected,
+        dim: controlRow.dim ?? controlRow.text.length === 0,
+      });
+    }
+
+    lines.push(line);
+  }
+
+  const footer = contentLine(safeWidth, WORKSPACE_PALETTE.footerBg);
+  writeText(footer, 2, safeWidth - 4, options.footer, { fg: WORKSPACE_PALETTE.muted, bg: WORKSPACE_PALETTE.footerBg });
+  lines.push(footer);
+  lines.push(borderLine(safeWidth, GLYPHS.frame.bottomLeft, GLYPHS.frame.horizontal, GLYPHS.frame.bottomRight));
+
+  while (lines.length < safeHeight) lines.unshift(makeLine(safeWidth));
+  return lines.slice(-safeHeight);
+}

package/src/runtime/bootstrap-core.ts

@@ -38,6 +38,7 @@ import { registerAgentNotifyTool } from '../tools/agent-notify-tool.ts';
 import { registerAgentOperatorActionTool } from '../tools/agent-operator-action-tool.ts';
 import { registerAgentOperatorBriefingTool } from '../tools/agent-operator-briefing-tool.ts';
 import { registerAgentReminderScheduleTool } from '../tools/agent-reminder-schedule-tool.ts';
+import { getTerminalSize } from '../shell/terminal-size.ts';
 import { registerAgentWorkPlanTool } from '../tools/agent-work-plan-tool.ts';
 import { compactRegisteredToolDefinitions } from '../tools/tool-definition-compaction.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
@@ -200,7 +201,7 @@ export async function initializeBootstrapCore(
   });
 
   const conversation = new ConversationManager(() => {
-    const width = stdout.columns || 80;
+    const width = getTerminalSize(stdout).width;
     if (panelManager.isVisible() && panelManager.getAllOpen().length > 0) {
       return Math.max(1, panelManager.getLeftWidth(width) - 1);
     }

package/src/shell/onboarding-fullscreen.ts

@@ -35,6 +35,7 @@ export function createOnboardingFullscreenComposite(
     header: [],
     viewport,
     footer: [],
+    forceFullRedraw: true,
     panelWidth: 0,
   };
 }

package/src/shell/terminal-size.ts

@@ -0,0 +1,37 @@
+export interface TerminalSize {
+  readonly width: number;
+  readonly height: number;
+}
+
+type TerminalSizeSource = Pick<NodeJS.WriteStream, 'columns' | 'rows'> & {
+  readonly getWindowSize?: () => readonly [number, number] | readonly [number, number, number, number];
+};
+
+function positiveInteger(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value) && value > 0) return Math.floor(value);
+  if (typeof value === 'string' && value.trim().length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+  }
+  return undefined;
+}
+
+export function getTerminalSize(stdout: TerminalSizeSource): TerminalSize {
+  let windowWidth: number | undefined;
+  let windowHeight: number | undefined;
+  try {
+    const size = stdout.getWindowSize?.();
+    if (Array.isArray(size)) {
+      windowWidth = positiveInteger(size[0]);
+      windowHeight = positiveInteger(size[1]);
+    }
+  } catch {
+    windowWidth = undefined;
+    windowHeight = undefined;
+  }
+
+  return {
+    width: positiveInteger(stdout.columns) ?? windowWidth ?? positiveInteger(process.env.COLUMNS) ?? 80,
+    height: positiveInteger(stdout.rows) ?? windowHeight ?? positiveInteger(process.env.LINES) ?? 24,
+  };
+}

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '1.0.39';
+let _version = '1.0.41';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {
     readonly version?: unknown;