@kirosnn/mosaic 0.71.0 → 0.73.0

package/src/agent/tools/executor.ts

@@ -1,12 +1,11 @@
-import { readFile, writeFile, readdir, appendFile, stat, mkdir } from 'fs/promises';
+import { readFile, writeFile, readdir, appendFile, stat, mkdir, realpath } from 'fs/promises';
 import { join, resolve, dirname, extname, sep } from 'path';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import { requestApproval } from '../../utils/approvalBridge';
 import { shouldRequireApprovals } from '../../utils/config';
 import { generateDiff, formatDiffForDisplay } from '../../utils/diff';
-import { captureFileSnapshot } from '../../utils/undoRedo';
-import { trackFileChange, trackFileCreated, trackFileDeleted } from '../../utils/fileChangeTracker';
+import { trackFileChange, trackFileCreated } from '../../utils/fileChangeTracker';
 import TurndownService from 'turndown';
 import { Readability } from '@mozilla/readability';
 import { parseHTML } from 'linkedom';
@@ -189,24 +188,23 @@ export interface ToolResult {
   diff?: string[];
 }
 
-const pathValidationCache = new Map<string, boolean>();
 const globPatternCache = new Map<string, RegExp>();
 
+async function validatePath(fullPath: string, workspace: string): Promise<boolean> {
+  const normalizedWorkspace = workspace.endsWith(sep) ? workspace : workspace + sep;
 
-function validatePath(fullPath: string, workspace: string): boolean {
-  const cacheKey = `${fullPath}|${workspace}`;
-  const cached = pathValidationCache.get(cacheKey);
-  if (cached !== undefined) return cached;
-
-  const result = fullPath.startsWith(workspace);
-  pathValidationCache.set(cacheKey, result);
-
-  if (pathValidationCache.size > 1000) {
-    const firstKey = pathValidationCache.keys().next().value;
-    if (firstKey) pathValidationCache.delete(firstKey);
+  try {
+    const resolved = await realpath(fullPath);
+    return resolved === workspace || resolved.startsWith(normalizedWorkspace);
+  } catch {
+    const parent = dirname(fullPath);
+    try {
+      const resolvedParent = await realpath(parent);
+      return resolvedParent === workspace || resolvedParent.startsWith(normalizedWorkspace);
+    } catch {
+      return fullPath === workspace || fullPath.startsWith(normalizedWorkspace);
+    }
   }
-
-  return result;
 }
 
 const EXCLUDED_DIRECTORIES = new Set([
@@ -284,15 +282,6 @@ interface SearchOptions {
 
 const DEFAULT_MAX_FILE_SIZE = 1024 * 1024;
 
-function isValidRegex(pattern: string): { valid: boolean; error?: string } {
-  try {
-    new RegExp(pattern);
-    return { valid: true };
-  } catch (e) {
-    return { valid: false, error: e instanceof Error ? e.message : 'Invalid regular expression' };
-  }
-}
-
 function isBinaryFile(buffer: Buffer, bytesToCheck = 8000): boolean {
   const checkLength = Math.min(buffer.length, bytesToCheck);
   let nullCount = 0;
@@ -465,12 +454,18 @@ interface WalkResult {
   excluded?: boolean;
 }
 
-async function walkDirectory(dir: string, filePattern?: string, includeHidden = false): Promise<WalkResult[]> {
+interface WalkOutput {
+  results: WalkResult[];
+  errors: string[];
+}
+
+async function walkDirectory(dir: string, filePattern?: string, includeHidden = false): Promise<WalkOutput> {
   const results: WalkResult[] = [];
+  const errors: string[] = [];
 
   try {
     const entries = await readdir(dir, { withFileTypes: true });
-    const subDirPromises: Promise<WalkResult[]>[] = [];
+    const subDirPromises: Promise<WalkOutput>[] = [];
 
     for (const entry of entries) {
       if (!includeHidden && entry.name.startsWith('.')) continue;
@@ -491,27 +486,31 @@ async function walkDirectory(dir: string, filePattern?: string, includeHidden =
     }
 
     if (subDirPromises.length > 0) {
-      const subResults = await Promise.all(subDirPromises);
-      for (const subResult of subResults) {
-        results.push(...subResult);
+      const subOutputs = await Promise.all(subDirPromises);
+      for (const sub of subOutputs) {
+        results.push(...sub.results);
+        errors.push(...sub.errors);
       }
     }
-  } catch {
-    return results;
+  } catch (e) {
+    errors.push(`${dir}: ${e instanceof Error ? e.message : String(e)}`);
   }
 
-  return results;
+  return { results, errors };
 }
 
-async function listFilesRecursive(dirPath: string, workspace: string, filterPattern?: string, includeHidden = false): Promise<WalkResult[]> {
+async function listFilesRecursive(dirPath: string, workspace: string, filterPattern?: string, includeHidden = false): Promise<WalkOutput> {
   const fullPath = resolve(workspace, dirPath);
-  const files = await walkDirectory(fullPath, filterPattern, includeHidden);
+  const { results, errors } = await walkDirectory(fullPath, filterPattern, includeHidden);
   const separator = workspace.endsWith(sep) ? '' : sep;
 
-  return files.map(file => ({
-    ...file,
-    path: file.path.replace(workspace + separator, '')
-  }));
+  return {
+    results: results.map(file => ({
+      ...file,
+      path: file.path.replace(workspace + separator, '')
+    })),
+    errors,
+  };
 }
 
 async function findFilesByPattern(pattern: string, searchPath: string): Promise<string[]> {
@@ -520,7 +519,7 @@ async function findFilesByPattern(pattern: string, searchPath: string): Promise<
   const hasDoubleStar = pattern.includes('**');
 
   if (hasDoubleStar) {
-    const files = await walkDirectory(searchPath, undefined, false);
+    const { results: files } = await walkDirectory(searchPath, undefined, false);
     const separator = searchPath.endsWith(sep) ? '' : sep;
     const root = searchPath + separator;
 
@@ -723,7 +722,7 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
         const endLine = args.end_line as number | undefined;
         const fullPath = resolve(workspace, path);
 
-        if (!validatePath(fullPath, workspace)) {
+        if (!await validatePath(fullPath, workspace)) {
           return {
             success: false,
             error: 'Access denied: path is outside workspace'
@@ -760,19 +759,17 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
       case 'write': {
         const path = args.path as string;
         let content = typeof args.content === 'string' ? args.content : '';
-        if (content) content = content.trimEnd(); // Ensure no trailing empty lines
+        if (content) content = content.trimEnd();
         const append = args.append === true;
         const fullPath = resolve(workspace, path);
 
-        if (!validatePath(fullPath, workspace)) {
+        if (!await validatePath(fullPath, workspace)) {
           return {
             success: false,
             error: 'Access denied: path is outside workspace'
           };
         }
 
-        captureFileSnapshot(path);
-
         await mkdir(dirname(fullPath), { recursive: true });
 
         let oldContent = '';
@@ -817,7 +814,7 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
         const includeHidden = args.include_hidden === null ? undefined : (args.include_hidden as boolean | undefined);
         const fullPath = resolve(workspace, path);
 
-        if (!validatePath(fullPath, workspace)) {
+        if (!await validatePath(fullPath, workspace)) {
           return {
             success: false,
             error: 'Access denied: path is outside workspace'
@@ -825,7 +822,7 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
         }
 
         if (recursive) {
-          const files = await listFilesRecursive(path, workspace, filter, includeHidden);
+          const { results: files, errors: walkErrors } = await listFilesRecursive(path, workspace, filter, includeHidden);
           const fileStats = await Promise.all(
             files.map(async (file) => {
               if (file.excluded) {
@@ -836,17 +833,29 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
                 };
               }
               const filePath = resolve(workspace, file.path);
-              const stats = await stat(filePath);
-              return {
-                path: file.path,
-                type: stats.isDirectory() ? 'directory' : 'file',
-                size: stats.size,
-              };
+              try {
+                const stats = await stat(filePath);
+                return {
+                  path: file.path,
+                  type: stats.isDirectory() ? 'directory' : 'file',
+                  size: stats.size,
+                };
+              } catch {
+                return {
+                  path: file.path,
+                  type: 'unknown',
+                  error: 'access denied',
+                };
+              }
             })
           );
+          const output: Record<string, unknown> = { files: fileStats };
+          if (walkErrors.length > 0) {
+            output.errors = walkErrors.slice(0, 10);
+          }
           return {
             success: true,
-            result: JSON.stringify(fileStats, null, 2)
+            result: JSON.stringify(output, null, 2)
           };
         } else {
           const entries = await readdir(fullPath, { withFileTypes: true });
@@ -910,7 +919,7 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
               : `Command timed out after ${timeout}ms and produced no output.\n\n[Process may be running in background]`;
 
             return {
-              success: true,
+              success: false,
               result: output
             };
           }
@@ -922,7 +931,7 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
             : `Command failed: ${errorMessage}`;
 
           return {
-            success: true,
+            success: false,
             result: fullOutput
           };
         }
@@ -933,7 +942,7 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
         const searchPath = (args.path === null ? undefined : (args.path as string | undefined)) || '.';
         const fullPath = resolve(workspace, searchPath);
 
-        if (!validatePath(fullPath, workspace)) {
+        if (!await validatePath(fullPath, workspace)) {
           return {
             success: false,
             error: 'Access denied: path is outside workspace'
@@ -971,7 +980,7 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
 
         const fullPath = resolve(workspace, searchPath);
 
-        if (!validatePath(fullPath, workspace)) {
+        if (!await validatePath(fullPath, workspace)) {
           return {
             success: false,
             error: 'Access denied: path is outside workspace'
@@ -996,22 +1005,24 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
           };
         }
 
+        const normalizedFileType = typeof fileType === 'string' ? fileType.trim().toLowerCase() : undefined;
+        const fileTypeParts = normalizedFileType
+          ? normalizedFileType.split(',').map(p => p.trim()).filter(Boolean)
+          : [];
+        const resolvedExtensions = fileTypeParts.length > 0
+          ? Array.from(new Set(fileTypeParts.flatMap((part) => {
+            const mapped = FILE_TYPE_EXTENSIONS[part];
+            if (mapped && mapped.length > 0) return mapped;
+            if (part.startsWith('.')) return [part];
+            return [`.${part}`];
+          })))
+          : undefined;
+
         let finalPattern: string;
         if (pattern) {
           finalPattern = pattern.includes('**') ? pattern : `**/${pattern}`;
-        } else if (fileType) {
-          const extensions = FILE_TYPE_EXTENSIONS[fileType.toLowerCase()];
-          if (!extensions) {
-            return {
-              success: false,
-              error: `Unknown file type: ${fileType}. Available types: ${Object.keys(FILE_TYPE_EXTENSIONS).join(', ')}`
-            };
-          }
-          if (extensions.length === 1) {
-            finalPattern = `**/*${extensions[0]}`;
-          } else {
-            finalPattern = '**/*';
-          }
+        } else if (resolvedExtensions && resolvedExtensions.length === 1) {
+          finalPattern = `**/*${resolvedExtensions[0]}`;
         } else {
           finalPattern = '**/*';
         }
@@ -1022,11 +1033,8 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
           allFiles = allFiles.filter(f => !f.split('/').some(part => part.startsWith('.')));
         }
 
-        if (fileType && !pattern) {
-          const extensions = FILE_TYPE_EXTENSIONS[fileType.toLowerCase()];
-          if (extensions) {
-            allFiles = allFiles.filter(f => extensions.some(ext => f.toLowerCase().endsWith(ext)));
-          }
+        if (resolvedExtensions && !pattern) {
+          allFiles = allFiles.filter(f => resolvedExtensions.some(ext => f.toLowerCase().endsWith(ext)));
         }
 
         if (excludePattern) {
@@ -1104,12 +1112,16 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
 
         let formattedResult: string;
 
+        const skippedDetails = skippedFiles.length > 0
+          ? skippedFiles.slice(0, 5).map(s => ({ file: s.file, reason: s.reason }))
+          : undefined;
+
         if (outputMode === 'files') {
           const filesOnly = results.map(r => r.file);
           const summary = {
             files_found: filesOnly.length,
             files: filesOnly,
-            ...(skippedFiles.length > 0 && { skipped: skippedFiles.length })
+            ...(skippedFiles.length > 0 && { skipped: skippedFiles.length, skipped_details: skippedDetails })
           };
           formattedResult = JSON.stringify(summary, null, 2);
         } else if (outputMode === 'count') {
@@ -1118,7 +1130,7 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
             total_matches: totalMatchCount,
             files_with_matches: counts.length,
             counts,
-            ...(skippedFiles.length > 0 && { skipped: skippedFiles.length })
+            ...(skippedFiles.length > 0 && { skipped: skippedFiles.length, skipped_details: skippedDetails })
           };
           formattedResult = JSON.stringify(summary, null, 2);
         } else {
@@ -1126,7 +1138,7 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
             total_matches: totalMatchCount,
             files_searched: allFiles.length,
             files_with_matches: results.length,
-            ...(skippedFiles.length > 0 && { skipped_files: skippedFiles.length }),
+            ...(skippedFiles.length > 0 && { skipped_files: skippedFiles.length, skipped_details: skippedDetails }),
             ...(totalResults >= maxResults && { truncated: true, max_results: maxResults }),
             results: results.map(r => ({
               file: r.file,
@@ -1156,19 +1168,17 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
         const path = args.path as string;
         const oldContent = args.old_content as string;
         let newContent = args.new_content as string;
-        if (newContent) newContent = newContent.trimEnd(); // Ensure no trailing empty lines
+        if (newContent) newContent = newContent.trimEnd();
         const occurrence = ((args.occurrence === null ? undefined : (args.occurrence as number | undefined)) ?? 1);
         const fullPath = resolve(workspace, path);
 
-        if (!validatePath(fullPath, workspace)) {
+        if (!await validatePath(fullPath, workspace)) {
           return {
             success: false,
             error: 'Access denied: path is outside workspace'
           };
         }
 
-        captureFileSnapshot(path);
-
         await mkdir(dirname(fullPath), { recursive: true });
 
         let content = '';
@@ -1240,7 +1250,7 @@ DO NOT continue without using the question tool. DO NOT ask in plain text.`;
         }
         const fullPath = resolve(workspace, path);
 
-        if (!validatePath(fullPath, workspace)) {
+        if (!await validatePath(fullPath, workspace)) {
           return {
             success: false,
             error: 'Access denied: path is outside workspace'

package/src/agent/tools/exploreExecutor.ts

@@ -7,7 +7,7 @@ import { createXai } from '@ai-sdk/xai';
 import { z } from 'zod';
 import { readConfig } from '../../utils/config';
 import { executeTool } from './executor';
-import { getExploreAbortSignal, isExploreAborted, notifyExploreTool } from '../../utils/exploreBridge';
+import { getExploreAbortSignal, isExploreAborted, notifyExploreTool, getExploreContext } from '../../utils/exploreBridge';
 
 interface ExploreLog {
   tool: string;
@@ -36,7 +36,7 @@ IMPORTANT RULES:
 5. Summarize findings clearly and include relevant file paths and code snippets
 6. You MUST call the "done" tool when finished - this is the only way to complete the exploration`;
 
-const MAX_STEPS = 50;
+const MAX_STEPS = 100;
 
 interface ExploreResult {
   success: boolean;
@@ -78,13 +78,6 @@ function createModelProvider(config: { provider: string; model: string; apiKey?:
 
 let exploreDoneResult: string | null = null;
 
-function getResultPreview(result: string | undefined): string {
-  if (!result) return '';
-  const lines = result.split('\n');
-  if (lines.length <= 3) return result.substring(0, 200);
-  return lines.slice(0, 3).join('\n').substring(0, 200) + '...';
-}
-
 function createExploreTools() {
   return {
     read: createTool({
@@ -240,6 +233,11 @@ export async function executeExploreTool(purpose: string): Promise<ExploreResult
 
     const tools = createExploreTools();
 
+    const parentContext = getExploreContext();
+    const systemPrompt = parentContext
+      ? `${EXPLORE_SYSTEM_PROMPT}\n\nCONTEXT FROM PARENT CONVERSATION:\n${parentContext}`
+      : EXPLORE_SYSTEM_PROMPT;
+
     const result = streamText({
       model,
       messages: [
@@ -248,7 +246,7 @@ export async function executeExploreTool(purpose: string): Promise<ExploreResult
           content: `Explore the codebase to: ${purpose}`,
         },
       ],
-      system: EXPLORE_SYSTEM_PROMPT,
+      system: systemPrompt,
       tools,
       maxSteps: MAX_STEPS,
       abortSignal,

package/src/agent/tools/grep.ts

@@ -2,31 +2,32 @@ import { tool, type CoreTool } from 'ai';
 import { z } from 'zod';
 import { executeTool } from './executor';
 
-const FILE_TYPE_EXTENSIONS: Record<string, string[]> = {
-  ts: ['.ts', '.tsx', '.mts', '.cts'],
-  js: ['.js', '.jsx', '.mjs', '.cjs'],
-  py: ['.py', '.pyw', '.pyi'],
-  java: ['.java'],
-  go: ['.go'],
-  rust: ['.rs'],
-  c: ['.c', '.h'],
-  cpp: ['.cpp', '.cc', '.cxx', '.hpp', '.hh', '.hxx'],
-  cs: ['.cs'],
-  rb: ['.rb', '.rake', '.gemspec'],
-  php: ['.php', '.phtml'],
-  swift: ['.swift'],
-  kt: ['.kt', '.kts'],
-  scala: ['.scala'],
-  html: ['.html', '.htm', '.xhtml'],
-  css: ['.css', '.scss', '.sass', '.less'],
-  json: ['.json', '.jsonc'],
-  yaml: ['.yaml', '.yml'],
-  md: ['.md', '.markdown'],
-  sh: ['.sh', '.bash', '.zsh'],
-  sql: ['.sql'],
-  vue: ['.vue'],
-  svelte: ['.svelte'],
-};
+const FILE_TYPE_EXTENSIONS: Record<string, string[]> = {
+  ts: ['.ts', '.tsx', '.mts', '.cts'],
+  js: ['.js', '.jsx', '.mjs', '.cjs'],
+  py: ['.py', '.pyw', '.pyi'],
+  java: ['.java'],
+  go: ['.go'],
+  rust: ['.rs'],
+  c: ['.c', '.h'],
+  cpp: ['.cpp', '.cc', '.cxx', '.hpp', '.hh', '.hxx'],
+  cs: ['.cs'],
+  rb: ['.rb', '.rake', '.gemspec'],
+  php: ['.php', '.phtml'],
+  swift: ['.swift'],
+  kt: ['.kt', '.kts'],
+  scala: ['.scala'],
+  html: ['.html', '.htm', '.xhtml'],
+  css: ['.css', '.scss', '.sass', '.less'],
+  json: ['.json', '.jsonc'],
+  yaml: ['.yaml', '.yml'],
+  md: ['.md', '.markdown'],
+  txt: ['.txt'],
+  sh: ['.sh', '.bash', '.zsh'],
+  sql: ['.sql'],
+  vue: ['.vue'],
+  svelte: ['.svelte'],
+};
 
 export { FILE_TYPE_EXTENSIONS };
 
@@ -41,10 +42,10 @@ Examples:
 - grep(query="TODO") - Search in all files
 - grep(query="class.*Component", file_type="ts") - Reuse regex search
 - grep(query="handleClick", output_mode="files") - Just list matching files`,
-  parameters: z.object({
-    query: z.string().describe('Regular expression pattern to search for'),
-    file_type: z.string().optional().describe('File type: ts, js, tsx, jsx, py, java, go, rust, c, cpp, rb, php, json, yaml, md, html, css'),
-    pattern: z.string().optional().describe('Glob pattern for files (e.g., "**/*.config.ts"). Usually file_type is easier.'),
+  parameters: z.object({
+    query: z.string().describe('Regular expression pattern to search for'),
+    file_type: z.string().optional().describe('File type or extension (e.g. ts, tsx, js, txt, .env). Unknown types are treated as extensions.'),
+    pattern: z.string().optional().describe('Glob pattern for files (e.g., "**/*.config.ts"). Usually file_type is easier.'),
     path: z.string().optional().describe('Directory to search (defaults to workspace root)'),
     case_sensitive: z.boolean().optional().describe('Case-sensitive (default: false)'),
     whole_word: z.boolean().optional().describe('Match whole words only (default: false)'),

package/src/agent/tools/question.ts

@@ -10,11 +10,17 @@ export const question: CoreTool = tool({
       z.object({
         label: z.string().describe('The option label shown to the user.'),
         value: z.string().nullable().optional().describe('Optional value returned for the selected option. Use null if not needed.'),
+        group: z.string().optional().describe('Optional group name. Consecutive options with the same group are displayed under a shared header.'),
       })
     ).describe('List of options the user can pick from. A text input field is automatically displayed below the options where the user can type a custom response instead.'),
+    timeout: z.number().optional().describe('Optional timeout in seconds. The question is automatically rejected when time runs out.'),
+    validation: z.object({
+      pattern: z.string().describe('Regex pattern the custom text must match.'),
+      message: z.string().optional().describe('Error message shown when validation fails.'),
+    }).optional().describe('Optional validation for the custom text input.'),
   }),
   execute: async (args) => {
-    const answer = await askQuestion(args.prompt, args.options);
+    const answer = await askQuestion(args.prompt, args.options, args.timeout, args.validation);
     return answer;
   },
 });

package/src/agent/types.ts

@@ -117,14 +117,15 @@ export type AgentEvent =
   | FinishEvent
   | ErrorEvent;
 
-export interface ProviderConfig {
-  provider: string;
-  model: string;
-  apiKey?: string;
-  systemPrompt: string;
-  tools?: Record<string, CoreTool>;
-  maxSteps?: number;
-}
+export interface ProviderConfig {
+  provider: string;
+  model: string;
+  apiKey?: string;
+  systemPrompt: string;
+  tools?: Record<string, CoreTool>;
+  maxSteps?: number;
+  maxContextTokens?: number;
+}
 
 export interface AgentConfig {
   maxSteps?: number;

package/src/components/App.tsx

@@ -7,13 +7,13 @@ import { Setup } from './Setup';
 import { Main } from './Main';
 import { ShortcutsModal } from './ShortcutsModal';
 import { CommandModal } from './CommandsModal';
-import { Notification, type NotificationData } from './Notification';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { subscribeNotifications } from '../utils/notificationBridge';
-import { shouldRequireApprovals, setRequireApprovals } from '../utils/config';
-import { getCurrentApproval, respondApproval } from '../utils/approvalBridge';
-import { emitApprovalMode } from '../utils/approvalModeBridge';
+import { Notification, type NotificationData } from './Notification';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { subscribeNotifications } from '../utils/notificationBridge';
+import { shouldRequireApprovals, setRequireApprovals } from '../utils/config';
+import { getCurrentApproval, respondApproval } from '../utils/approvalBridge';
+import { emitApprovalMode } from '../utils/approvalModeBridge';
 
 const execAsync = promisify(exec);
 
@@ -32,7 +32,7 @@ export function App({ initialMessage }: AppProps) {
   const [shortcutsTab, setShortcutsTab] = useState<0 | 1>(0);
   const [commandsOpen, setCommandsOpen] = useState(false);
   const [notifications, setNotifications] = useState<NotificationData[]>([]);
-  const [pendingMessage, setPendingMessage] = useState<string | undefined>(initialMessage);
+  const [pendingMessage] = useState<string | undefined>(initialMessage);
   const lastSelectionRef = useRef<{ text: string; at: number } | null>(null);
 
   const renderer = useRenderer();
@@ -61,8 +61,8 @@ export function App({ initialMessage }: AppProps) {
     }
   }, []);
 
-  useEffect(() => {
-    const handler = (selection: any) => {
+  useEffect(() => {
+    const handler = (selection: any) => {
       if (!selection || selection.isSelecting || !selection.isActive) return;
       const text = typeof selection.getSelectedText === 'function' ? selection.getSelectedText() : '';
       if (!text) return;
@@ -79,41 +79,41 @@ export function App({ initialMessage }: AppProps) {
     return () => {
       rendererAny.off?.('selection', handler);
     };
-  }, [renderer, copyToClipboard, addNotification]);
-
-  useEffect(() => {
-    return subscribeNotifications((payload) => {
-      addNotification(payload.message, payload.type ?? 'info', payload.duration);
-    });
-  }, [addNotification]);
-
-  useEffect(() => {
-    const isDarwin = process.platform === 'darwin';
-
-    const handleKeyPress = (key: KeyEvent) => {
-      const k = key as any;
-
-      if (k.name === 'escape') {
-        setShortcutsOpen(false);
-        setCommandsOpen(false);
-        return;
-      }
-
-      if (k.name === 'tab' && k.shift) {
-        const next = !shouldRequireApprovals();
-        setRequireApprovals(next);
-        if (!next && getCurrentApproval()) {
-          respondApproval(true);
-        }
-        emitApprovalMode(next);
-        addNotification(next ? 'Approvals enabled' : 'Auto-approve enabled', 'info', 2500);
-        return;
-      }
-
-      if (shortcutsOpen && (k.name === 'f1' || k.name === 'f2')) {
-        setShortcutsTab(k.name === 'f2' ? 1 : 0);
-        return;
-      }
+  }, [renderer, copyToClipboard, addNotification]);
+
+  useEffect(() => {
+    return subscribeNotifications((payload) => {
+      addNotification(payload.message, payload.type ?? 'info', payload.duration);
+    });
+  }, [addNotification]);
+
+  useEffect(() => {
+    const isDarwin = process.platform === 'darwin';
+
+    const handleKeyPress = (key: KeyEvent) => {
+      const k = key as any;
+
+      if (k.name === 'escape') {
+        setShortcutsOpen(false);
+        setCommandsOpen(false);
+        return;
+      }
+
+      if (k.name === 'tab' && k.shift) {
+        const next = !shouldRequireApprovals();
+        setRequireApprovals(next);
+        if (!next && getCurrentApproval()) {
+          respondApproval(true);
+        }
+        emitApprovalMode(next);
+        addNotification(next ? 'Approvals enabled' : 'Auto-approve enabled', 'info', 2500);
+        return;
+      }
+
+      if (shortcutsOpen && (k.name === 'f1' || k.name === 'f2')) {
+        setShortcutsTab(k.name === 'f2' ? 1 : 0);
+        return;
+      }
 
       const seq = k.sequence;