Feature Request: Restore Last Chat Session on Application Crash/Unexpected Shutdown

[Jarrodsz]

Crash

Is your feature request related to a problem? Please describe.

Although Roo Code stores chat history, if VS Code crashes or is unexpectedly terminated, all open Roo chat panes within that VS Code window reload as empty/new sessions upon restart. Users must then manually find and reopen their previous conversations for each pane, losing the immediate context of their multi-pane workspace.
Use code with caution.
Markdown

Describe the solution you'd like

Implement a system where Roo Code remembers which chat sessions were active in its specific panes within a VS Code window. Upon VS Code restarting after a crash, Roo Code should automatically attempt to reload the last active chat history into each corresponding Roo chat pane.

Proposed Workflow:

1. Pane State Tracking:

   • Each active Roo chat pane instance within a VS Code window should have its "current chat session ID" (or a similar identifier pointing to its history) persisted. This could leverage VS Code's extension state persistence mechanisms (e.g., Memento API for workspace state).
   • This state should be updated whenever a chat is opened/switched in a pane or as new messages come in (to ensure the latest state is captured).

2. Detection on VS Code/Extension Activation:

   • When the Roo Code extension activates (especially after a VS Code restart that might have been a crash), it checks its persisted state for previously active panes and their associated chat session IDs for that specific VS Code window/workspace.

3. Automatic UI Restoration:

   • For each identified previously active Roo chat pane:
     • Roo Code attempts to re-initialize or find the corresponding UI pane.
     • It then automatically loads the chat history associated with the persisted chat session ID into that specific pane's UI.
     • The scroll position or the view of the last few messages should ideally be restored if possible.

4. Handling Panes That Can't Be Restored:

   • If a persisted pane state refers to a chat history that no longer exists or a pane cannot be recreated, Roo Code should handle this gracefully (e.g., open an empty pane, log an internal error, or show a minimal notification in that pane).
     Use code with caution.
     Markdown

Describe alternatives you've considered

• Manual Reopening: Current behavior, which is inefficient and disrupts workflow, especially with multiple active Roo chat panes.
• Relying solely on VS Code's generic webview/editor restoration: This may not be specific enough to map Roo's distinct chat sessions to their correct panes accurately without Roo's explicit management.
  Use code with caution.
  Markdown

Benefits

• Seamless Workspace Continuity: Users can immediately resume their work in all their Roo chat panes after a VS Code crash without manual intervention.
• Context Preservation: Maintains the context of multiple ongoing conversations across different panes.
• Increased Productivity: Eliminates the time and effort needed to manually restore the chat UI state.
• Improved User Experience: Makes Roo Code feel more integrated and resilient within the VS Code environment.
  Use code with caution.
  Markdown

Additional context

• This feature relies on the existing chat history storage mechanism. The focus is on restoring the UI presentation of those histories in their respective panes.
• Consider how to uniquely identify Roo chat panes within a VS Code window, especially if users can have multiple instances open.
• The state should ideally be scoped to the VS Code workspace or window to handle multiple VS Code windows correctly.
• A subtle notification like "Previous chat sessions restored" could be shown on first load after restoration.

[Mnehmos]

Scope Document (Dual Approach)

Scope Document: Restore Last Chat Session on Application Crash/Unexpected Shutdown.

1. Problem Statement

When VS Code crashes or is unexpectedly terminated, Roo Code loses all active chat sessions. Upon restarting, users are presented with empty chat panes and must manually find and reopen their previous conversations. This disrupts workflow, especially for users who rely on multiple, simultaneous chat sessions for context.

This feature aims to automatically restore the last active chat session in each Roo Code pane, providing a seamless experience and preserving the user's workspace.

2. Root Cause Analysis

The application does not persist the state of active chat sessions in a way that can survive a crash. The link between a specific webview pane and its active chat session is lost when the application closes unexpectedly. The application lacks a mechanism to track which chat sessions were active in which panes and restore them on startup.

3. Solution Design: Two Implementation Paths

Two distinct paths can be taken to solve this problem. Both are viable, but they differ in their implementation complexity and reliance on VS Code's native features.

---

Path A: Manual Session State Management

This approach involves manually tracking the active chat session for each webview pane in the extension's global state.

3.1.A. Key Components to be Modified

• src/core/webview/ClineProvider.ts: To persist the taskId of the active chat session to the workspace state.
• src/activate/registerCommands.ts: To check for persisted sessions on startup and restore them.
• src/core/config/ContextProxy.ts: To store and retrieve the persisted session data from the global state.

3.2.A. Implementation Steps

1. Persist Active Chat Sessions:

   • In src/core/webview/ClineProvider.ts, generate a unique identifier for each webview panel.
   • When a task is initialized (in initClineWithTask and initClineWithHistoryItem), update a global state object (activeRooSessions) with the new taskId for the corresponding panel and workspace.
   • When a panel is disposed of (onDidDispose), remove its entry from the activeRooSessions object.

2. Restore Chat Sessions on Activation:

   • In src/activate/registerCommands.ts, during extension activation, retrieve activeRooSessions from the global state.
   • For each persisted session, create a new webview panel by calling openClineInNewTab with the taskId.

3. Load History in Restored Panels:

   • Update the resolveWebviewView method in ClineProvider to accept an optional taskId and call initClineWithHistoryItem to load the chat history.

---

Path B: Using WebviewPanelSerializer

This approach leverages VS Code's built-in mechanism for saving and restoring webview panels, which is the more idiomatic and robust solution.

3.1.B. Key Components & Implementation Steps

1. Create ClinePanelSerializer.ts:

   • Create a new file, src/core/webview/ClinePanelSerializer.ts, that implements the vscode.WebviewPanelSerializer interface.
   • serializeWebviewPanel: Persist the taskId of the current task into the state object provided by VS Code.
   • deserializeWebviewPanel: On startup, this method will be called by VS Code for each panel to be restored. It will use the taskId from the state object to re-initialize a ClineProvider with the correct chat history.

2. Update src/core/webview/ClineProvider.ts:

   • Refactor the provider to support being restored by the serializer, including a way to associate a provider instance with its WebviewPanel.
   • Remove the manual session state management logic.

3. Update src/activate/registerCommands.ts:

   • Remove the manual session restoration logic.
   • Register the new ClinePanelSerializer with VS Code using vscode.window.registerWebviewPanelSerializer during extension activation.

---

4. Comparison and Recommendation

Aspect	Path A: Manual State	Path B: WebviewPanelSerializer
Robustness	Lower. More prone to state inconsistencies and race conditions.	Higher. Leverages VS Code's native, battle-tested persistence mechanism.
Complexity	Higher. Requires manual tracking of panel IDs, workspaces, and state cleanup.	Lower. Offloads state management to the editor, simplifying the extension's code.
Maintainability	Harder to maintain due to custom logic for a common editor pattern.	Easier to maintain. Aligns with VS Code extension best practices.
Scope	Can be implemented for both WebviewPanel (tabs) and WebviewView (sidebar).	Primarily designed for WebviewPanel. Sidebar restoration would require a separate approach.

Recommendation:

Path B (WebviewPanelSerializer) is the strongly recommended approach for restoring chat sessions in editor tabs. It is a more robust, maintainable, and idiomatic solution that results in cleaner code. For the sidebar view, a separate, simpler persistence mechanism (similar to Path A but scoped only to the sidebar) can be implemented if required.

5. Impact Analysis (Applicable to both paths)

• Positive Impact: This feature will significantly improve the user experience by providing seamless session restoration, preserving context, and increasing productivity.
• Potential Risks:
  • Incorrect state management could lead to the wrong chat session being restored or errors on startup.
  • The implementation must be robust enough to handle multiple VS Code windows and workspaces correctly.
• Testing Strategy:
  • Manual testing will be required to verify that sessions are correctly restored after a simulated crash.
  • Unit tests should be added for the new state management or serializer logic.

6. Out of Scope

• This feature will not restore the scroll position or the exact view of the last few messages. The focus is on restoring the chat history itself.
• Any changes to the underlying chat history storage mechanism are out of scope.

[hannesrudolph]

We would prefer to fix the crash issue. Closing this as not planned.