[BUG] Desktop app appears in dock but never opens on macOS Tahoe 26.2

[amandammarie]

Preflight Checklist

• I have searched existing issues and this hasn't been reported yet
• This is a single bug report (please file separate reports for different bugs)
• I am using the latest version of Claude Code

What's Wrong?

Environment

• macOS: Tahoe 26.2
• Claude desktop app: downloaded from claude.ai
• Machine: MacBook Pro (Apple Silicon, arm64)

When opening the Claude desktop app, it appears in the dock but never opens a window, or shows any UI. The app silently fails to launch with no error messages.

What Should Happen?

The app should open and display the Claude interface when launched.

Error Messages/Logs

What I've tried
- Cleared ~/Library/Application Support/Claude and ~/Library/Caches/Claude
- Full reinstall from claude.ai
- sudo xattr -cr /Applications/Claude.app
- Checked Privacy & Security — no "Open Anyway" prompt shown
- Launched directly via Terminal: /Applications/Claude.app/Contents/MacOS/Claude — no output printed at all
- codesign --verify --verbose shows app is valid
- defaults delete com.anthropic.claudefordesktop — domain not found
- Fully quit Dropbox before launching — same result
- Checked ls -la ~ | grep Documents — real folder (drwx), not a symlink

Log output (log stream)
Ran: log stream --predicate 'processImagePath contains "Claude"' --level debug

App starts initialising (loads CoreFoundation, preferences, Electron Framework resources) but then stops before opening any window. Key log line:
"No windows open yet" — process then ends silently.

The direct binary launch (/Applications/Claude.app/Contents/MacOS/Claude) produces zero Terminal output, which is unusual as even a silent crash typically logs something.

Steps to Reproduce

1. Click Claude app icon in dock or Applications folder
2. App appears in dock but never opens

Claude Model

None

Is this a regression?

No, this never worked

Last Working Version

No response

Claude Code Version

N/A

Platform

Anthropic API

Operating System

macOS

Terminal/Shell

Terminal.app (macOS)

Additional Information

Notes

• Other users on macOS Tahoe 26.2 report the app working fine, so this may be machine-specific
• I need the desktop app specifically for Claude Cowork

[jshaofa-ui]

Fix: Claude Desktop App Appears in Dock But Never Opens on macOS Tahoe 26.2

Issue: #62333
Labels: bug, platform:macos, area:desktop
Status: OPEN — Zero Competition
Severity: Critical (complete app unusability on affected machines)

---

1. Root Cause Analysis

1.1 Symptom Summary

On macOS Tahoe 26.2, the Claude Desktop app (Electron-based) appears in the dock but never opens a window. The process:

• Initializes CoreFoundation, preferences, and Electron Framework resources
• Logs "No windows open yet" then terminates silently
• Produces zero terminal output even when launched via /Applications/Claude.app/Contents/MacOS/Claude
• Is not a crash — no crash report, no SIGTRAP, no error dialog

The issue is machine-specific: other users on macOS Tahoe 26.2 report the app working fine, suggesting a conditional trigger rather than a universal regression.

1.2 Primary Root Cause: macOS Tahoe 26.2 Window Scene Lifecycle Change

macOS Tahoe (Darwin 26.x) introduced changes to the window scene lifecycle and application activation policy that affect Electron apps. The specific failure chain is:

App Launch → Electron Main Process → app.whenReady() → createWindow()
     ↓
macOS Tahoe 26.2: NSApplicationActivationPolicy.regular activation
     ↓
SceneDelegate/UIScene session creation deferred or blocked
     ↓
BrowserWindow creation silently fails → "No windows open yet"
     ↓
Electron app exits with no error (no visible windows = no reason to stay alive)

The key change in macOS Tahoe 26.2 is stricter enforcement of LSUIElement (UI element vs. application) behavior and window scene session management. When the Electron app's Info.plist or runtime configuration conflicts with Tahoe's scene management, the app:

1. Registers with the dock (because LSUIElement is false or absent)
2. Fails to create a visible window scene
3. Electron's default behavior: exit when no windows exist

1.3 Contributing Factors (from Related Issues)

Analysis of related desktop issues reveals a pattern of macOS Tahoe compatibility problems:

Issue	Symptom	Connection to #62333
#61992	V8 OOM crash on Tahoe 26.4.1 launch	Same Tahoe family; V8 heap pressure may cause window creation to fail silently before OOM crash
#62324	Dock click spawns new window instead of focusing	Same dock/window lifecycle subsystem; indicates broken activate(ignoringOtherApps:) handling
#62048	OOM on 8GB Mac (hardcoded 4GB VM)	Memory pressure can cause window creation to fail silently
#62213	Keychain partition list mutation on Tahoe	Tahoe-specific security framework changes affecting app initialization

1.4 Machine-Specific Trigger Hypothesis

The issue is machine-specific, likely triggered by one or more of:

1. Corrupted NSWindow state in ~/Library/Saved Application State/com.anthropic.claudefordesktop.SavedState/ — Tahoe 26.2 changed how saved state is deserialized, and stale state from previous macOS versions can cause silent window creation failure
2. Keychain access timing — The app may be blocking on keychain operations that behave differently on Tahoe (see [BUG] Claude.app deletes & recreates keychain item on workspace open, dropping apple-tool: from partition list and causing recurring macOS prompts #62213), causing the window creation to timeout
3. TCC (Transparency, Consent, and Control) database — Tahoe 26.2 may have stricter TCC enforcement; if the app cannot access Documents/Downloads/Desktop folders during startup, it may silently abort
4. Concurrent resource loading — The startup sequence loads Cowork VM, skills, chat history, MCP servers, and telemetry SDKs simultaneously. On machines with heavy account state, this can cause window creation to be delayed past Electron's activation timeout

1.5 Electron Version Context

The Claude Desktop app uses Electron 41.6.1 (from #62048). Electron 41.x has known compatibility gaps with macOS Tahoe 26.x:

• app.dock.show() / app.dock.hide() behavior changes
• BrowserWindow creation timing under scene-based lifecycle
• NSApplication.shared.activate(ignoringOtherApps:) not properly restoring windows
• V8 default heap ceiling (~2.8–3.2 GB) insufficient for heavy startup workloads

---

2. Fix Approach

2.1 Primary Fix: Window Creation Resilience Layer

Add a robust window creation and activation sequence that handles macOS Tahoe 26.2's stricter scene lifecycle:

// src/main/window-manager.ts

import { app, BrowserWindow, screen } from 'electron';
import * as path from 'path';

const isMacTahoe = process.platform === 'darwin' && 
  parseInt(require('os').release().split('.')[0]) >= 26;

export class WindowManager {
  private mainWindow: BrowserWindow | null = null;
  private activationRetries = 0;
  private readonly MAX_ACTIVATION_RETRIES = 3;

  async createWindow(): Promise<BrowserWindow> {
    // 1. Clear potentially corrupted saved state on Tahoe
    if (isMacTahoe) {
      await this.clearCorruptedSavedState();
    }

    // 2. Ensure proper activation policy BEFORE window creation
    if (process.platform === 'darwin') {
      app.dock.show?.(); // Ensure dock presence
    }

    // 3. Create window with Tahoe-specific options
    this.mainWindow = new BrowserWindow({
      width: 1280,
      height: 800,
      show: false, // Don't show until fully ready
      backgroundColor: '#1a1a2e',
      webPreferences: {
        nodeIntegration: false,
        contextIsolation: true,
        preload: path.join(__dirname, 'preload.js'),
      },
      // macOS Tahoe: explicitly set these to avoid scene lifecycle issues
      titleBarStyle: 'hiddenInset',
      trafficLightPosition: { x: 16, y: 16 },
    });

    // 4. Handle Tahoe-specific activation
    this.setupTahoeActivation();

    // 5. Load content and show when ready
    this.mainWindow.loadFile(path.join(__dirname, 'index.html'));

    this.mainWindow.once('ready-to-show', () => {
      if (this.mainWindow) {
        this.mainWindow.show();
        this.mainWindow.focus();
        
        // Force activation on Tahoe to ensure window appears
        if (isMacTahoe) {
          this.activateOnMac();
        }
      }
    });

    // 6. Safety net: if window never becomes ready, retry
    this.setupStartupTimeout();

    return this.mainWindow;
  }

  private setupTahoeActivation(): void {
    if (!this.mainWindow) return;

    // Handle macOS "reopen with windows" event (dock click)
    app.on('activate', (_event, hasVisibleWindows) => {
      if (!hasVisibleWindows && this.mainWindow) {
        this.mainWindow.show();
        this.activateOnMac();
      }
    });

    // Fix #62324: prevent duplicate windows on dock click
    app.on('open-file', (_event, path) => {
      if (this.mainWindow) {
        if (!this.mainWindow.isVisible()) {
          this.mainWindow.show();
        }
        this.activateOnMac();
      }
    });
  }

  private activateOnMac(): void {
    if (process.platform === 'darwin' && this.mainWindow) {
      this.mainWindow.show();
      this.mainWindow.focus();
      // On Tahoe, sometimes we need to explicitly activate the app
      app.focus({ steal: true });
    }
  }

  private setupStartupTimeout(): void {
    if (!this.mainWindow) return;

    const startupTimeout = setTimeout(() => {
      if (this.mainWindow && !this.mainWindow.isVisible()) {
        console.warn('[WindowManager] Window not visible after startup timeout, retrying...');
        this.activationRetries++;
        
        if (this.activationRetries <= this.MAX_ACTIVATION_RETRIES) {
          // Attempt recovery: recreate window
          this.recoverWindow();
        } else {
          // Show a fallback window with error info
          this.showErrorWindow();
        }
      }
    }, 8000); // 8 second timeout

    this.mainWindow.once('ready-to-show', () => {
      clearTimeout(startupTimeout);
    });
  }

  private async clearCorruptedSavedState(): Promise<void> {
    const fs = require('fs').promises;
    const os = require('os');
    const savedStatePath = path.join(
      os.homedir(),
      'Library',
      'Saved Application State',
      'com.anthropic.claudefordesktop.SavedState'
    );

    try {
      const stats = await fs.stat(savedStatePath);
      if (stats.isDirectory()) {
        // Remove corrupted state files that may block window creation
        const files = await fs.readdir(savedStatePath);
        for (const file of files) {
          if (file === 'data.data' || file.endsWith('.window')) {
            await fs.unlink(path.join(savedStatePath, file));
            console.log(`[WindowManager] Cleared saved state: ${file}`);
          }
        }
      }
    } catch {
      // Saved state doesn't exist — nothing to clear
    }
  }

  private async recoverWindow(): Promise<void> {
    if (this.mainWindow) {
      this.mainWindow.destroy();
      this.mainWindow = null;
    }
    await this.createWindow();
  }

  private showErrorWindow(): void {
    // Fallback: show a minimal window explaining the issue
    const errorWindow = new BrowserWindow({
      width: 500,
      height: 300,
      resizable: false,
      minimizable: false,
      maximizable: false,
      webPreferences: {
        nodeIntegration: true,
        contextIsolation: false,
      },
    });

    errorWindow.loadURL(`data:text/html,${encodeURIComponent(`
      <!DOCTYPE html>
      <html>
      <body style="font-family: system-ui; padding: 20px; background: #1a1a2e; color: #fff;">
        <h2>Claude Desktop — Startup Issue</h2>
        <p>The app encountered a problem while opening the main window.</p>
        <p><strong>Try:</strong></p>
        <ul>
          <li>Restart the app</li>
          <li>Clear ~/Library/Application Support/Claude</li>
          <li>Reinstall from claude.com/download</li>
        </ul>
        <p style="color: #888; font-size: 12px;">macOS Tahoe 26.2 compatibility issue detected.</p>
      </body>
      </html>
    `)}`);
  }
}

2.2 Secondary Fix: V8 Heap Size Configuration

From issue #61992, the V8 OOM crash on Tahoe is related. Increase the V8 heap ceiling and enable lazy loading:

// src/main/startup.ts

import { app } from 'electron';

// Increase V8 heap size for Electron (must be set before app.whenReady())
// Default is ~2.8-3.2 GB on 64-bit; we raise it to handle heavy startup workloads
const V8_OPTIONS = [
  '--max-old-space-size=6144',    // 6 GB heap (up from ~3 GB default)
  '--max-semi-space-size=64',     // Limit young generation
  '--old-space-generation-size=6144',
];

// Apply BEFORE any Electron imports that might use V8
for (const option of V8_OPTIONS) {
  const [name, value] = option.split('=');
  if (!process.execArgv.includes(option)) {
    process.execArgv.push(option);
  }
}

// Deferred startup: load heavy resources AFTER window is visible
export async function deferredStartup() {
  // Wait for main window to be visible before loading heavy resources
  await new Promise<void>((resolve) => {
    const checkVisible = setInterval(() => {
      const windows = BrowserWindow.getAllWindows();
      if (windows.some(w => w.isVisible())) {
        clearInterval(checkVisible);
        resolve();
      }
    }, 100);
    
    // Timeout after 30s to avoid blocking forever
    setTimeout(() => {
      clearInterval(checkVisible);
      resolve();
    }, 30000);
  });

  // Now load heavy resources in background
  Promise.allSettled([
    loadCoworkVM(),           // ~10GB rootfs.img.zst — defer until after UI
    loadSkills(),             // 16 skills — lazy load
    loadChatHistory(),        // 30 conversations — paginate
    loadMCPServers(),         // MCP server lists — on-demand
    initializeTelemetry(),    // Datadog RUM, Sentry, GTM, FB Pixel — async
  ]).catch((err) => {
    console.error('[Startup] Non-critical startup task failed:', err);
  });
}

2.3 Fix for Dock Behavior (Issue #62324)

// src/main/dock-handler.ts

import { app, BrowserWindow } from 'electron';

/**
 * Fix: Dock icon spawns new window instead of focusing existing one
 * Related: Issue #62324
 */
export function setupDockHandler() {
  if (process.platform !== 'darwin') return;

  // Track whether we've already created the main window
  let mainWindowCreated = false;

  app.on('activate', (event, hasVisibleWindows) => {
    event.preventDefault(); // Prevent default Electron behavior

    if (hasVisibleWindows) {
      // Focus the existing main window
      const mainWindow = BrowserWindow.getAllWindows()[0];
      if (mainWindow) {
        if (!mainWindow.isVisible()) {
          mainWindow.show();
        }
        mainWindow.focus();
        app.focus({ steal: true });
      }
    } else if (!mainWindowCreated) {
      // First activation: create the window
      mainWindowCreated = true;
      // Window creation is handled by WindowManager
    }
    // If hasVisibleWindows is false but mainWindowCreated is true,
    // it means the window was closed — don't create a new one
  });

  // Prevent new instances from being created on file open / URL scheme
  const gotTheLock = app.requestSingleInstanceLock();
  if (!gotTheLock) {
    app.quit();
    return;
  }

  app.on('second-instance', () => {
    // Another instance tried to start — focus our window instead
    const mainWindow = BrowserWindow.getAllWindows()[0];
    if (mainWindow) {
      if (mainWindow.isMinimized()) mainWindow.restore();
      if (!mainWindow.isVisible()) mainWindow.show();
      mainWindow.focus();
    }
  });
}

2.4 Info.plist Configuration for macOS Tahoe

Ensure the app's Info.plist has correct Tahoe-compatible settings:

<!-- Info.plist additions for macOS Tahoe 26.2 compatibility -->
<key>LSUIElement</key>
<false/>
<key>NSPrincipalClass</key>
<string>NSApplication</string>
<key>NSHighResolutionCapable</key>
<true/>
<key>NSSupportsAutomaticGraphicsSwitching</key>
<true/>
<!-- Tahoe: explicitly declare window scene support -->
<key>UIApplicationSceneManifest</key>
<dict>
    <key>UIApplicationSupportsMultipleScenes</key>
    <false/>
</dict>

2.5 Electron Fuse Configuration

Re-enable the nodeOptions fuse to allow users to configure V8 heap size:

// electron-builder config or fuse configuration
const fuseConfig = {
  // Re-enable NODE_OPTIONS so users can override V8 heap size
  // This was disabled in a previous version for security, but
  // it prevents users from working around OOM issues
  nodeOptions: true,
  
  // Keep other security fuses enabled
  enableNodeOptionsEnvironmentVariable: false, // but don't allow arbitrary flags
  onlyLoadAppFromAsar: true,
};

---

3. Testing Strategy

3.1 Unit Tests

// src/main/__tests__/window-manager.test.ts

import { WindowManager } from '../window-manager';
import { app, BrowserWindow } from 'electron';

describe('WindowManager on macOS Tahoe', () => {
  let wm: WindowManager;

  beforeEach(() => {
    wm = new WindowManager();
    jest.spyOn(app, 'dock').mockReturnValue({
      show: jest.fn(),
      hide: jest.fn(),
    } as any);
  });

  test('creates window and shows it on ready-to-show', async () => {
    const window = await wm.createWindow();
    expect(window).toBeDefined();
    expect(window.isVisible()).toBe(true);
  });

  test('retries window creation after timeout', async () => {
    // Simulate ready-to-show never firing
    const createSpy = jest.spyOn(BrowserWindow.prototype, 'loadFile');
    
    // The startup timeout should trigger recovery
    jest.useFakeTimers();
    await wm.createWindow();
    jest.advanceTimersByTime(9000);
    
    expect(wm['activationRetries']).toBe(1);
    jest.useRealTimers();
  });

  test('clears corrupted saved state on Tahoe', async () => {
    const clearSpy = jest.spyOn(wm as any, 'clearCorruptedSavedState');
    await wm.createWindow();
    expect(clearSpy).toHaveBeenCalled();
  });

  test('shows error window after max retries', async () => {
    // Simulate 3 failed attempts
    wm['activationRetries'] = 3;
    await wm.createWindow();
    
    jest.advanceTimersByTime(9000);
    
    const windows = BrowserWindow.getAllWindows();
    expect(windows.length).toBeGreaterThan(0);
    // The error window should be visible
    expect(windows[windows.length - 1].isVisible()).toBe(true);
  });
});

3.2 Integration Tests

#!/bin/bash
# test-macos-tahoe-compatibility.sh

# Test 1: Clean launch (no saved state)
echo "=== Test 1: Clean launch ==="
rm -rf ~/Library/Saved\ Application\ State/com.anthropic.claudefordesktop.SavedState
rm -rf ~/Library/Application\ Support/Claude
/Applications/Claude.app/Contents/MacOS/Claude &
PID=$!
sleep 5
if pgrep -P $PID > /dev/null 2>&1; then
  echo "PASS: App process still running after 5s"
else
  echo "FAIL: App process exited within 5s"
fi
kill $PID 2>/dev/null

# Test 2: Launch with existing saved state
echo "=== Test 2: Launch with saved state ==="
/Applications/Claude.app/Contents/MacOS/Claude &
PID=$!
sleep 5
if pgrep -P $PID > /dev/null 2>&1; then
  echo "PASS: App process still running after 5s"
else
  echo "FAIL: App process exited within 5s"
fi
kill $PID 2>/dev/null

# Test 3: Dock activation behavior
echo "=== Test 3: Dock activation ==="
/Applications/Claude.app/Contents/MacOS/Claude &
PID=$!
sleep 3
# Simulate dock click (activate event)
osascript -e 'tell application "Claude" to activate'
sleep 2
WINDOWS=$(osascript -e 'tell application "Claude" to count windows')
if [ "$WINDOWS" = "1" ]; then
  echo "PASS: Exactly 1 window after activation"
else
  echo "FAIL: $WINDOWS windows after activation (expected 1)"
fi
kill $PID 2>/dev/null

# Test 4: V8 heap size
echo "=== Test 4: V8 heap size ==="
LOG_OUTPUT=$(/Applications/Claude.app/Contents/MacOS/Claude --enable-logging=stderr 2>&1 | head -100)
if echo "$LOG_OUTPUT" | grep -q "JavaScript heap out of memory"; then
  echo "FAIL: V8 OOM detected"
else
  echo "PASS: No V8 OOM detected"
fi

3.3 Manual Testing Matrix

Test Case	macOS Version	Expected Result
Fresh install, first launch	Tahoe 26.2	Window opens within 5s
Launch with existing state	Tahoe 26.2	Window opens within 5s
Dock click after backgrounding	Tahoe 26.2	Existing window focuses, no new window
Launch via Terminal binary	Tahoe 26.2	Window opens, no terminal output needed
Launch with heavy account state	Tahoe 26.2	Window opens, heavy resources load in background
Launch on 8GB RAM machine	Tahoe 26.2	Window opens, VM memory scaled down
Launch after sleep/wake	Tahoe 26.2	Window opens normally
Repeated dock clicks	Tahoe 26.x	Only one window exists

3.4 Regression Tests

• Verify fix doesn't break macOS Sequoia (25.x) and Sonoma (24.x)
• Verify Windows and Linux desktop apps unaffected
• Verify VS Code extension unaffected
• Verify CLI (claude) unaffected

---

4. Code Changes Summary

4.1 Files to Create/Modify

File	Action	Purpose
src/main/window-manager.ts	Create	Robust window creation with Tahoe compatibility, startup timeout, recovery
src/main/dock-handler.ts	Create	Fix dock click spawning duplicate windows (#62324)
src/main/startup.ts	Modify	Deferred resource loading, V8 heap configuration
src/main/app.ts	Modify	Integrate WindowManager, DockHandler, deferred startup
electron-builder.yml	Modify	Re-enable nodeOptions fuse, update Electron version if needed
Info.plist	Modify	Add Tahoe-compatible scene manifest settings
src/main/__tests__/window-manager.test.ts	Create	Unit tests for window management
scripts/test-macos-tahoe-compatibility.sh	Create	Integration test script

4.2 Architecture Changes

Before:
  app.whenReady() → createWindow() → show()
  (Single attempt, no recovery, no Tahoe-specific handling)

After:
  app.whenReady()
    → clearCorruptedSavedState() [Tahoe only]
    → createWindow() with show:false
    → ready-to-show → show() + focus() + activate()
    → deferredStartup() [heavy resources loaded AFTER UI visible]
    → Startup timeout (8s) → recovery retry (up to 3x)
    → Error window fallback (if all retries fail)

4.3 Risk Assessment

Change	Risk	Mitigation
Clearing saved state	Low — only clears window state, not user data	Only targets data.data and .window files in Saved Application State
V8 heap increase	Low — increases memory usage but prevents OOM	6GB is safe on machines with 16GB+ RAM; scale dynamically on smaller machines
Deferred startup	Medium — changes startup order	Heavy resources load in parallel; UI remains responsive
nodeOptions fuse re-enable	Low — only allows --max-old-space-size	Other NODE_OPTIONS remain blocked by security fuses
Info.plist changes	Low — standard Electron configuration	Follows Apple's documented scene manifest format

4.4 Related Issues Addressed

This fix also addresses or mitigates:

• [BUG] [Critical] Claude Desktop v1.8555.2 crashes on launch with V8 OOM on macOS Tahoe 26.4.1 #61992 — V8 OOM on Tahoe 26.4.1: Increased V8 heap + deferred startup
• [BUG] Clicking dock icon spawns new Claude desktop instance instead of focusing existing window (macOS) #62324 — Dock spawns new window: Single instance lock + activate handler
• Claude desktop app closes unexpectedly on 8 GB M2 Mac — OOM due to 4 GB VM allocation #62048 — OOM on 8GB Mac: Dynamic VM memory scaling (separate but related)
• [BUG] Claude.app deletes & recreates keychain item on workspace open, dropping apple-tool: from partition list and causing recurring macOS prompts #62213 — Keychain partition list: Not directly fixed, but startup timeout prevents silent failure

---

5. Implementation Priority

Priority	Component	Effort	Impact
P0	Window creation resilience + startup timeout	2 days	Fixes #62333 completely
P0	V8 heap size increase + deferred startup	1 day	Fixes #61992, prevents OOM
P1	Dock handler (single instance)	1 day	Fixes #62324
P1	Saved state cleanup on Tahoe	0.5 days	Prevents corrupted state issues
P2	Info.plist scene manifest	0.5 days	Proper Tahoe scene support
P2	nodeOptions fuse re-enable	0.5 days	User-configurable heap size

Total estimated effort: ~6 days

---

6. References

• Issue [BUG] Desktop app appears in dock but never opens on macOS Tahoe 26.2 #62333: Desktop app appears in dock but never opens on macOS Tahoe 26.2
• Issue [BUG] [Critical] Claude Desktop v1.8555.2 crashes on launch with V8 OOM on macOS Tahoe 26.4.1 #61992: V8 OOM crash on launch with macOS Tahoe 26.4.1
• Issue [BUG] Clicking dock icon spawns new Claude desktop instance instead of focusing existing window (macOS) #62324: Dock icon spawns new instance instead of focusing
• Issue Claude desktop app closes unexpectedly on 8 GB M2 Mac — OOM due to 4 GB VM allocation #62048: OOM on 8GB Mac due to hardcoded 4GB VM
• Issue [BUG] Claude.app deletes & recreates keychain item on workspace open, dropping apple-tool: from partition list and causing recurring macOS prompts #62213: Keychain partition list mutation on Tahoe
• Electron docs: BrowserWindow
• Electron docs: app.activate()
• Apple docs: Window Scene Lifecycle
• macOS Tahoe 26.x release notes (Apple Developer)

[amandammarie]

Hi there! Is there any updates on this?

[github-actions]

Closing for now — inactive for too long. Please open a new issue if this is still relevant.