@@ -17,6 +17,6 @@ The message-port interceptor follows the pinned VS Code implementation. Check it
 
 A gray sidebar can persist after renderer termination even when the watchdog assigns fresh HTML. HTML delivery alone cannot restart a dead renderer. Recovery now waits ten seconds for a heartbeat after assigning HTML, then recreates the affected host if the renderer has not responded. Sidebar recovery uses the generated view-removal and focus commands after checking their availability; tab recovery replaces its panel while retaining its provider. The crash test covers the real sidebar path. Unit tests cover tab replacement and task ownership.
 
-A recovery attempt includes HTML-generation errors. Three attempts exhaust the budget; a startup heartbeat alone does not reset it. Periodic heartbeats must span a 60-second healthy window to replenish the budget. Exhaustion or unavailable/failed scoped host recovery logs once and offers a non-modal Reload Window or Show Logs action. A sidebar replacement that arrives after the ten-second wait retains the incident budget and displayed task. Only sustained healthy heartbeats replenish that budget. Window reload is never automatic. A late action from an old notification is ignored after liveness returns.
+A recovery attempt includes HTML-generation errors. Three attempts exhaust the budget; a startup heartbeat alone does not reset it. Periodic heartbeats must span a 60-second healthy window to replenish the budget. Exhaustion or unavailable/failed scoped host recovery logs once and offers a non-modal Reload Window or Show Logs action. A sidebar replacement that arrives after the ten-second wait retains the incident budget and displayed task. A failed sidebar focus command clears the pending marker so a later manual open starts normally. A tab that fails initialization after publication keeps its task and a watchdog for bounded retries. Only sustained healthy heartbeats replenish the incident budget. Window reload is never automatic. A late action from an old notification is ignored after liveness returns.
 
 Keep exact timing boundaries, individual post-await guards, and reload-budget assertions in provider unit tests. Exercise OS minimize and sleep/resume behavior manually; the Electron scenarios do not reproduce OS suspension or its scheduling order.
@@ -3744,7 +3744,7 @@ export class ClineProvider
 		if (this.webviewHostRecoveryInProgress || this._disposed || this.view !== view || !view.visible) return
 		const revision = this.webviewHeartbeatRevision
 		let started = false
-		let sidebarRemoved = false
+		let sidebarFocused = false
 		try {
 			let commands: string[] | undefined
 			if (!("onDidChangeViewState" in view)) {
@@ -3783,13 +3783,24 @@ export class ClineProvider
 				const resolved = this.resolveWebviewView(replacement)
 				if (this.view === replacement) view.dispose()
 				else replacement.dispose()
-				await resolved
+				try {
+					await resolved
+				} catch (error) {
+					// A published panel already owns this provider and its task.
+					// Keep its disposal subscription, and restore the watchdog even
+					// if HTML generation or state hydration failed before installation.
+					// The next stale tick uses the existing bounded recovery budget.
+					if (this.view === view) throw error
+					if (this._disposed || this.view !== replacement) return
+					this.log(`[Zoo Code] Failed to initialize replacement tab: ${String(error)}`)
+					this.startWebviewWatchdog()
+				}
 			} else {
 				this.pendingSidebarRecovery = true
 				await vscode.commands.executeCommand(`${ClineProvider.sideBarId}.removeView`)
-				sidebarRemoved = true
 				if (this._disposed) return
 				await vscode.commands.executeCommand(`${ClineProvider.sideBarId}.focus`, { preserveFocus: true })
+				sidebarFocused = true
 				await pWaitFor(
 					() =>
 						this._disposed ||
@@ -3801,9 +3812,9 @@ export class ClineProvider
 				)
 			}
 		} catch (error) {
-			// If removal failed, no replacement is expected. A removed sidebar
-			// can still resolve after the wait expires and must retain its task.
-			if (started && !sidebarRemoved) this.pendingSidebarRecovery = false
+			// Only a successful focus can leave a delayed replacement pending.
+			// Command failures must not mark a later manual open as recovery.
+			if (started && !sidebarFocused) this.pendingSidebarRecovery = false
 			// A late discovery failure must not stop a recovered/replaced view.
 			// Once recreation starts, disposal of the old view is expected.
 			if (
 
@@ -1511,6 +1511,36 @@ describe("ClineProvider", () => {
 			},
 		)
 
+		test("clears a failed focus incident before a manual sidebar open", async () => {
+			await provider.resolveWebviewView(mockWebviewView)
+			const task = new Task(defaultTaskOptions)
+			task.abort = true
+			provider["taskRegistry"].push(task)
+			const remove = vi.spyOn(provider, "removeClineFromStack")
+			vi.mocked(vscode.commands.executeCommand).mockImplementation(async (command) => {
+				if (command === `${ClineProvider.sideBarId}.removeView`) disposeCallback()
+				if (command === `${ClineProvider.sideBarId}.focus`) throw new Error("focus failed")
+			})
+
+			await vi.advanceTimersByTimeAsync(130_000)
+
+			expect(provider["view"]).toBeUndefined()
+			expect(provider["pendingSidebarRecovery"]).toBe(false)
+			expect(provider["webviewHostRecoveryInProgress"]).toBe(false)
+			expect(provider["webviewRecoveryAttempts"]).toBe(3)
+			expect(vscode.window.showWarningMessage).toHaveBeenCalledTimes(1)
+			expect(remove).not.toHaveBeenCalled()
+
+			const manualView = { ...mockWebviewView, webview: { ...mockWebviewView.webview, html: "" } }
+			await provider.resolveWebviewView(manualView)
+
+			expect(provider["view"]).toBe(manualView)
+			expect(provider["webviewRecoveryAttempts"]).toBe(0)
+			expect(provider["webviewRecoveryFailureReported"]).toBe(false)
+			expect(remove).toHaveBeenCalledTimes(1)
+			expect(provider.getCurrentTask()).toBeUndefined()
+		})
+
 		test.each(["Reload Window", "Show Logs"] as const)(
 			"runs only the selected recovery action: %s",
 			async (action) => {
@@ -2366,6 +2396,120 @@ describe("ClineProvider", () => {
 				expect(vscode.window.showWarningMessage).toHaveBeenCalledTimes(1)
 			})
 
+			function replacementPanel() {
+				return {
+					...mockWebviewPanel,
+					webview: {
+						...mockWebviewPanel.webview,
+						html: "",
+						onDidReceiveMessage: vi.fn(() => ({ dispose: vi.fn() })),
+					},
+					onDidDispose: vi.fn(() => ({ dispose: vi.fn() })),
+					dispose: vi.fn(),
+				}
+			}
+
+			test.each(["HTML generation", "state hydration"] as const)(
+				"retries a published tab after failed %s without disposing its interrupted task",
+				async (stage) => {
+					await provider.resolveWebviewView(mockWebviewPanel)
+					const task = new Task(defaultTaskOptions)
+					task.abort = true
+					provider["taskRegistry"].push(task)
+					const remove = vi.spyOn(provider, "removeClineFromStack")
+					provider["getWebviewHtml"] = vi.fn().mockResolvedValue("recovered-html")
+					await provider["reloadWebviewForRecovery"]()
+					const failed = replacementPanel()
+					const healthy = replacementPanel()
+					vi.mocked(vscode.window.createWebviewPanel).mockReturnValueOnce(failed).mockReturnValue(healthy)
+					if (stage === "HTML generation") {
+						vi.mocked(provider["getWebviewHtml"]).mockRejectedValueOnce(new Error("HTML failed"))
+					} else {
+						vi.spyOn(provider, "getState").mockRejectedValueOnce(new Error("hydration failed"))
+					}
+					await vi.advanceTimersByTimeAsync(10_000)
+
+					expect(provider["view"]).toBe(failed)
+					expect(failed.webview.onDidReceiveMessage).not.toHaveBeenCalled()
+					expect(failed.dispose).not.toHaveBeenCalled()
+					expect(provider["webviewWatchdogInterval"]).not.toBeNull()
+					expect(provider["webviewHostRecoveryInProgress"]).toBe(false)
+					expect(provider["webviewRecoveryAttempts"]).toBe(1)
+					expect(vscode.window.showWarningMessage).not.toHaveBeenCalled()
+					expect(mockOutputChannel.appendLine).toHaveBeenCalledWith(
+						expect.stringContaining("Failed to initialize replacement tab"),
+					)
+
+					await vi.advanceTimersByTimeAsync(130_000)
+
+					expect(vscode.window.createWebviewPanel).toHaveBeenCalledTimes(2)
+					expect(provider["view"]).toBe(healthy)
+					// The provider and focus tracker each install one message listener.
+					expect(healthy.webview.onDidReceiveMessage).toHaveBeenCalledTimes(2)
+					expect(failed.dispose).toHaveBeenCalledTimes(1)
+					expect(provider["webviewRecoveryAttempts"]).toBe(2)
+					expect(provider.getCurrentTask()).toBe(task)
+					expect(provider["_disposed"]).toBe(false)
+					expect(remove).not.toHaveBeenCalled()
+					expect(task.dispose).not.toHaveBeenCalled()
+					expect(task.abortTask).not.toHaveBeenCalled()
+				},
+			)
+
+			test.each(["disposed", "replaced"] as const)(
+				"does not restart a stale replacement watchdog after the provider is %s",
+				async (event) => {
+					await provider.resolveWebviewView(mockWebviewPanel)
+					provider["getWebviewHtml"] = vi.fn().mockResolvedValue("recovered-html")
+					await provider["reloadWebviewForRecovery"]()
+					let rejectHtml: (error: Error) => void = () => {
+						throw new Error("Replacement HTML generation has not started")
+					}
+					vi.mocked(provider["getWebviewHtml"]).mockImplementationOnce(
+						() =>
+							new Promise<string>((_resolve, reject) => {
+								rejectHtml = reject
+							}),
+					)
+					const failed = replacementPanel()
+					vi.mocked(vscode.window.createWebviewPanel).mockReturnValue(failed)
+					await vi.advanceTimersByTimeAsync(10_000)
+					expect(provider["view"]).toBe(failed)
+					if (event === "disposed") await provider.dispose()
+					else await provider.resolveWebviewView(replacementPanel())
+					const watchdog = provider["webviewWatchdogInterval"]
+					rejectHtml(new Error("stale HTML failure"))
+					await vi.advanceTimersByTimeAsync(0)
+					expect(provider["webviewWatchdogInterval"]).toBe(watchdog)
+					expect(provider["webviewHostRecoveryInProgress"]).toBe(false)
+					expect(vscode.window.showWarningMessage).not.toHaveBeenCalled()
+				},
+			)
+
+			test("bounds repeated published-tab initialization failures and keeps the task available", async () => {
+				await provider.resolveWebviewView(mockWebviewPanel)
+				const task = new Task(defaultTaskOptions)
+				provider["taskRegistry"].push(task)
+				provider["getWebviewHtml"] = vi.fn().mockResolvedValue("recovered-html")
+				vi.mocked(vscode.window.createWebviewPanel).mockImplementation(() => {
+					const replacement = replacementPanel()
+					// Fail after publication, before any message listener is installed.
+					vi.spyOn(provider, "getState").mockRejectedValueOnce(new Error("hydration failed"))
+					return replacement
+				})
+
+				await vi.advanceTimersByTimeAsync(720_000)
+
+				expect(vscode.window.createWebviewPanel).toHaveBeenCalledTimes(3)
+				expect(provider["webviewRecoveryAttempts"]).toBe(3)
+				expect(provider["webviewHostRecoveryInProgress"]).toBe(false)
+				expect(vscode.window.showWarningMessage).toHaveBeenCalledTimes(1)
+				expect(provider["_disposed"]).toBe(false)
+				expect(provider.getCurrentTask()).toBe(task)
+				expect(task.dispose).not.toHaveBeenCalled()
+				expect(task.abortTask).not.toHaveBeenCalled()
+			})
+
 			test("reloads the tab webview when the heartbeat is stale and the tab is visible", async () => {
 				await provider.resolveWebviewView(mockWebviewPanel)
 				const htmlAfterResolve = mockWebviewPanel.webview.html