claudedesk 4.3.1 → 4.4.0

package/src/shared/ipc-contract.ts

@@ -33,6 +33,8 @@ import type {
   TeammateDetectedEvent,
   TasksUpdatedEvent,
   TeamRemovedEvent,
+  ClaudeModel,
+  ModelSwitchEvent,
 } from './ipc-types';
 
 import type {
@@ -64,6 +66,23 @@ import type {
   AtlasScanProgress,
 } from './types/atlas-types';
 
+import type {
+  LayoutPreset,
+} from '../types/layout-presets';
+
+import type { LayoutNode } from './ipc-types';
+
+import type {
+  GitStatus,
+  GitBranchInfo,
+  GitCommitInfo,
+  GitDiffResult,
+  GitOperationResult,
+  GitCommitRequest,
+  GeneratedCommitMessage,
+  GitRemoteProgress,
+} from './types/git-types';
+
 // ─── Contract helper types ──────────────────────────────────────────
 
 /** renderer → main, expects a return value (ipcRenderer.invoke / ipcMain.handle) */
@@ -107,6 +126,13 @@ export interface IPCContractMap {
   resizeSession:       SendContract<'session:resize', [SessionResizeRequest]>;
   sessionReady:        SendContract<'session:ready',  [string]>;
 
+  // ── Model switching (invoke) ──
+  switchModel:         InvokeContract<'model:switch', [string, ClaudeModel], boolean>;
+
+  // ── Model History (invoke) ──
+  getModelHistory:     InvokeContract<'model:getHistory',   [string], import('../main/model-history-manager').ModelSwitchHistoryEntry[]>;
+  clearModelHistory:   InvokeContract<'model:clearHistory', [string], boolean>;
+
   // ── Window controls (send) ──
   minimizeWindow:      SendContract<'window:minimize', []>;
   maximizeWindow:      SendContract<'window:maximize', []>;
@@ -119,6 +145,7 @@ export interface IPCContractMap {
   onSessionUpdated:    EventContract<'session:updated',  SessionMetadata>;
   onSessionOutput:     EventContract<'session:output',   SessionOutput>;
   onSessionExited:     EventContract<'session:exited',   SessionExitEvent>;
+  onModelChanged:      EventContract<'model:changed',    ModelSwitchEvent>;
 
   // ── Dialogs & File system (invoke) ──
   browseDirectory:     InvokeContract<'dialog:browseDirectory', [],                              string | null>;
@@ -192,6 +219,8 @@ export interface IPCContractMap {
   unlinkSessionFromTeam: InvokeContract<'teams:unlinkSession', [string],                          boolean>;
   closeTeam:           InvokeContract<'teams:close',          [string],                           boolean>;
   updateAutoLayoutTeams: InvokeContract<'settings:updateAutoLayout', [boolean],                   boolean>;
+  updateUIMode:          InvokeContract<'settings:updateUIMode',     ['beginner' | 'expert'],     boolean>;
+  updateDefaultModel:    InvokeContract<'settings:updateDefaultModel', [ClaudeModel],              boolean>;
 
   // ── Agent Teams events (main→renderer) ──
   onTeamDetected:      EventContract<'teams:detected',        TeamInfo>;
@@ -206,9 +235,47 @@ export interface IPCContractMap {
   getAtlasSettings:    InvokeContract<'atlas:getSettings',    [],                                 AtlasSettings>;
   updateAtlasSettings: InvokeContract<'atlas:updateSettings', [Partial<AtlasSettings>],           AtlasSettings>;
 
+  // ── Command Registry (invoke) ──
+  searchCommands:      InvokeContract<'commands:search',      [string, number?],                  import('./types/command-types').CommandSearchResult[]>;
+  getAllCommands:      InvokeContract<'commands:getAll',      [],                                 import('./types/command-types').CommandRegistryData>;
+  executeCommand:      InvokeContract<'commands:execute',     [string, any[]?],                   boolean>;
+
   // ── Repository Atlas events (main→renderer) ──
   onAtlasScanProgress: EventContract<'atlas:scanProgress', AtlasScanProgress>;
 
+  // ── Layout Presets (invoke) ──
+  getLayoutPresets:    InvokeContract<'layout:getPresets',    [],                                 LayoutPreset[]>;
+  applyLayoutPreset:   InvokeContract<'layout:apply',         [string],                           boolean>;
+  applyCustomLayout:   InvokeContract<'layout:applyCustom',   [number, number],                   boolean>;
+  getCurrentLayout:    InvokeContract<'layout:getCurrent',    [],                                 LayoutNode>;
+
+  // ── Git Integration (invoke) ──
+  getGitStatus:        InvokeContract<'git:status',          [string],                              GitStatus>;
+  getGitBranches:      InvokeContract<'git:branches',        [string],                              GitBranchInfo[]>;
+  gitStageFiles:       InvokeContract<'git:stage',           [string, string[]],                    GitOperationResult>;
+  gitUnstageFiles:     InvokeContract<'git:unstage',         [string, string[]],                    GitOperationResult>;
+  gitStageAll:         InvokeContract<'git:stageAll',        [string],                              GitOperationResult>;
+  gitUnstageAll:       InvokeContract<'git:unstageAll',      [string],                              GitOperationResult>;
+  gitCommit:           InvokeContract<'git:commit',          [GitCommitRequest],                    GitOperationResult>;
+  gitGenerateMessage:  InvokeContract<'git:generateMessage', [string],                              GeneratedCommitMessage>;
+  gitPush:             InvokeContract<'git:push',            [string, boolean?],                    GitOperationResult>;
+  gitPull:             InvokeContract<'git:pull',            [string],                              GitOperationResult>;
+  gitFetch:            InvokeContract<'git:fetch',           [string],                              GitOperationResult>;
+  gitSwitchBranch:     InvokeContract<'git:switchBranch',    [string, string],                      GitOperationResult>;
+  gitCreateBranch:     InvokeContract<'git:createBranch',    [string, string],                      GitOperationResult>;
+  gitLog:              InvokeContract<'git:log',             [string, number?],                     GitCommitInfo[]>;
+  gitDiff:             InvokeContract<'git:diff',            [string, string, boolean],             GitDiffResult>;
+  gitCommitDiff:       InvokeContract<'git:commitDiff',      [string, string],                      GitCommitInfo>;
+  gitDiscardFile:      InvokeContract<'git:discardFile',     [string, string],                      GitOperationResult>;
+  gitDiscardAll:       InvokeContract<'git:discardAll',      [string],                              GitOperationResult>;
+  gitInit:             InvokeContract<'git:init',            [string],                              GitOperationResult>;
+  gitStartWatching:    InvokeContract<'git:startWatching',   [string],                              boolean>;
+  gitStopWatching:     InvokeContract<'git:stopWatching',    [string],                              boolean>;
+
+  // ── Git events (main→renderer) ──
+  onGitStatusChanged:  EventContract<'git:statusChanged',    GitStatus>;
+  onGitRemoteProgress: EventContract<'git:remoteProgress',   GitRemoteProgress>;
+
   // ── App info (invoke) ──
   getVersionInfo:      InvokeContract<'app:getVersionInfo', [],                                  AppVersionInfo>;
 }
@@ -233,6 +300,13 @@ export const channels: { [K in keyof IPCContractMap]: ChannelOf<K> } = {
   resizeSession:       'session:resize',
   sessionReady:        'session:ready',
 
+  // Model switching
+  switchModel:         'model:switch',
+
+  // Model History
+  getModelHistory:     'model:getHistory',
+  clearModelHistory:   'model:clearHistory',
+
   // Window controls
   minimizeWindow:      'window:minimize',
   maximizeWindow:      'window:maximize',
@@ -245,6 +319,7 @@ export const channels: { [K in keyof IPCContractMap]: ChannelOf<K> } = {
   onSessionUpdated:    'session:updated',
   onSessionOutput:     'session:output',
   onSessionExited:     'session:exited',
+  onModelChanged:      'model:changed',
 
   // Dialogs
   browseDirectory:     'dialog:browseDirectory',
@@ -318,6 +393,8 @@ export const channels: { [K in keyof IPCContractMap]: ChannelOf<K> } = {
   unlinkSessionFromTeam: 'teams:unlinkSession',
   closeTeam:           'teams:close',
   updateAutoLayoutTeams: 'settings:updateAutoLayout',
+  updateUIMode:          'settings:updateUIMode',
+  updateDefaultModel:    'settings:updateDefaultModel',
 
   // Agent Teams events
   onTeamDetected:      'teams:detected',
@@ -332,9 +409,47 @@ export const channels: { [K in keyof IPCContractMap]: ChannelOf<K> } = {
   getAtlasSettings:    'atlas:getSettings',
   updateAtlasSettings: 'atlas:updateSettings',
 
+  // Command Registry
+  searchCommands:      'commands:search',
+  getAllCommands:      'commands:getAll',
+  executeCommand:      'commands:execute',
+
   // Repository Atlas events
   onAtlasScanProgress: 'atlas:scanProgress',
 
+  // Layout Presets
+  getLayoutPresets:    'layout:getPresets',
+  applyLayoutPreset:   'layout:apply',
+  applyCustomLayout:   'layout:applyCustom',
+  getCurrentLayout:    'layout:getCurrent',
+
+  // Git Integration
+  getGitStatus:        'git:status',
+  getGitBranches:      'git:branches',
+  gitStageFiles:       'git:stage',
+  gitUnstageFiles:     'git:unstage',
+  gitStageAll:         'git:stageAll',
+  gitUnstageAll:       'git:unstageAll',
+  gitCommit:           'git:commit',
+  gitGenerateMessage:  'git:generateMessage',
+  gitPush:             'git:push',
+  gitPull:             'git:pull',
+  gitFetch:            'git:fetch',
+  gitSwitchBranch:     'git:switchBranch',
+  gitCreateBranch:     'git:createBranch',
+  gitLog:              'git:log',
+  gitDiff:             'git:diff',
+  gitCommitDiff:       'git:commitDiff',
+  gitDiscardFile:      'git:discardFile',
+  gitDiscardAll:       'git:discardAll',
+  gitInit:             'git:init',
+  gitStartWatching:    'git:startWatching',
+  gitStopWatching:     'git:stopWatching',
+
+  // Git events
+  onGitStatusChanged:  'git:statusChanged',
+  onGitRemoteProgress: 'git:remoteProgress',
+
   // App info
   getVersionInfo:      'app:getVersionInfo',
 };
@@ -357,6 +472,11 @@ export const contractKinds: { [K in keyof IPCContractMap]: KindOf<K> } = {
   resizeSession:       'send',
   sessionReady:        'send',
 
+  switchModel:         'invoke',
+
+  getModelHistory:     'invoke',
+  clearModelHistory:   'invoke',
+
   minimizeWindow:      'send',
   maximizeWindow:      'send',
   closeWindow:         'send',
@@ -367,6 +487,7 @@ export const contractKinds: { [K in keyof IPCContractMap]: KindOf<K> } = {
   onSessionUpdated:    'event',
   onSessionOutput:     'event',
   onSessionExited:     'event',
+  onModelChanged:      'event',
 
   browseDirectory:     'invoke',
   showSaveDialog:      'invoke',
@@ -397,6 +518,10 @@ export const contractKinds: { [K in keyof IPCContractMap]: KindOf<K> } = {
   updateTemplate:      'invoke',
   deleteTemplate:      'invoke',
 
+  searchCommands:      'invoke',
+  getAllCommands:      'invoke',
+  executeCommand:      'invoke',
+
   getFileInfo:         'invoke',
   readFileContent:     'invoke',
 
@@ -429,6 +554,8 @@ export const contractKinds: { [K in keyof IPCContractMap]: KindOf<K> } = {
   unlinkSessionFromTeam: 'invoke',
   closeTeam:           'invoke',
   updateAutoLayoutTeams: 'invoke',
+  updateUIMode:          'invoke',
+  updateDefaultModel:    'invoke',
 
   onTeamDetected:      'event',
   onTeammateAdded:     'event',
@@ -443,6 +570,36 @@ export const contractKinds: { [K in keyof IPCContractMap]: KindOf<K> } = {
 
   onAtlasScanProgress: 'event',
 
+  getLayoutPresets:    'invoke',
+  applyLayoutPreset:   'invoke',
+  applyCustomLayout:   'invoke',
+  getCurrentLayout:    'invoke',
+
+  // Git Integration
+  getGitStatus:        'invoke',
+  getGitBranches:      'invoke',
+  gitStageFiles:       'invoke',
+  gitUnstageFiles:     'invoke',
+  gitStageAll:         'invoke',
+  gitUnstageAll:       'invoke',
+  gitCommit:           'invoke',
+  gitGenerateMessage:  'invoke',
+  gitPush:             'invoke',
+  gitPull:             'invoke',
+  gitFetch:            'invoke',
+  gitSwitchBranch:     'invoke',
+  gitCreateBranch:     'invoke',
+  gitLog:              'invoke',
+  gitDiff:             'invoke',
+  gitCommitDiff:       'invoke',
+  gitDiscardFile:      'invoke',
+  gitDiscardAll:       'invoke',
+  gitInit:             'invoke',
+  gitStartWatching:    'invoke',
+  gitStopWatching:     'invoke',
+  onGitStatusChanged:  'event',
+  onGitRemoteProgress: 'event',
+
   getVersionInfo:      'invoke',
 };
 

package/src/shared/ipc-types.ts

@@ -4,11 +4,18 @@ export type PermissionMode = 'standard' | 'skip-permissions';
 // Session status
 export type SessionStatus = 'starting' | 'running' | 'exited' | 'error';
 
+// Claude model types
+export type ClaudeModel = 'sonnet' | 'opus' | 'haiku' | 'auto';
+
+// Model preset types
+export type ModelPreset = 'cheap' | 'balanced' | 'power';
+
 // Session creation request
 export interface SessionCreateRequest {
   name?: string;
   workingDirectory: string;
   permissionMode: PermissionMode;
+  model?: ClaudeModel; // Starting model override (defaults to AppSettings.defaultModel)
 }
 
 // Session metadata
@@ -24,6 +31,7 @@ export interface SessionMetadata {
   agentId?: string;
   agentType?: 'lead' | 'teammate';
   isTeammate?: boolean;
+  currentModel?: ClaudeModel | null; // null = not yet detected
 }
 
 // Session list response
@@ -57,6 +65,14 @@ export interface SessionExitEvent {
   exitCode: number;
 }
 
+// Model switch event
+export interface ModelSwitchEvent {
+  sessionId: string;
+  model: ClaudeModel;
+  previousModel: ClaudeModel | null;
+  detectedAt: number;
+}
+
 // Persisted session state
 export interface PersistedSessionState {
   version: 1;
@@ -124,7 +140,15 @@ export interface LayoutBranch {
   children: [LayoutNode, LayoutNode];
 }
 
-export type LayoutNode = LayoutLeaf | LayoutBranch;
+export interface LayoutGrid {
+  type: 'grid';
+  id: string;
+  direction: 'horizontal' | 'vertical'; // row or column
+  children: LayoutNode[];
+  sizes: number[]; // percentage for each child (must sum to 100)
+}
+
+export type LayoutNode = LayoutLeaf | LayoutBranch | LayoutGrid;
 
 export interface SplitViewState {
   layout: LayoutNode;
@@ -147,6 +171,15 @@ export interface AppSettings {
   sessionPoolSettings?: SessionPoolSettings;
   autoLayoutTeams?: boolean;
   atlasSettings?: import('./types/atlas-types').AtlasSettings;
+  hasLaunchedBefore?: boolean; // Track first launch for Layout Picker
+  lastUsedLayoutPresetId?: string; // Track which preset was last applied
+  wizardCompleted?: boolean; // Track if welcome wizard has been completed
+  tooltipCoachDismissed?: Record<string, boolean>; // Track dismissed tooltip coach hints
+  panelHelpDismissed?: Record<string, boolean>; // Track dismissed panel help overlays
+  uiMode?: 'beginner' | 'expert'; // UI complexity mode (default: beginner)
+  defaultModel?: ClaudeModel; // Default model for new sessions (default: 'sonnet')
+  modelPreset?: ModelPreset; // Model preset mode (default: 'balanced')
+  gitSettings?: import('./types/git-types').GitSettings;
 }
 
 // Workspace create request
@@ -323,3 +356,21 @@ export type {
   AtlasOutputLocation,
 } from './types/atlas-types';
 
+export type {
+  GitFileStatus,
+  GitFileArea,
+  GitFileEntry,
+  GitBranchInfo,
+  GitStatus,
+  GitCommitInfo,
+  GitDiffResult,
+  CommitType,
+  CommitConfidence,
+  GeneratedCommitMessage,
+  GitOperationResult,
+  GitErrorCode,
+  GitCommitRequest,
+  GitRemoteProgress,
+  GitSettings,
+} from './types/git-types';
+

package/src/shared/message-parser.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { parseMessages, resetParser } from './message-parser';
+
+describe('parseMessages', () => {
+  beforeEach(() => {
+    resetParser();
+  });
+
+  it('parses "@agent> message" format', () => {
+    const result = parseMessages('@frontend> Starting the build', 'sess-1');
+    expect(result).toHaveLength(1);
+    expect(result[0].sender).toBe('frontend');
+    expect(result[0].content).toBe('Starting the build');
+    expect(result[0].sessionId).toBe('sess-1');
+  });
+
+  it('parses "@agent → @target: message" format', () => {
+    const result = parseMessages('@lead → @worker: Do the task', 'sess-1');
+    expect(result).toHaveLength(1);
+    expect(result[0].sender).toBe('lead');
+    expect(result[0].receiver).toBe('worker');
+    expect(result[0].content).toBe('Do the task');
+  });
+
+  it('parses "[Agent → Target]: message" format', () => {
+    const result = parseMessages('[Lead Agent → Worker]: Start deployment', 'sess-1');
+    expect(result).toHaveLength(1);
+    expect(result[0].sender).toBe('Lead Agent');
+    expect(result[0].receiver).toBe('Worker');
+    expect(result[0].content).toBe('Start deployment');
+  });
+
+  it('parses "Sending message to Agent: message" format', () => {
+    const result = parseMessages('Sending message to Backend: Update the API', 'sess-1');
+    expect(result).toHaveLength(1);
+    expect(result[0].sender).toBe('lead');
+    expect(result[0].receiver).toBe('Backend');
+    expect(result[0].content).toBe('Update the API');
+  });
+
+  it('strips ANSI codes before parsing', () => {
+    const ansi = '\x1b[32m@frontend> Building\x1b[0m';
+    const result = parseMessages(ansi, 'sess-1');
+    expect(result).toHaveLength(1);
+    expect(result[0].sender).toBe('frontend');
+    expect(result[0].content).toBe('Building');
+  });
+
+  it('deduplicates identical messages', () => {
+    const text = '@agent> Hello\n@agent> Hello';
+    const result = parseMessages(text, 'sess-1');
+    expect(result).toHaveLength(1);
+  });
+
+  it('skips empty lines', () => {
+    const result = parseMessages('\n\n\n', 'sess-1');
+    expect(result).toHaveLength(0);
+  });
+
+  it('returns empty array for non-matching text', () => {
+    const result = parseMessages('This is normal output', 'sess-1');
+    expect(result).toHaveLength(0);
+  });
+
+  it('handles multiple different messages', () => {
+    const text = '@frontend> Building\n@backend> Ready';
+    const result = parseMessages(text, 'sess-1');
+    expect(result).toHaveLength(2);
+    expect(result[0].sender).toBe('frontend');
+    expect(result[1].sender).toBe('backend');
+  });
+
+  it('assigns incremental IDs', () => {
+    const result = parseMessages('@a> Hello\n@b> World', 'sess-1');
+    expect(result[0].id).toMatch(/^msg-\d+$/);
+    expect(result[1].id).toMatch(/^msg-\d+$/);
+    expect(result[0].id).not.toBe(result[1].id);
+  });
+});

package/src/shared/model-detector.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from 'vitest';
+import { detectModelFromOutput } from './model-detector';
+
+describe('detectModelFromOutput', () => {
+  describe('initial detection (welcome screen)', () => {
+    it('detects "Haiku 4.5 ·" format', () => {
+      const result = detectModelFromOutput('Haiku 4.5 · Claude Max', true);
+      expect(result).toEqual({ model: 'haiku', confidence: 'high' });
+    });
+
+    it('detects "Opus 4.6 ·" format', () => {
+      const result = detectModelFromOutput('Opus 4.6 · Claude Max', true);
+      expect(result).toEqual({ model: 'opus', confidence: 'high' });
+    });
+
+    it('detects "Sonnet 4.5 ·" format', () => {
+      const result = detectModelFromOutput('Sonnet 4.5 · Claude Max', true);
+      expect(result).toEqual({ model: 'sonnet', confidence: 'high' });
+    });
+
+    it('detects "Claude 3.5 Sonnet" format', () => {
+      const result = detectModelFromOutput('Welcome to Claude 3.5 Sonnet', true);
+      expect(result).toEqual({ model: 'sonnet', confidence: 'high' });
+    });
+
+    it('detects "(Opus 4.6 · Most capable" format', () => {
+      const result = detectModelFromOutput('(Opus 4.6 · Most capable model)', true);
+      expect(result).toEqual({ model: 'opus', confidence: 'high' });
+    });
+
+    it('rejects promo text without ·', () => {
+      // "Opus 4.6 is here" should NOT match the first pattern
+      // because "is here" appears before "·"
+      const result = detectModelFromOutput('Opus 4.6 is here · $50 free', true);
+      // This should still match via the second pattern (Claude ... Opus)
+      // or not match the first pattern. The key is it doesn't falsely detect.
+      // Actually the first pattern requires · immediately after version, "is here" breaks it.
+      expect(result.model).toBeNull();
+    });
+
+    it('returns null for unrecognized text', () => {
+      const result = detectModelFromOutput('Welcome to the chat', true);
+      expect(result).toEqual({ model: null, confidence: 'low' });
+    });
+
+    it('strips ANSI codes before matching', () => {
+      const ansi = '\x1b[1m\x1b[34mHaiku 4.5 · Claude Max\x1b[0m';
+      const result = detectModelFromOutput(ansi, true);
+      expect(result).toEqual({ model: 'haiku', confidence: 'high' });
+    });
+  });
+
+  describe('switch detection', () => {
+    it('detects "Set model to Opus"', () => {
+      const result = detectModelFromOutput('Set model to Opus (claude-opus-4-6)', false);
+      expect(result).toEqual({ model: 'opus', confidence: 'high' });
+    });
+
+    it('detects "Set model to Default (Opus 4.6..."', () => {
+      const result = detectModelFromOutput('Set model to Default (Opus 4.6 · Most capable)', false);
+      expect(result).toEqual({ model: 'opus', confidence: 'high' });
+    });
+
+    it('detects "Kept model as Sonnet"', () => {
+      const result = detectModelFromOutput('Kept model as Sonnet', false);
+      expect(result).toEqual({ model: 'sonnet', confidence: 'high' });
+    });
+
+    it('detects "Kept model as Default (Haiku"', () => {
+      const result = detectModelFromOutput('Kept model as Default (Haiku 4.5)', false);
+      expect(result).toEqual({ model: 'haiku', confidence: 'high' });
+    });
+
+    it('detects "Model changed to haiku"', () => {
+      const result = detectModelFromOutput('Model changed to haiku', false);
+      expect(result).toEqual({ model: 'haiku', confidence: 'high' });
+    });
+
+    it('returns null for unrelated text', () => {
+      const result = detectModelFromOutput('This is just some output text', false);
+      expect(result).toEqual({ model: null, confidence: 'low' });
+    });
+
+    it('strips ANSI before switch detection', () => {
+      const ansi = '\x1b[32mSet model to Opus\x1b[0m';
+      const result = detectModelFromOutput(ansi, false);
+      expect(result).toEqual({ model: 'opus', confidence: 'high' });
+    });
+  });
+});

package/src/shared/model-detector.ts

@@ -0,0 +1,97 @@
+/**
+ * Model Detector — Parse terminal output to detect active Claude model
+ *
+ * Detects model switches from Claude Code CLI output in two phases:
+ * 1. Initial detection: Parse welcome screen for starting model
+ * 2. Switch detection: Parse /model command confirmations
+ */
+
+export type ClaudeModel = 'sonnet' | 'opus' | 'haiku' | 'auto';
+
+export interface ModelDetectionResult {
+  model: ClaudeModel | null;
+  confidence: 'high' | 'medium' | 'low';
+}
+
+// Patterns for detecting model switches via /model command
+const SWITCH_PATTERNS = [
+  /Set model to (?:Default )?\(?(Opus|Sonnet|Haiku)/i,  // "Set model to Default (Opus 4.6..."
+  /Set model to (\w+)/i,                                 // "Set model to opus (claude-opus-4-6)"
+  /Kept model as (?:Default )?\(?(Opus|Sonnet|Haiku)/i, // "Kept model as Default (recommended)"
+  /Kept model as (\w+)/i,                                // "Kept model as haiku"
+  /Switched to (?:claude[- ])?(\w+)/i,
+  /Now using (?:model: )?(\w+)/i,
+  /Model changed to (\w+)/i,
+  /Using model (\w+)/i,
+];
+
+// Patterns for detecting initial model from welcome screen
+// IMPORTANT: Pattern 0 requires "·" immediately after version to exclude promo text
+// like "Opus 4.6 is here · $50 free extra usage" (which has "is here" before "·")
+const WELCOME_PATTERNS = [
+  /(Opus|Sonnet|Haiku)\s+\d+\.\d+\s*·/i,          // "Haiku 4.5 · Claude Max" (v2.1+ format, requires ·)
+  /Claude (?:3\.5 |4\.\d+ )?(Sonnet|Opus|Haiku)/i,
+  /\((Opus|Sonnet|Haiku)\s+\d+\.\d+/i,            // "(Opus 4.6 · Most capable..."
+  /Using model[: ]+(\w+)/i,
+  /Model[: ]+(\w+)/i,
+  /\((\w+)\s+\d+\.\d+\)/i, // e.g., "(Sonnet 4.5)"
+];
+
+/**
+ * Strip ANSI escape sequences from terminal output.
+ * Handles CSI sequences (\x1b[...X), OSC sequences (\x1b]...\x07), and single-char escapes.
+ */
+function stripAnsi(text: string): string {
+  return text
+    .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')   // CSI sequences (colors, cursor, etc.)
+    .replace(/\x1b\][^\x07]*\x07/g, '')        // OSC sequences (title, etc.)
+    .replace(/\x1b[()][A-Z0-9]/g, '')          // Character set selection
+    .replace(/\x1b[=>]/g, '');                  // Keypad mode
+}
+
+/**
+ * Detect model from terminal output.
+ *
+ * @param text - Terminal output to parse (raw PTY output with ANSI codes is OK)
+ * @param isInitial - True for welcome screen detection, false for switch detection
+ * @returns Detection result with confidence level
+ */
+export function detectModelFromOutput(
+  text: string,
+  isInitial: boolean = false
+): ModelDetectionResult {
+  const clean = stripAnsi(text);
+  const patterns = isInitial ? WELCOME_PATTERNS : SWITCH_PATTERNS;
+
+  for (const pattern of patterns) {
+    const match = clean.match(pattern);
+    if (match) {
+      const raw = match[1].toLowerCase();
+      const normalized = normalizeModelName(raw);
+      if (normalized) {
+        return { model: normalized, confidence: 'high' };
+      }
+    }
+  }
+
+  return { model: null, confidence: 'low' };
+}
+
+/**
+ * Normalize raw model name to canonical ClaudeModel type.
+ */
+function normalizeModelName(raw: string): ClaudeModel | null {
+  const map: Record<string, ClaudeModel> = {
+    'sonnet': 'sonnet',
+    '3.5-sonnet': 'sonnet',
+    '4-sonnet': 'sonnet',
+    'opus': 'opus',
+    '3-opus': 'opus',
+    '4-opus': 'opus',
+    'haiku': 'haiku',
+    '3-haiku': 'haiku',
+    '4-haiku': 'haiku',
+    'auto': 'auto',
+  };
+  return map[raw] || null;
+}

package/src/shared/types/command-types.ts

@@ -0,0 +1,26 @@
+/**
+ * Command types for enhanced command palette
+ */
+
+export type CommandCategory = 'sessions' | 'view' | 'templates' | 'panels' | 'settings' | 'help';
+
+export interface Command {
+  id: string;
+  category: CommandCategory;
+  title: string;
+  description?: string;
+  keywords?: string[]; // For better search
+  shortcut?: string; // Display keyboard shortcut
+  icon?: string; // Icon name or SVG
+  action?: string; // IPC method name or special action
+  args?: any[]; // Arguments for the action
+}
+
+export interface CommandSearchResult extends Command {
+  score: number; // Relevance score for sorting
+}
+
+export interface CommandRegistryData {
+  commands: Command[];
+  categories: Record<CommandCategory, { label: string; icon: string }>;
+}