🤖 feat: add workspace archiving support (#1267)

Workspace archiving replaces sidebar deletion with a safe, reversible
action.

## Changes
- Add `archived` / `archivedAt` to workspace schemas + propagate through
metadata
- Add `workspace.archive` / `workspace.unarchive` ORPC endpoints
- Sidebar: replace **Delete** with **Archive** and hide archived
workspaces
- Project page (create-workspace flow): show **Archived Workspaces**
with search + timeline grouping
- Archived list supports:
  - Restore
- Permanent delete (only from archived view; bulk delete always uses
`force: true`)
- Bulk selection via checkboxes (+ shift-click range select) with a
progress modal
- Archiving interrupts any active stream for that workspace (prevents
"headless" streams)

## Behavior
1. Archiving removes a workspace from the sidebar (and it’s filtered out
of the frontend workspace tracking map).
2. Archived workspaces are visible on the **project page**
(create-workspace view), where they can be restored.
3. Permanent deletion is only available for archived workspaces.
4. Single-delete tries `force: false` without confirmation; only shows
the force-delete modal if the non-force delete fails.

---
_Generated with `mux` • Model: `openai:gpt-5.2` • Thinking: `high`_

Author: ammar-agent

.storybook/mocks/orpc.ts

@@ -21,6 +21,7 @@ import {
   type TaskSettings,
 } from "@/common/types/tasks";
 import { createAsyncMessageQueue } from "@/common/utils/asyncMessageQueue";
+import { isWorkspaceArchived } from "@/common/utils/archive";
 
 /** Session usage data structure matching SessionUsageFileSchema */
 export interface MockSessionUsage {
@@ -251,7 +252,14 @@ export function createMockORPCClient(options: MockORPCClientOptions = {}): APICl
       },
     },
     workspace: {
-      list: async () => workspaces,
+      list: async (input?: { archived?: boolean }) => {
+        if (input?.archived) {
+          return workspaces.filter((w) => isWorkspaceArchived(w.archivedAt, w.unarchivedAt));
+        }
+        return workspaces.filter((w) => !isWorkspaceArchived(w.archivedAt, w.unarchivedAt));
+      },
+      archive: async () => ({ success: true }),
+      unarchive: async () => ({ success: true }),
       create: async (input: { projectPath: string; branchName: string }) => ({
         success: true,
         metadata: {

src/browser/App.tsx

@@ -17,17 +17,12 @@ import { buildSortedWorkspacesByProject } from "./utils/ui/workspaceFiltering";
 import { useResumeManager } from "./hooks/useResumeManager";
 import { useUnreadTracking } from "./hooks/useUnreadTracking";
 import { useWorkspaceStoreRaw, useWorkspaceRecency } from "./stores/WorkspaceStore";
-import { ChatInput } from "./components/ChatInput/index";
-import type { ChatInputAPI } from "./components/ChatInput/types";
 
 import { useStableReference, compareMaps } from "./hooks/useStableReference";
 import { CommandRegistryProvider, useCommandRegistry } from "./contexts/CommandRegistryContext";
 import { useOpenTerminal } from "./hooks/useOpenTerminal";
 import type { CommandAction } from "./contexts/CommandRegistryContext";
-import { ModeProvider } from "./contexts/ModeContext";
-import { ProviderOptionsProvider } from "./contexts/ProviderOptionsContext";
 import { ThemeProvider, useTheme, type ThemeMode } from "./contexts/ThemeContext";
-import { ThinkingProvider } from "./contexts/ThinkingContext";
 import { CommandPalette } from "./components/CommandPalette";
 import { buildCoreSources, type BuildSourcesParams } from "./utils/commands/sources";
 
@@ -48,12 +43,12 @@ import { getRuntimeTypeForTelemetry } from "@/common/telemetry";
 import { useStartWorkspaceCreation, getFirstProjectPath } from "./hooks/useStartWorkspaceCreation";
 import { useAPI } from "@/browser/contexts/API";
 import { AuthTokenModal } from "@/browser/components/AuthTokenModal";
+import { ProjectPage } from "@/browser/components/ProjectPage";
 
 import { SettingsProvider, useSettings } from "./contexts/SettingsContext";
 import { SettingsModal } from "./components/Settings/SettingsModal";
 import { SplashScreenProvider } from "./components/splashScreens/SplashScreenProvider";
 import { TutorialProvider } from "./contexts/TutorialContext";
-import { ConnectionStatusIndicator } from "./components/ConnectionStatusIndicator";
 import { TooltipProvider } from "./components/ui/tooltip";
 import { useFeatureFlags } from "./contexts/FeatureFlagsContext";
 import { FeatureFlagsProvider } from "./contexts/FeatureFlagsContext";
@@ -102,25 +97,16 @@ function AppInner() {
   const isMobile = typeof window !== "undefined" && window.innerWidth <= 768;
   const [sidebarCollapsed, setSidebarCollapsed] = usePersistedState("sidebarCollapsed", isMobile);
   const defaultProjectPath = getFirstProjectPath(projects);
-  const creationChatInputRef = useRef<ChatInputAPI | null>(null);
   const creationProjectPath = !selectedWorkspace
     ? (pendingNewWorkspaceProject ?? (projects.size === 1 ? defaultProjectPath : null))
     : null;
-  const handleCreationChatReady = useCallback((api: ChatInputAPI) => {
-    creationChatInputRef.current = api;
-    api.focus();
-  }, []);
 
   const startWorkspaceCreation = useStartWorkspaceCreation({
     projects,
     beginWorkspaceCreation,
   });
 
-  useEffect(() => {
-    if (creationProjectPath) {
-      creationChatInputRef.current?.focus();
-    }
-  }, [creationProjectPath]);
+  // ProjectPage handles its own focus when mounted
 
   const handleToggleSidebar = useCallback(() => {
     setSidebarCollapsed((prev) => !prev);
@@ -502,12 +488,6 @@ function AppInner() {
       } else if (matchesKeybind(e, KEYBINDS.OPEN_SETTINGS)) {
         e.preventDefault();
         openSettings();
-      } else if (matchesKeybind(e, KEYBINDS.FOCUS_CHAT)) {
-        // Focus creation chat when on new chat page (no workspace selected)
-        if (creationProjectPath && creationChatInputRef.current) {
-          e.preventDefault();
-          creationChatInputRef.current.focus();
-        }
       }
     };
 
@@ -661,51 +641,40 @@ function AppInner() {
                 const projectName =
                   projectPath.split("/").pop() ?? projectPath.split("\\").pop() ?? "Project";
                 return (
-                  <ModeProvider projectPath={projectPath}>
-                    <ProviderOptionsProvider>
-                      <ThinkingProvider projectPath={projectPath}>
-                        <ConnectionStatusIndicator />
-                        <ChatInput
-                          variant="creation"
-                          projectPath={projectPath}
-                          projectName={projectName}
-                          onProviderConfig={handleProviderConfig}
-                          onReady={handleCreationChatReady}
-                          onWorkspaceCreated={(metadata) => {
-                            // IMPORTANT: Add workspace to store FIRST (synchronous) to ensure
-                            // the store knows about it before React processes the state updates.
-                            // This prevents race conditions where the UI tries to access the
-                            // workspace before the store has created its aggregator.
-                            workspaceStore.addWorkspace(metadata);
-
-                            // Add to workspace metadata map (triggers React state update)
-                            setWorkspaceMetadata((prev) =>
-                              new Map(prev).set(metadata.id, metadata)
-                            );
-
-                            // Only switch to new workspace if user hasn't selected another one
-                            // during the creation process (selectedWorkspace was null when creation started)
-                            setSelectedWorkspace((current) => {
-                              if (current !== null) {
-                                // User has already selected another workspace - don't override
-                                return current;
-                              }
-                              return toWorkspaceSelection(metadata);
-                            });
-
-                            // Track telemetry
-                            telemetry.workspaceCreated(
-                              metadata.id,
-                              getRuntimeTypeForTelemetry(metadata.runtimeConfig)
-                            );
-
-                            // Clear pending state
-                            clearPendingWorkspaceCreation();
-                          }}
-                        />
-                      </ThinkingProvider>
-                    </ProviderOptionsProvider>
-                  </ModeProvider>
+                  <ProjectPage
+                    projectPath={projectPath}
+                    projectName={projectName}
+                    onProviderConfig={handleProviderConfig}
+                    onWorkspaceCreated={(metadata) => {
+                      // IMPORTANT: Add workspace to store FIRST (synchronous) to ensure
+                      // the store knows about it before React processes the state updates.
+                      // This prevents race conditions where the UI tries to access the
+                      // workspace before the store has created its aggregator.
+                      workspaceStore.addWorkspace(metadata);
+
+                      // Add to workspace metadata map (triggers React state update)
+                      setWorkspaceMetadata((prev) => new Map(prev).set(metadata.id, metadata));
+
+                      // Only switch to new workspace if user hasn't selected another one
+                      // during the creation process (selectedWorkspace was null when creation started)
+                      setSelectedWorkspace((current) => {
+                        if (current !== null) {
+                          // User has already selected another workspace - don't override
+                          return current;
+                        }
+                        return toWorkspaceSelection(metadata);
+                      });
+
+                      // Track telemetry
+                      telemetry.workspaceCreated(
+                        metadata.id,
+                        getRuntimeTypeForTelemetry(metadata.runtimeConfig)
+                      );
+
+                      // Clear pending state
+                      clearPendingWorkspaceCreation();
+                    }}
+                  />
                 );
               })()
             ) : (