copilot-liku-cli 0.0.10 → 0.0.11

package/INSTALLATION.md

@@ -155,6 +155,29 @@ npm link
 
 This creates a symbolic link from your global `node_modules` to your local development directory. Any changes you make will be immediately available when you run `liku`.
 
+### 3b. Use the local repo version in another project (same machine)
+
+If you want another project (e.g., `C:\dev\Whatup`) to use this local working copy instead of the npm-published version:
+
+From the other project folder:
+
+```bash
+npm link copilot-liku-cli
+```
+
+Recommended verification (ensures you are using the local linked binary):
+
+```bash
+npx --no-install liku doctor --json
+```
+
+To switch the other project back to the published npm package:
+
+```bash
+npm unlink copilot-liku-cli
+npm install copilot-liku-cli
+```
+
 ### 4. Verify Setup
 
 ```bash

package/QUICKSTART.md

@@ -42,6 +42,37 @@ liku start
 npm start
 ```
 
+#### Option 3: Use the local repo version in another project (recommended for dev)
+
+If you want a different project (e.g., `C:\dev\Whatup`) to use your *local working copy* of this repo (instead of the npm-published version), use `npm link`.
+
+From the repo root:
+
+```bash
+npm link
+```
+
+From the other project:
+
+```bash
+npm link copilot-liku-cli
+```
+
+Verify you’re running the repo copy (recommended):
+
+```bash
+npx --no-install liku doctor --json
+```
+
+Look for `env.projectRoot` being the repo path (e.g., `C:\dev\copilot-Liku-cli`).
+
+To switch back to the published npm version:
+
+```bash
+npm unlink copilot-liku-cli
+npm i copilot-liku-cli
+```
+
 ## Quick Verify (Recommended)
 
 After install, run these checks in order:
@@ -76,6 +107,25 @@ For deterministic, machine-readable output (recommended for smaller models / aut
 liku doctor --json
 ```
 
+#### `doctor.v1` schema contract (for smaller models)
+
+When you consume `liku doctor --json`, treat it as the source-of-truth for targeting and planning. The output is a single JSON object with:
+
+- `schemaVersion` (string): currently `doctor.v1`.
+- `ok` (boolean): `false` means at least one `checks[].status === "fail"`.
+- `checks[]` (array): structured checks with `{ id, status: "pass"|"warn"|"fail", message, details? }`.
+- `uiState` (object): UI Automation snapshot
+   - `uiState.activeWindow`: where input will go *right now*
+   - `uiState.windows[]`: discovered top-level windows (bounded unless `--all`)
+- `targeting` (object | null): present when `doctor` is given a request text
+   - `targeting.selectedWindow`: the best-matched window candidate
+   - `targeting.candidates[]`: scored alternatives (for disambiguation)
+- `plan` (object | null): present when a request is provided and a plan can be generated
+   - `plan.steps[]`: ordered steps, each with `{ state, goal, command, verification, notes? }`
+- `next.commands[]` (array of strings): copy/paste-ready commands extracted from `plan.steps[].command`.
+
+**Deterministic execution rule:** run `plan.steps[]` in order, and re-check `liku window --active` after any focus change before sending keys.
+
 `smoke:shortcuts` intentionally validates chat visibility via direct in-app
 toggle and validates keyboard routing on overlay with target gating.
 
@@ -163,6 +213,23 @@ When automating browsers, be explicit about **targeting**:
 
 If you skip steps 1–2 and the overlay/chat has focus, keyboard shortcuts may close the overlay instead of affecting the browser.
 
+#### Robust recipe (recommended)
+
+If your intent is to **continue in an existing Edge/Chrome window/tab**, prefer **in-window control** (focus + keyboard) over launching the browser again.
+
+- Prefer: **focus window → new tab / address bar → type → enter → verify**
+- Avoid for “existing tab control”: PowerShell COM \`SendKeys\`, \`Start-Process msedge ...\`, and \`microsoft-edge:...\` (these often open new windows/tabs and can be flaky).
+
+**Canonical flow (what to ask the agent to do):**
+1) Bring the **target browser window** (Edge/Chrome/Firefox/Brave/etc) to the foreground
+2) \`ctrl+t\` (new tab) then \`ctrl+l\` (address bar)
+3) Type a full URL (prefer \`https://...\`) and press Enter
+4) Wait for load, then perform page-level action (e.g., YouTube search)
+5) Validate after major steps; if typing drops characters, re-focus the address bar and retry
+
+**Self-heal typing retry (when URL is wrong):**
+\`ctrl+l\` → \`ctrl+a\` → type URL again → \`enter\`
+
 ### Selecting a Screen Element
 ```
 1. Press Ctrl+Alt+Space to open chat

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-liku-cli",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "GitHub Copilot CLI with headless agent + ultra-thin overlay architecture",
   "main": "src/main/index.js",
   "bin": {

package/src/cli/commands/doctor.js

@@ -79,6 +79,55 @@ function extractQuotedStrings(text) {
   return out;
 }
 
+function escapeDoubleQuotes(text) {
+  return String(text || '').replace(/"/g, '\\"');
+}
+
+function extractUrlCandidate(text) {
+  const str = normalizeText(text);
+
+  // Full URL
+  const fullUrl = /(https?:\/\/[^\s"']+)/i.exec(str);
+  if (fullUrl?.[1]) return fullUrl[1];
+
+  // Common bare domains (keep conservative)
+  const bare = /\b([a-z0-9-]+\.)+(com|net|org|io|ai|dev|edu|gov)(\/[^\s"']*)?\b/i.exec(str);
+  if (bare?.[0]) return bare[0];
+
+  return null;
+}
+
+function extractSearchQuery(text) {
+  const str = normalizeText(text);
+  const quoted = extractQuotedStrings(str);
+
+  // Prefer quoted strings if user said search ... for "..."
+  const searchFor = /\bsearch\b/i.test(str) && /\bfor\b/i.test(str);
+  if (searchFor && quoted.length) return quoted[0];
+
+  // Unquoted: search (on/in)? (youtube/google)? for <rest>
+  const m = /\bsearch(?:\s+(?:on|in))?(?:\s+(?:youtube|google))?\s+for\s+([^\n\r.;]+)$/i.exec(str);
+  if (m?.[1]) return normalizeText(m[1]);
+
+  return null;
+}
+
+function toHttpsUrl(urlish) {
+  const u = normalizeText(urlish);
+  if (!u) return null;
+  if (/^https?:\/\//i.test(u)) return u;
+  return `https://${u}`;
+}
+
+function buildSearchUrl({ query, preferYouTube = false }) {
+  const q = normalizeText(query);
+  if (!q) return null;
+  if (preferYouTube) {
+    return `https://www.youtube.com/results?search_query=${encodeURIComponent(q)}`;
+  }
+  return `https://www.google.com/search?q=${encodeURIComponent(q)}`;
+}
+
 function parseRequestHints(requestText) {
   const text = normalizeText(requestText);
   const lower = normalizeForMatch(text);
@@ -90,18 +139,42 @@ function parseRequestHints(requestText) {
   const inWindowMatch = /\b(?:in|within)\s+([^\n\r]+?)\s+window\b/i.exec(text);
   const windowHint = inWindowMatch ? normalizeText(inWindowMatch[1]) : null;
 
+  const wantsNewTab = /\bnew\s+tab\b/i.test(text) || /\bopen\s+a\s+new\s+tab\b/i.test(text);
+  const urlCandidate = extractUrlCandidate(text);
+  const searchQuery = extractSearchQuery(text);
+
+  const wantsIntegratedBrowser = /\b(integrated\s+browser|simple\s+browser|inside\s+vs\s*code|in\s+vs\s*code|vscode\s+insiders|workbench\.browser\.openlocalhostlinks|live\s+preview)\b/i.test(text);
+
+  const browserSignals = Boolean(urlCandidate)
+    || Boolean(searchQuery)
+    || /\b(go\s+to|navigate|visit|open\s+youtube|youtube\.com|search)\b/i.test(text);
+
   // Heuristic: infer app family
   const appHints = {
-    isBrowser: /\b(edge|chrome|browser|msedge)\b/i.test(text),
+    isBrowser: /\b(edge|chrome|chromium|firefox|brave|opera|vivaldi|browser|msedge)\b/i.test(text) || browserSignals,
     isEditor: /\b(vs\s*code|visual\s*studio\s*code|code\s*-\s*insiders|editor)\b/i.test(text),
     isTerminal: /\b(terminal|powershell|cmd\.exe|command\s+prompt|windows\s+terminal)\b/i.test(text),
     isExplorer: /\b(file\s+explorer|explorer\.exe)\b/i.test(text),
   };
 
+  const requestedBrowser = (() => {
+    // Ordered from most-specific to least-specific
+    if (/\bedge\s+beta\b/i.test(text)) return { name: 'edge', keywords: ['edge', 'msedge', 'beta'] };
+    if (/\bmsedge\b/i.test(text) || /\bmicrosoft\s+edge\b/i.test(text) || /\bedge\b/i.test(text)) return { name: 'edge', keywords: ['edge', 'msedge'] };
+    if (/\bgoogle\s+chrome\b/i.test(text) || /\bchrome\b/i.test(text) || /\bchromium\b/i.test(text)) return { name: 'chrome', keywords: ['chrome', 'chromium'] };
+    if (/\bmozilla\s+firefox\b/i.test(text) || /\bfirefox\b/i.test(text)) return { name: 'firefox', keywords: ['firefox'] };
+    if (/\bbrave\b/i.test(text)) return { name: 'brave', keywords: ['brave'] };
+    if (/\bvivaldi\b/i.test(text)) return { name: 'vivaldi', keywords: ['vivaldi'] };
+    if (/\bopera\b/i.test(text)) return { name: 'opera', keywords: ['opera'] };
+    return null;
+  })();
+
   // Infer intent
   const intent = (() => {
     if (/\bclose\b/.test(lower) && /\btab\b/.test(lower)) return 'close_tab';
     if (/\bclose\b/.test(lower) && /\bwindow\b/.test(lower)) return 'close_window';
+    if (appHints.isBrowser && (urlCandidate || searchQuery)) return 'browser_navigate';
+    if (appHints.isBrowser && /\b(new\s+tab|open\s+tab|ctrl\+t|ctrl\+l|navigate|go\s+to|visit|open\s+youtube|youtube\.com|search\s+for|search)\b/i.test(text)) return 'browser_navigate';
     if (/\bclick\b/.test(lower)) return 'click';
     if (/\btype\b/.test(lower) || /\benter\b/.test(lower)) return 'type';
     if (/\bscroll\b/.test(lower)) return 'scroll';
@@ -123,9 +196,42 @@ function parseRequestHints(requestText) {
     tabTitle,
     appHints,
     elementTextCandidates,
+    wantsNewTab,
+    urlCandidate,
+    searchQuery,
+    requestedBrowser,
+    wantsIntegratedBrowser,
   };
 }
 
+function isLikelyBrowserWindow(win) {
+  const title = win?.title || '';
+  const proc = win?.processName || '';
+  return (
+    includesCI(proc, 'msedge') || includesCI(title, 'edge') ||
+    includesCI(proc, 'chrome') || includesCI(title, 'chrome') ||
+    includesCI(proc, 'firefox') || includesCI(title, 'firefox') ||
+    includesCI(proc, 'brave') || includesCI(title, 'brave') ||
+    includesCI(proc, 'opera') || includesCI(title, 'opera') ||
+    includesCI(proc, 'vivaldi') || includesCI(title, 'vivaldi')
+  );
+}
+
+function isLikelyVSCodeWindow(win) {
+  const title = win?.title || '';
+  const proc = win?.processName || '';
+  return (
+    includesCI(proc, 'Code') || includesCI(proc, 'Code - Insiders') ||
+    includesCI(title, 'Visual Studio Code')
+  );
+}
+
+function isLocalhostUrl(urlish) {
+  const u = normalizeText(urlish);
+  if (!u) return false;
+  return /^(https?:\/\/)?(localhost|127\.0\.0\.1)(:\d+)?(\/|$)/i.test(u);
+}
+
 function scoreWindowCandidate(win, hints) {
   let score = 0;
   const reasons = [];
@@ -138,10 +244,20 @@ function scoreWindowCandidate(win, hints) {
     reasons.push('title matches windowHint');
   }
 
-  if (hints.appHints?.isBrowser && (includesCI(proc, 'msedge') || includesCI(title, 'edge') || includesCI(proc, 'chrome') || includesCI(title, 'chrome'))) {
+  const looksLikeBrowser = isLikelyBrowserWindow(win);
+
+  if (hints.appHints?.isBrowser && looksLikeBrowser) {
     score += 35;
     reasons.push('looks like browser');
   }
+
+  if (hints.requestedBrowser?.keywords?.length) {
+    const matchesPreferred = hints.requestedBrowser.keywords.some(k => includesCI(proc, k) || includesCI(title, k));
+    if (matchesPreferred) {
+      score += 25;
+      reasons.push(`matches requested browser (${hints.requestedBrowser.name})`);
+    }
+  }
   if (hints.appHints?.isEditor && (includesCI(title, 'visual studio code') || includesCI(title, 'code - insiders') || includesCI(proc, 'Code') || includesCI(proc, 'Code - Insiders'))) {
     score += 35;
     reasons.push('looks like editor');
@@ -164,8 +280,34 @@ function scoreWindowCandidate(win, hints) {
 }
 
 function buildSuggestedPlan(hints, activeWindow, rankedCandidates) {
-  const top = rankedCandidates?.[0]?.window || null;
-  const target = top || activeWindow || null;
+  const windowsRanked = Array.isArray(rankedCandidates) ? rankedCandidates.map(c => c.window).filter(Boolean) : [];
+  const browserWindowsRanked = windowsRanked.filter(isLikelyBrowserWindow);
+  const vsCodeWindowsRanked = windowsRanked.filter(isLikelyVSCodeWindow);
+
+  const target = (() => {
+    // If the user explicitly wants the VS Code integrated browser, target VS Code.
+    if (hints.wantsIntegratedBrowser) {
+      if (vsCodeWindowsRanked[0]) return vsCodeWindowsRanked[0];
+      if (activeWindow && isLikelyVSCodeWindow(activeWindow)) return activeWindow;
+      return windowsRanked[0] || activeWindow || null;
+    }
+
+    // For browser actions, never target an arbitrary non-browser window.
+    if (hints.intent === 'browser_navigate' && hints.appHints?.isBrowser) {
+      if (hints.requestedBrowser?.keywords?.length) {
+        const preferred = browserWindowsRanked.find(w => hints.requestedBrowser.keywords.some(k => includesCI(w?.processName || '', k) || includesCI(w?.title || '', k)));
+        if (preferred) return preferred;
+      }
+
+      // Fallback to any detected browser window, else the active window if it is a browser.
+      if (browserWindowsRanked[0]) return browserWindowsRanked[0];
+      if (activeWindow && isLikelyBrowserWindow(activeWindow)) return activeWindow;
+      return null;
+    }
+
+    // Non-browser intents: use ranking, then active window.
+    return windowsRanked[0] || activeWindow || null;
+  })();
   const plan = [];
 
   const targetTitleForFilter = target?.title ? String(target.title) : null;
@@ -221,6 +363,171 @@ function buildSuggestedPlan(hints, activeWindow, rankedCandidates) {
     return { target, plan };
   }
 
+  if (hints.intent === 'browser_navigate' && hints.appHints?.isBrowser) {
+    // If running inside VS Code and the user wants it, prefer using the Integrated Browser.
+    if (hints.wantsIntegratedBrowser) {
+      const url = toHttpsUrl(hints.urlCandidate) || buildSearchUrl({ query: hints.searchQuery, preferYouTube: false });
+      const localhostish = isLocalhostUrl(hints.urlCandidate);
+
+      plan.push({
+        state: 'OPEN_INTEGRATED_BROWSER',
+        goal: 'Open VS Code Integrated Browser',
+        command: 'liku keys ctrl+shift+p',
+        verification: 'Command Palette opens',
+        notes: 'Run the VS Code command: "Browser: Open Integrated Browser"',
+      });
+      plan.push({
+        state: 'COMMAND_INTEGRATED_BROWSER',
+        goal: 'Run the Integrated Browser command',
+        command: 'liku type "Browser: Open Integrated Browser"',
+        verification: 'The command appears in the palette',
+      });
+      plan.push({
+        state: 'CONFIRM_COMMAND',
+        goal: 'Execute the command',
+        command: 'liku keys enter',
+        verification: 'An Integrated Browser editor tab opens',
+        notes: localhostish
+          ? 'Tip: enable the VS Code setting workbench.browser.openLocalhostLinks to automatically open localhost links in the integrated browser.'
+          : 'Integrated Browser supports http(s) and file URLs.',
+      });
+
+      if (localhostish) {
+        plan.push({
+          state: 'OPEN_SETTINGS',
+          goal: 'Open VS Code Settings (optional)',
+          command: 'liku keys ctrl+,',
+          verification: 'Settings UI opens',
+        });
+        plan.push({
+          state: 'FIND_SETTING',
+          goal: 'Locate the localhost-integrated-browser setting',
+          command: 'liku type "workbench.browser.openLocalhostLinks"',
+          verification: 'The setting appears in search results',
+          notes: 'Enable it to route localhost links to the Integrated Browser.',
+        });
+        plan.push({
+          state: 'VERIFY_SETTING',
+          goal: 'Capture evidence of the setting state',
+          command: 'liku screenshot',
+          verification: 'Screenshot shows the setting and whether it is enabled',
+        });
+      }
+
+      if (url) {
+        plan.push({
+          state: 'FOCUS_ADDRESS_BAR',
+          goal: 'Focus the integrated browser address bar',
+          command: 'liku keys ctrl+l',
+          verification: 'Address bar is focused (URL text highlighted)',
+        });
+        plan.push({
+          state: 'TYPE_URL',
+          goal: 'Type the destination URL',
+          command: `liku type "${escapeDoubleQuotes(url)}"`,
+          verification: 'The full URL appears correctly in the address bar',
+        });
+        plan.push({
+          state: 'NAVIGATE',
+          goal: 'Navigate to the URL in the integrated browser',
+          command: 'liku keys enter',
+          verification: 'Page begins loading; content changes',
+        });
+      } else {
+        plan.push({
+          state: 'MISSING_URL',
+          goal: 'No URL could be inferred from the request',
+          command: 'liku screenshot',
+          verification: 'Use the screenshot to decide the next navigation step',
+        });
+      }
+
+      plan.push({
+        state: 'VERIFY_RESULT',
+        goal: 'Capture evidence of the resulting page state',
+        command: 'liku screenshot',
+        verification: 'Screenshot shows expected page state in the integrated browser',
+      });
+
+      return { target, plan };
+    }
+
+    if (!target) {
+      plan.push({
+        state: 'NO_BROWSER_WINDOW',
+        goal: 'No browser window was detected; open a browser window first',
+        command: 'liku window',
+        verification: 'A browser window (Edge/Chrome/Firefox/Brave/etc) appears in the list',
+      });
+      return { target: null, plan };
+    }
+
+    // Prefer deterministic in-window navigation over process launch.
+    const preferYouTube = /\byoutube\b/i.test(hints.raw || '') || /youtube\.com/i.test(hints.raw || '');
+    const url = (
+      toHttpsUrl(hints.urlCandidate) ||
+      buildSearchUrl({ query: hints.searchQuery, preferYouTube })
+    );
+
+    if (hints.wantsNewTab) {
+      plan.push({
+        state: 'OPEN_NEW_TAB',
+        goal: 'Open a new tab in the focused browser window',
+        command: 'liku keys ctrl+t',
+        verification: 'A new tab opens (tab count increases or blank tab appears)',
+      });
+    }
+
+    plan.push({
+      state: 'FOCUS_ADDRESS_BAR',
+      goal: 'Focus the address bar',
+      command: 'liku keys ctrl+l',
+      verification: 'Address bar is focused (URL text highlighted)',
+      notes: 'If focus is flaky, re-run `liku window --active` and re-focus the browser window before sending keys.',
+    });
+
+    if (url) {
+      plan.push({
+        state: 'TYPE_URL',
+        goal: `Type the destination URL${hints.searchQuery ? ' (search encoded into URL for reliability)' : ''}`,
+        command: `liku type "${escapeDoubleQuotes(url)}"`,
+        verification: 'The full URL appears correctly in the address bar',
+        notes: 'If characters drop: ctrl+l → ctrl+a → type URL again → enter (with short pauses).',
+      });
+      plan.push({
+        state: 'NAVIGATE',
+        goal: 'Navigate to the URL in the current tab',
+        command: 'liku keys enter',
+        verification: 'Page begins loading; title/content changes',
+      });
+    } else {
+      plan.push({
+        state: 'MISSING_URL',
+        goal: 'No URL could be inferred from the request',
+        command: 'liku screenshot',
+        verification: 'Use the screenshot to decide the next navigation step',
+      });
+    }
+
+    plan.push({
+      state: 'VERIFY_FOCUS',
+      goal: 'Verify keyboard focus stayed on the browser window',
+      command: 'liku window --active',
+      verification: hints.requestedBrowser?.name
+        ? `Active window process/title matches the requested browser (${hints.requestedBrowser.name})`
+        : 'Active window process/title matches a browser window',
+    });
+
+    plan.push({
+      state: 'VERIFY_RESULT',
+      goal: 'Capture evidence of the resulting page state',
+      command: 'liku screenshot',
+      verification: 'Screenshot shows expected page (e.g., YouTube results for query)',
+    });
+
+    return { target, plan };
+  }
+
   if (hints.intent === 'close_window') {
     plan.push({
       state: 'EXECUTE_ACTION',

package/src/main/ai-service.js

@@ -496,6 +496,32 @@ function getPlatformContext() {
 - **Reopen closed tab**: \`ctrl+shift+t\`
 - **Close window**: \`ctrl+shift+w\`
 
+### Browser Automation Policy (Robust)
+When the user asks to **use an existing browser window/tab** (Edge/Chrome), prefer **in-window control** (focus + keys) instead of launching processes.
+
+- **DO NOT** use PowerShell COM \`SendKeys\` or \`Start-Process msedge\` / \`microsoft-edge:\` to control an existing tab. These are unreliable and may open new windows/tabs unexpectedly.
+- **DO** use Liku actions: \`bring_window_to_front\` / \`focus_window\` + \`key\` + \`type\` + \`wait\`.
+- **Chain the whole flow in one action block** so focus is maintained; avoid pausing for manual validation.
+
+**Reliable recipes:**
+- **Open a new tab in the existing Edge/Chrome window**:
+  1) bring window to front
+  2) wait 300–800ms
+  3) \`ctrl+t\`
+  4) wait 200–500ms
+- **Navigate the current tab to a URL**:
+  1) \`ctrl+l\` (address bar)
+  2) wait 150–300ms
+  3) type full URL (prefer \`https://...\`)
+  4) \`enter\`
+  5) wait 2000–5000ms (page load)
+- **Self-heal if text drops/mis-types**: \`ctrl+l\` → \`ctrl+a\` → type again → \`enter\` (add waits)
+- **YouTube search (keyboard-first)**: press \`/\` to focus search → type query → \`enter\` → wait
+
+**Verification guidance:**
+- If unsure whether the right window/tab is active, take a quick \`screenshot\` and proceed only when the browser is clearly focused.
+- Validate major state changes (after focus, after navigation, after submitting search). If validation fails, retry focus + navigation (bounded retries).
+
 ### Focus Rule (CRITICAL)
 Before sending keyboard shortcuts, make sure the intended app window is focused.
 If the overlay/chat has focus, shortcuts like \`ctrl+w\` / \`ctrl+shift+w\` may close the overlay instead of the target app.
@@ -1920,6 +1946,27 @@ function analyzeActionSafety(action, targetInfo = {}) {
     case 'key':
       // Analyze key combinations
       const key = (action.key || '').toLowerCase();
+      const keyNorm = key.replace(/\s+/g, '');
+
+      // Treat window/tab/app-close shortcuts as HIGH risk: they can instantly close the overlay,
+      // the active terminal tab/window, a browser window, or dismiss important dialogs.
+      // Require explicit confirmation so smaller models can't accidentally "self-close" the UI.
+      const closeCombos = [
+        'alt+f4',
+        'ctrl+w',
+        'ctrl+shift+w',
+        'ctrl+q',
+        'ctrl+shift+q',
+        'cmd+w',
+        'cmd+q',
+      ];
+      if (closeCombos.includes(keyNorm)) {
+        result.riskLevel = ActionRiskLevel.CRITICAL;
+        result.warnings.push(`Close shortcut detected: ${action.key}`);
+        result.requiresConfirmation = true;
+        break;
+      }
+
       if (key.includes('delete') || key.includes('backspace')) {
         result.riskLevel = ActionRiskLevel.HIGH;
         result.warnings.push('Delete/Backspace key may remove content');
@@ -2154,9 +2201,21 @@ async function executeActions(actionData, onAction = null, onScreenshot = null,
   const results = [];
   let screenshotRequested = false;
   let pendingConfirmation = false;
+  let lastTargetWindowHandle = null;
 
   for (let i = 0; i < actionData.actions.length; i++) {
     const action = actionData.actions[i];
+
+    // Track the intended target window across steps so later key/type actions can
+    // re-focus it. Without this, focus can drift back to the overlay/terminal.
+    if (action.type === 'focus_window' || action.type === 'bring_window_to_front') {
+      try {
+        const hwnd = await systemAutomation.resolveWindowHandle(action);
+        if (hwnd) {
+          lastTargetWindowHandle = hwnd;
+        }
+      } catch {}
+    }
     
     // Handle screenshot requests specially
     if (action.type === 'screenshot') {
@@ -2179,9 +2238,14 @@ async function executeActions(actionData, onAction = null, onScreenshot = null,
     // Analyze safety
     const safety = analyzeActionSafety(action, targetInfo);
     console.log(`[AI-SERVICE] Action ${i} safety: ${safety.riskLevel}`, safety.warnings);
+
+    // CRITICAL actions require an explicit confirmation step, even if the user clicked
+    // the general "Execute" button for a batch. This prevents accidental destructive
+    // shortcuts (e.g., alt+f4) from immediately closing the active app due to focus issues.
+    const canBypassConfirmation = skipSafetyConfirmation && safety.riskLevel !== ActionRiskLevel.CRITICAL;
     
     // If HIGH or CRITICAL risk, require confirmation (unless user already confirmed via Execute button)
-    if (safety.requiresConfirmation && !skipSafetyConfirmation) {
+    if (safety.requiresConfirmation && !canBypassConfirmation) {
       console.log(`[AI-SERVICE] Action ${i} requires user confirmation`);
       
       // Store as pending action
@@ -2204,7 +2268,11 @@ async function executeActions(actionData, onAction = null, onScreenshot = null,
     }
     
     if (skipSafetyConfirmation && safety.requiresConfirmation) {
-      console.log(`[AI-SERVICE] Action ${i} safety bypassed (user pre-confirmed via Execute button)`);
+      if (canBypassConfirmation) {
+        console.log(`[AI-SERVICE] Action ${i} safety bypassed (user pre-confirmed via Execute button)`);
+      } else {
+        console.log(`[AI-SERVICE] Action ${i} requires explicit confirmation (CRITICAL)`);
+      }
     }
 
     // Execute the action (SAFE/LOW/MEDIUM risk)
@@ -2214,6 +2282,7 @@ async function executeActions(actionData, onAction = null, onScreenshot = null,
       if (uiWatcher && uiWatcher.isPolling) {
         const elementAtPoint = uiWatcher.getElementAtPoint(action.x, action.y);
         if (elementAtPoint && elementAtPoint.windowHandle) {
+          lastTargetWindowHandle = elementAtPoint.windowHandle;
           // Found an element with a known window handle
           // Focus it first to ensure click goes to the right window (not trapped by overlay or obscuring window)
           // We can call systemAutomation.focusWindow directly
@@ -2224,11 +2293,35 @@ async function executeActions(actionData, onAction = null, onScreenshot = null,
       }
     }
 
+    // Ensure keyboard input goes to the last known target window.
+    if ((action.type === 'key' || action.type === 'type') && lastTargetWindowHandle) {
+      console.log(`[AI-SERVICE] Re-focusing last target window ${lastTargetWindowHandle} before ${action.type}`);
+      await systemAutomation.focusWindow(lastTargetWindowHandle);
+      await new Promise(r => setTimeout(r, 125));
+    }
+
     const result = await (actionExecutor ? actionExecutor(action) : systemAutomation.executeAction(action));
     result.reason = action.reason || '';
     result.safety = safety;
     results.push(result);
 
+    // If we just performed a step that likely changed focus, snapshot the actual foreground HWND.
+    // This is especially important when uiWatcher isn't polling (can't infer windowHandle).
+    if (typeof systemAutomation.getForegroundWindowHandle === 'function') {
+      if (
+        action.type === 'click' ||
+        action.type === 'double_click' ||
+        action.type === 'right_click' ||
+        action.type === 'focus_window' ||
+        action.type === 'bring_window_to_front'
+      ) {
+        const fg = await systemAutomation.getForegroundWindowHandle();
+        if (fg) {
+          lastTargetWindowHandle = fg;
+        }
+      }
+    }
+
     // Callback for UI updates
     if (onAction) {
       onAction(result, i, actionData.actions.length);
@@ -2270,10 +2363,20 @@ async function resumeAfterConfirmation(onAction = null, onScreenshot = null, opt
   
   const results = [...pending.completedResults];
   let screenshotRequested = false;
+  let lastTargetWindowHandle = null;
   
   // Execute the confirmed action and remaining actions
   for (let i = 0; i < pending.remainingActions.length; i++) {
     const action = pending.remainingActions[i];
+
+    if (action.type === 'focus_window' || action.type === 'bring_window_to_front') {
+      try {
+        const hwnd = await systemAutomation.resolveWindowHandle(action);
+        if (hwnd) {
+          lastTargetWindowHandle = hwnd;
+        }
+      } catch {}
+    }
     
     if (action.type === 'screenshot') {
       screenshotRequested = true;
@@ -2283,12 +2386,45 @@ async function resumeAfterConfirmation(onAction = null, onScreenshot = null, opt
       results.push({ success: true, action: 'screenshot', message: 'Screenshot captured' });
       continue;
     }
+
+    if ((action.type === 'click' || action.type === 'double_click' || action.type === 'right_click') && action.x !== undefined) {
+      if (uiWatcher && uiWatcher.isPolling) {
+        const elementAtPoint = uiWatcher.getElementAtPoint(action.x, action.y);
+        if (elementAtPoint && elementAtPoint.windowHandle) {
+          lastTargetWindowHandle = elementAtPoint.windowHandle;
+          console.log(`[AI-SERVICE] (resume) Auto-focusing window handle ${elementAtPoint.windowHandle} for click at (${action.x}, ${action.y})`);
+          await systemAutomation.focusWindow(elementAtPoint.windowHandle);
+          await new Promise(r => setTimeout(r, 450));
+        }
+      }
+    }
+
+    if ((action.type === 'key' || action.type === 'type') && lastTargetWindowHandle) {
+      console.log(`[AI-SERVICE] (resume) Re-focusing last target window ${lastTargetWindowHandle} before ${action.type}`);
+      await systemAutomation.focusWindow(lastTargetWindowHandle);
+      await new Promise(r => setTimeout(r, 125));
+    }
     
     // Execute action (user confirmed, skip safety for first action)
     const result = await (actionExecutor ? actionExecutor(action) : systemAutomation.executeAction(action));
     result.reason = action.reason || '';
     result.userConfirmed = i === 0; // First one was confirmed
     results.push(result);
+
+    if (typeof systemAutomation.getForegroundWindowHandle === 'function') {
+      if (
+        action.type === 'click' ||
+        action.type === 'double_click' ||
+        action.type === 'right_click' ||
+        action.type === 'focus_window' ||
+        action.type === 'bring_window_to_front'
+      ) {
+        const fg = await systemAutomation.getForegroundWindowHandle();
+        if (fg) {
+          lastTargetWindowHandle = fg;
+        }
+      }
+    }
     
     if (onAction) {
       onAction(result, pending.actionIndex + i, pending.actionIndex + pending.remainingActions.length);

package/src/main/index.js

@@ -1,3 +1,65 @@
+function isBrokenPipeLikeError(err) {
+  const code = err && err.code;
+  return (
+    code === 'EPIPE' ||
+    code === 'ERR_STREAM_DESTROYED' ||
+    code === 'ERR_STREAM_WRITE_AFTER_END'
+  );
+}
+
+function patchConsoleForBrokenPipes() {
+  const methods = ['log', 'info', 'warn', 'error'];
+  const originals = {};
+  let stdioDisabled = false;
+
+  for (const method of methods) {
+    originals[method] = typeof console[method] === 'function'
+      ? console[method].bind(console)
+      : () => {};
+
+    console[method] = (...args) => {
+      if (stdioDisabled) return;
+      try {
+        originals[method](...args);
+      } catch (e) {
+        if (isBrokenPipeLikeError(e)) {
+          stdioDisabled = true;
+          return;
+        }
+        throw e;
+      }
+    };
+  }
+
+  const swallowStreamError = (stream) => {
+    if (!stream || typeof stream.on !== 'function') return;
+    stream.on('error', (e) => {
+      if (isBrokenPipeLikeError(e)) {
+        stdioDisabled = true;
+        return;
+      }
+    });
+  };
+
+  swallowStreamError(process.stdout);
+  swallowStreamError(process.stderr);
+}
+
+patchConsoleForBrokenPipes();
+
+process.on('uncaughtException', (err) => {
+  if (isBrokenPipeLikeError(err)) {
+    return;
+  }
+  throw err;
+});
+
+process.on('unhandledRejection', (reason) => {
+  if (isBrokenPipeLikeError(reason)) {
+    return;
+  }
+});
+
 // Ensure Electron runs in app mode even if a dev shell has ELECTRON_RUN_AS_NODE set
 if (process.env.ELECTRON_RUN_AS_NODE) {
   console.warn('ELECTRON_RUN_AS_NODE was set; clearing so the app can start normally.');

package/src/main/system-automation.js

@@ -488,7 +488,24 @@ public class WindowFocus {
 [WindowFocus]::Focus([IntPtr]::new(${hwnd}))
 `;
     await executePowerShell(script);
-    console.log(`[AUTOMATION] Focused window handle: ${hwnd}`);
+
+    // Poll to verify focus actually stuck (SetForegroundWindow can be racy / blocked)
+    let verified = false;
+    for (let attempt = 0; attempt < 10; attempt++) {
+      const fg = await getForegroundWindowHandle();
+      if (fg === hwnd) {
+        verified = true;
+        break;
+      }
+      await sleep(50);
+    }
+
+    if (verified) {
+      console.log(`[AUTOMATION] Focused window handle (verified): ${hwnd}`);
+    } else {
+      const fg = await getForegroundWindowHandle();
+      console.warn(`[AUTOMATION] Focus requested for ${hwnd} but foreground is ${fg}`);
+    }
 }
 
 /**
@@ -1698,6 +1715,29 @@ public class WindowInfo {
   return await executePowerShell(script);
 }
 
+/**
+ * Get current foreground window handle (HWND)
+ */
+async function getForegroundWindowHandle() {
+  const script = `
+Add-Type -TypeDefinition @"
+using System;
+using System.Runtime.InteropServices;
+public class ForegroundHandle {
+  [DllImport("user32.dll")]
+  public static extern IntPtr GetForegroundWindow();
+  public static long GetHandle() {
+    return GetForegroundWindow().ToInt64();
+  }
+}
+"@
+[ForegroundHandle]::GetHandle()
+`;
+  const out = await executePowerShell(script);
+  const num = Number(String(out).trim());
+  return Number.isFinite(num) ? num : null;
+}
+
 /**
  * Execute an action from AI
  * @param {Object} action - Action object from AI
@@ -2109,6 +2149,7 @@ module.exports = {
   drag,
   sleep,
   getActiveWindowTitle,
+  getForegroundWindowHandle,
   resolveWindowHandle,
   minimizeWindow,
   restoreWindow,