[BUG] Auto-approve settings not synchronized across multiple VS Code windows

[gentzhu]

Problem Description

When using Roo Code with multiple VS Code windows open simultaneously, the auto-approve settings configured in the first window are not properly applied to subsequent windows. Even though auto-approve is enabled in Window A, Window B still prompts for approval on every action.

Environment

• VS Code Version: (please fill in)
• Roo Code Version: (please fill in)
• Operating System: Windows/Linux/macOS (please specify)
• Reproducibility: Always

Steps to Reproduce

1. Open VS Code Window A and enable auto-approve (select permissions like "Read files", "Edit files", etc., and toggle "Enabled" on)
2. Open a second VS Code Window B (File → New Window)
3. Open a different project folder in Window B
4. Start a Roo Code task in Window B that requires file operations or command execution
5. Observe that Roo Code prompts for approval on every action, despite auto-approve being enabled globally

Expected Behavior

Auto-approve settings should be synchronized across all VS Code windows, or at least persist correctly when opening new windows.

Actual Behavior

The second window ignores auto-approve settings and prompts for manual approval on every action, significantly disrupting the workflow.

Related Issues

This may be related to:

• Issue: Multi - Window Mode Interference in RooCode (VS Code Extension) #5605 - Multi-Window Mode Interference
• Auto-approve does not apply, sometimes #5502 - Auto-approve does not apply, sometimes

Additional Context

• The auto-approve toggle in the UI appears to be "Enabled" in both windows
• This issue occurs consistently when working with multiple projects simultaneously
• As a workaround, users have to manually toggle auto-approve off and on in each new window

Possible Root Cause

The extension state (specifically auto-approval configuration) may be stored per-extension-host rather than globally, causing desynchronization between VS Code windows which run separate Extension Host processes.

[roomote-v0]

I've analyzed this issue and here's my proposed implementation plan:

Root Cause

Each VS Code window runs a separate extension host process, each with its own ContextProxy singleton. ContextProxy caches all globalState keys in an in-memory stateCache at initialization time (initialize() in ContextProxy.ts). While VS Code's globalState is shared across windows (backed by SQLite), the in-memory cache is never refreshed after initialization.

When Window A toggles auto-approve settings, it:

1. Updates its own stateCache
2. Writes to globalState (shared storage)

Window B's ContextProxy still has its stale stateCache from initialization, so getState() -> getValues() returns the old auto-approve values.

Proposed Fix

1. Add refreshGlobalState() method to ContextProxy (src/core/config/ContextProxy.ts)

Similar to the existing refreshSecrets() method, add a method that re-reads all global state keys from the underlying globalState store into the stateCache:

async refreshGlobalState(): Promise<void> {
    for (const key of GLOBAL_STATE_KEYS) {
        if (isPassThroughStateKey(key)) continue
        try {
            this.stateCache[key] = this.originalContext.globalState.get(key)
        } catch (error) {
            logger.error(`Error refreshing global state ${key}: ${error instanceof Error ? error.message : String(error)}`)
        }
    }
}

2. Call refreshGlobalState() when the window gains focus/visibility (src/core/webview/ClineProvider.ts)

In resolveWebviewView(), the visibility change handlers already fire when a window becomes visible. Update these handlers (around lines 909-925) to refresh the state cache and post updated state to the webview:

// For WebviewPanel (tab mode)
const viewStateDisposable = webviewView.onDidChangeViewState(async () => {
    if (this.view?.visible) {
        await this.contextProxy.refreshGlobalState()
        this.postMessageToWebview({ type: "action", action: "didBecomeVisible" })
        await this.postStateToWebview()
    }
})

// For WebviewView (sidebar mode)  
const visibilityDisposable = webviewView.onDidChangeVisibility(async () => {
    if (this.view?.visible) {
        await this.contextProxy.refreshGlobalState()
        this.postMessageToWebview({ type: "action", action: "didBecomeVisible" })
        await this.postStateToWebview()
    }
})

3. Add tests

• Unit test for ContextProxy.refreshGlobalState() verifying the cache gets updated from the backing store
• Integration-style test verifying the visibility handler triggers a state refresh

Why This Approach

• Minimal surface area: only adds one method and modifies two existing handlers
• Follows existing patterns: mirrors the existing refreshSecrets() method
• No performance concern: globalState.get() reads from local SQLite, not network
• Covers the exact scenario: when a user switches between windows, the now-visible window refreshes its cache
• Does not require polling or cross-process messaging

Please mention @roomote in a comment saying that you approve this plan, and I'll proceed with the implementation.