Restore an archived workspace when its agent is reopened

Reopening an archived agent previously dead-ended at "workspace not
found": the agent record was un-archived but its workspace stayed
archived and was never sent to the client.

The daemon now un-archives the owning workspace alongside the agent when
its backing directory still exists, and the app auto-fires the restore
ahead of the missing-workspace gate so the user lands back in the
workspace rather than a dead end.

Worktrees whose directory was deleted on archive are not yet restorable
(recreating them from their branch is a follow-up); the workspace record
now persists its base branch as groundwork for that.

packages/app/src/utils/navigate-to-agent/index.ts

@@ -1,10 +1,51 @@
 import { router, type Href } from "expo-router";
 import { useSessionStore } from "@/stores/session-store";
+import { getHostRuntimeStore, isHostRuntimeConnected } from "@/runtime/host-runtime";
 import { resolveNavigateToAgent, type NavigateToAgentInput } from "./resolve";
 import { navigateToPreparedWorkspaceTab } from "@/utils/workspace-navigation";
 
 export type { NavigateToAgentInput } from "./resolve";
 
+// Clears the transient restoring state if the daemon resolves refreshAgent without
+// re-emitting a workspace_update (the directory-gone case), so the gate never spins forever.
+const RESTORE_TIMEOUT_MS = 7000;
+
+function restoreArchivedWorkspace(serverId: string, agentId: string, workspaceId: string): void {
+  const snapshot = getHostRuntimeStore().getSnapshot(serverId);
+  const client = snapshot?.client ?? null;
+  if (!client || !isHostRuntimeConnected(snapshot)) {
+    return;
+  }
+
+  const store = useSessionStore.getState();
+  const session = store.sessions[serverId];
+  // Self-gate: only an archived agent whose workspace is absent needs restoring.
+  // A still-present workspace or an in-flight restore is a no-op; fire-once is
+  // derived from store state.
+  const agent = session?.agents.get(agentId) ?? session?.agentDetails.get(agentId);
+  if (!agent?.archivedAt) {
+    return;
+  }
+  if (session?.workspaces.has(workspaceId)) {
+    return;
+  }
+  if (session?.restoringWorkspaces.get(workspaceId) === "restoring") {
+    return;
+  }
+
+  store.setWorkspaceRestoreStatus(serverId, workspaceId, "restoring");
+  // The reducer guards "failed" so a late timeout after the descriptor lands is a no-op.
+  setTimeout(
+    () => useSessionStore.getState().setWorkspaceRestoreStatus(serverId, workspaceId, "failed"),
+    RESTORE_TIMEOUT_MS,
+  );
+  client
+    .refreshAgent(agentId)
+    .catch(() =>
+      useSessionStore.getState().setWorkspaceRestoreStatus(serverId, workspaceId, "failed"),
+    );
+}
+
 export function navigateToAgent(input: NavigateToAgentInput): string {
   return resolveNavigateToAgent(input, {
     readAgentNavTarget: ({ serverId, agentId }) => {
@@ -18,5 +59,8 @@ export function navigateToAgent(input: NavigateToAgentInput): string {
       router.navigate(route as Href);
     },
     navigateToPreparedWorkspaceTab,
+    restoreArchivedWorkspace: ({ serverId, agentId, workspaceId }) => {
+      restoreArchivedWorkspace(serverId, agentId, workspaceId);
+    },
   });
 }