@getpaseo/server 0.1.18 → 0.1.20

package/dist/server/server/session.js

@@ -23,12 +23,14 @@ import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } fro
 import { projectTimelineRows, selectTimelineWindowByProjectedLimit, } from './agent/timeline-projection.js';
 import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from './agent/agent-response-loop.js';
 import { isValidAgentProvider, AGENT_PROVIDER_IDS } from './agent/provider-manifest.js';
+import { buildProjectPlacementForCwd, deriveProjectKind, deriveProjectRootPath, deriveWorkspaceDisplayName, deriveWorkspaceKind, normalizeWorkspaceId as normalizePersistedWorkspaceId, } from './workspace-registry-model.js';
+import { createPersistedProjectRecord, createPersistedWorkspaceRecord, } from './workspace-registry.js';
 import { buildVoiceAgentMcpServerConfig, buildVoiceModeSystemPrompt, stripVoiceModeSystemPrompt, } from './voice-config.js';
 import { isVoicePermissionAllowed } from './voice-permission-policy.js';
 import { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, } from './file-explorer/service.js';
 import { slugify, validateBranchSlug, listPaseoWorktrees, deletePaseoWorktree, isPaseoOwnedWorktreeCwd, resolvePaseoWorktreeRootForCwd, } from '../utils/worktree.js';
 import { createAgentWorktree, runAsyncWorktreeBootstrap } from './worktree-bootstrap.js';
-import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestStatus, } from '../utils/checkout-git.js';
+import { getCheckoutDiff, getCheckoutShortstat, getCheckoutStatus, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestStatus, } from '../utils/checkout-git.js';
 import { getProjectIcon } from '../utils/project-icon.js';
 import { expandTilde } from '../utils/path.js';
 import { searchHomeDirectories, searchWorkspaceEntries } from '../utils/directory-suggestions.js';
@@ -73,66 +75,6 @@ export function resolveCreateAgentTitles(options) {
         provisionalTitle,
     };
 }
-function deriveRemoteProjectKey(remoteUrl) {
-    if (!remoteUrl) {
-        return null;
-    }
-    const trimmed = remoteUrl.trim();
-    if (!trimmed) {
-        return null;
-    }
-    let host = null;
-    let path = null;
-    const scpLike = trimmed.match(/^[^@]+@([^:]+):(.+)$/);
-    if (scpLike) {
-        host = scpLike[1] ?? null;
-        path = scpLike[2] ?? null;
-    }
-    else if (trimmed.includes('://')) {
-        try {
-            const parsed = new URL(trimmed);
-            host = parsed.hostname || null;
-            path = parsed.pathname ? parsed.pathname.replace(/^\//, '') : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    if (!host || !path) {
-        return null;
-    }
-    let cleanedPath = path.trim().replace(/^\/+/, '').replace(/\/+$/, '');
-    if (cleanedPath.endsWith('.git')) {
-        cleanedPath = cleanedPath.slice(0, -4);
-    }
-    if (!cleanedPath.includes('/')) {
-        return null;
-    }
-    const cleanedHost = host.toLowerCase();
-    if (cleanedHost === 'github.com') {
-        return `remote:github.com/${cleanedPath}`;
-    }
-    return `remote:${cleanedHost}/${cleanedPath}`;
-}
-function deriveProjectGroupingKey(options) {
-    const remoteKey = deriveRemoteProjectKey(options.remoteUrl);
-    if (remoteKey) {
-        return remoteKey;
-    }
-    const mainRepoRoot = options.mainRepoRoot?.trim();
-    if (options.isPaseoOwnedWorktree && mainRepoRoot) {
-        return mainRepoRoot;
-    }
-    return options.cwd;
-}
-function deriveProjectGroupingName(projectKey) {
-    const githubRemotePrefix = 'remote:github.com/';
-    if (projectKey.startsWith(githubRemotePrefix)) {
-        return projectKey.slice(githubRemotePrefix.length) || projectKey;
-    }
-    const segments = projectKey.split(/[\\/]/).filter(Boolean);
-    return segments[segments.length - 1] || projectKey;
-}
 class SessionRequestError extends Error {
     constructor(code, message) {
         super(message);
@@ -260,7 +202,7 @@ export class Session {
             attention: 3,
             done: 4,
         };
-        const { clientId, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, createAgentMcpTransport, stt, tts, terminalManager, voice, voiceBridge, dictation, agentProviderRuntimeSettings, } = options;
+        const { clientId, onMessage, onBinaryMessage, onLifecycleIntent, logger, downloadTokenStore, pushTokenStore, paseoHome, agentManager, agentStorage, projectRegistry, workspaceRegistry, createAgentMcpTransport, stt, tts, terminalManager, voice, voiceBridge, dictation, agentProviderRuntimeSettings, } = options;
         this.clientId = clientId;
         this.sessionId = uuidv4();
         this.onMessage = onMessage;
@@ -271,6 +213,8 @@ export class Session {
         this.paseoHome = paseoHome;
         this.agentManager = agentManager;
         this.agentStorage = agentStorage;
+        this.projectRegistry = projectRegistry;
+        this.workspaceRegistry = workspaceRegistry;
         this.createAgentMcpTransport = createAgentMcpTransport;
         this.terminalManager = terminalManager;
         if (this.terminalManager) {
@@ -421,8 +365,12 @@ export class Session {
         }, 'startAgentStream: requested');
         let iterator;
         try {
-            iterator = this.agentManager.streamAgent(agentId, prompt, runOptions);
-            this.sessionLogger.trace({ agentId }, 'startAgentStream: streamAgent returned iterator');
+            const snapshot = this.agentManager.getAgent(agentId);
+            const shouldReplace = Boolean(snapshot && (snapshot.lifecycle === 'running' || snapshot.pendingRun));
+            iterator = shouldReplace
+                ? this.agentManager.replaceAgentRun(agentId, prompt, runOptions)
+                : this.agentManager.streamAgent(agentId, prompt, runOptions);
+            this.sessionLogger.trace({ agentId, shouldReplace }, 'startAgentStream: agent iterator returned');
         }
         catch (error) {
             this.handleAgentRunError(agentId, error, 'Failed to start agent run');
@@ -745,57 +693,15 @@ export class Session {
             });
         }
     }
-    buildFallbackProjectCheckout(cwd) {
-        return {
-            cwd,
-            isGit: false,
-            currentBranch: null,
-            remoteUrl: null,
-            isPaseoOwnedWorktree: false,
-            mainRepoRoot: null,
-        };
-    }
-    toProjectCheckoutLite(cwd, status) {
-        if (!status.isGit) {
-            return this.buildFallbackProjectCheckout(cwd);
-        }
-        if (status.isPaseoOwnedWorktree) {
-            return {
-                cwd,
-                isGit: true,
-                currentBranch: status.currentBranch,
-                remoteUrl: status.remoteUrl,
-                isPaseoOwnedWorktree: true,
-                mainRepoRoot: status.mainRepoRoot,
-            };
-        }
-        return {
-            cwd,
-            isGit: true,
-            currentBranch: status.currentBranch,
-            remoteUrl: status.remoteUrl,
-            isPaseoOwnedWorktree: false,
-            mainRepoRoot: null,
-        };
-    }
     async buildProjectPlacement(cwd) {
-        const checkout = await getCheckoutStatusLite(cwd, { paseoHome: this.paseoHome })
-            .then((status) => this.toProjectCheckoutLite(cwd, status))
-            .catch(() => this.buildFallbackProjectCheckout(cwd));
-        const projectKey = deriveProjectGroupingKey({
+        return buildProjectPlacementForCwd({
             cwd,
-            remoteUrl: checkout.remoteUrl,
-            isPaseoOwnedWorktree: checkout.isPaseoOwnedWorktree,
-            mainRepoRoot: checkout.mainRepoRoot,
+            paseoHome: this.paseoHome,
         });
-        return {
-            projectKey,
-            projectName: deriveProjectGroupingName(projectKey),
-            checkout,
-        };
     }
     async forwardAgentUpdate(agent) {
         try {
+            await this.ensureWorkspaceRegistered(agent.cwd);
             const subscription = this.agentUpdatesSubscription;
             const payload = await this.buildAgentPayload(agent);
             if (subscription) {
@@ -975,6 +881,12 @@ export class Session {
                 case 'paseo_worktree_archive_request':
                     await this.handlePaseoWorktreeArchiveRequest(msg);
                     break;
+                case 'open_project_request':
+                    await this.handleOpenProjectRequest(msg);
+                    break;
+                case 'archive_workspace_request':
+                    await this.handleArchiveWorkspaceRequest(msg);
+                    break;
                 case 'file_explorer_request':
                     await this.handleFileExplorerRequest(msg);
                     break;
@@ -1222,7 +1134,7 @@ export class Session {
     }
     async handleArchiveAgentRequest(agentId, requestId) {
         this.sessionLogger.info({ agentId }, `Archiving agent ${agentId}`);
-        const { archivedAt, archivedRecord } = await this.archiveAgentState(agentId);
+        const { archivedAt } = await this.archiveAgentState(agentId);
         this.emit({
             type: 'agent_archived',
             payload: {
@@ -1231,11 +1143,6 @@ export class Session {
                 requestId,
             },
         });
-        await this.maybeArchiveWorktreeAfterLastAgentArchived({
-            archivedAgentId: agentId,
-            archivedAgentCwd: archivedRecord.cwd,
-            requestId,
-        });
     }
     async archiveAgentState(agentId) {
         if (this.agentManager.getAgent(agentId)) {
@@ -1773,14 +1680,6 @@ export class Session {
             this.handleAgentRunError(agentId, error, 'Failed to initialize agent before sending prompt');
             return;
         }
-        try {
-            await this.interruptAgentIfRunning(agentId);
-        }
-        catch (error) {
-            this.handleAgentRunError(agentId, error, 'Failed to interrupt running agent before sending prompt');
-            return;
-        }
-        const prompt = this.buildAgentPrompt(text, images);
         try {
             this.agentManager.recordUserMessage(agentId, text, {
                 messageId,
@@ -1790,6 +1689,7 @@ export class Session {
         catch (error) {
             this.sessionLogger.error({ err: error, agentId }, `Failed to record user message for agent ${agentId}`);
         }
+        const prompt = this.buildAgentPrompt(text, images);
         this.startAgentStream(agentId, prompt, runOptions);
     }
     /**
@@ -1809,6 +1709,7 @@ export class Session {
                 ...(provisionalTitle ? { title: provisionalTitle } : {}),
             };
             const { sessionConfig, worktreeConfig } = await this.buildAgentSessionConfig(resolvedConfig, git, worktreeName, labels);
+            await this.ensureWorkspaceRegistered(sessionConfig.cwd);
             const snapshot = await this.agentManager.createAgent(sessionConfig, undefined, { labels });
             await this.forwardAgentUpdate(snapshot);
             if (requestId) {
@@ -3469,59 +3370,6 @@ export class Session {
             });
         }
     }
-    async maybeArchiveWorktreeAfterLastAgentArchived(options) {
-        try {
-            const ownership = await isPaseoOwnedWorktreeCwd(options.archivedAgentCwd, {
-                paseoHome: this.paseoHome,
-            });
-            if (!ownership.allowed) {
-                return;
-            }
-            const resolvedWorktree = await resolvePaseoWorktreeRootForCwd(options.archivedAgentCwd, {
-                paseoHome: this.paseoHome,
-            });
-            if (!resolvedWorktree) {
-                return;
-            }
-            const records = await this.agentStorage.list();
-            const recordsById = new Map(records.map((record) => [record.id, record]));
-            const targetPath = resolvedWorktree.worktreePath;
-            const hasRemainingNonArchivedRecord = records.some((record) => {
-                if (record.id === options.archivedAgentId || record.archivedAt) {
-                    return false;
-                }
-                return this.isPathWithinRoot(targetPath, record.cwd);
-            });
-            if (hasRemainingNonArchivedRecord) {
-                return;
-            }
-            const hasUnknownLiveAgent = this.agentManager.listAgents().some((agent) => {
-                if (agent.id === options.archivedAgentId) {
-                    return false;
-                }
-                if (!this.isPathWithinRoot(targetPath, agent.cwd)) {
-                    return false;
-                }
-                return !recordsById.has(agent.id);
-            });
-            if (hasUnknownLiveAgent) {
-                return;
-            }
-            const repoRoot = ownership.repoRoot;
-            if (!repoRoot) {
-                this.sessionLogger.warn({ agentId: options.archivedAgentId, worktreePath: targetPath }, 'Unable to resolve repo root for auto-archive after agent archive');
-                return;
-            }
-            await this.archivePaseoWorktree({
-                targetPath,
-                repoRoot,
-                requestId: options.requestId,
-            });
-        }
-        catch (error) {
-            this.sessionLogger.warn({ err: error, agentId: options.archivedAgentId, cwd: options.archivedAgentCwd }, 'Failed to auto-archive worktree after agent archive');
-        }
-    }
     async archivePaseoWorktree(options) {
         let targetPath = options.targetPath;
         const resolvedWorktree = await resolvePaseoWorktreeRootForCwd(targetPath, {
@@ -3532,11 +3380,13 @@ export class Session {
         }
         const removedAgents = new Set();
         const affectedWorkspaceCwds = new Set([targetPath]);
+        const affectedWorkspaceIds = new Set([normalizePersistedWorkspaceId(targetPath)]);
         const agents = this.agentManager.listAgents();
         for (const agent of agents) {
             if (this.isPathWithinRoot(targetPath, agent.cwd)) {
                 removedAgents.add(agent.id);
                 affectedWorkspaceCwds.add(agent.cwd);
+                affectedWorkspaceIds.add(normalizePersistedWorkspaceId(agent.cwd));
                 try {
                     await this.agentManager.closeAgent(agent.id);
                 }
@@ -3556,6 +3406,7 @@ export class Session {
             if (this.isPathWithinRoot(targetPath, record.cwd)) {
                 removedAgents.add(record.id);
                 affectedWorkspaceCwds.add(record.cwd);
+                affectedWorkspaceIds.add(normalizePersistedWorkspaceId(record.cwd));
                 try {
                     await this.agentStorage.remove(record.id);
                 }
@@ -3570,6 +3421,9 @@ export class Session {
             worktreePath: targetPath,
             paseoHome: this.paseoHome,
         });
+        for (const workspaceId of affectedWorkspaceIds) {
+            await this.archiveWorkspaceRecord(workspaceId);
+        }
         for (const agentId of removedAgents) {
             this.emit({
                 type: 'agent_deleted',
@@ -4109,13 +3963,6 @@ export class Session {
             },
         };
     }
-    normalizeWorkspaceId(cwd) {
-        const trimmed = cwd.trim();
-        if (!trimmed) {
-            return cwd;
-        }
-        return resolve(trimmed);
-    }
     deriveWorkspaceStateBucket(agent) {
         const pendingPermissionCount = agent.pendingPermissions?.length ?? 0;
         if (pendingPermissionCount > 0 || agent.attentionReason === 'permission') {
@@ -4132,18 +3979,6 @@ export class Session {
         }
         return 'done';
     }
-    deriveWorkspaceDirectoryName(cwd) {
-        const normalized = cwd.replace(/\\/g, '/');
-        const segments = normalized.split('/').filter(Boolean);
-        return segments[segments.length - 1] ?? cwd;
-    }
-    deriveWorkspaceName(input) {
-        const branch = input.checkout.currentBranch?.trim() ?? null;
-        if (branch && branch.toUpperCase() !== 'HEAD') {
-            return branch;
-        }
-        return this.deriveWorkspaceDirectoryName(input.cwd);
-    }
     accumulateLatestActivityAt(current, agent) {
         const candidateRaw = agent.lastUserMessageAt ?? agent.updatedAt;
         const candidateMs = Date.parse(candidateRaw);
@@ -4159,39 +3994,60 @@ export class Session {
         }
         return current;
     }
+    async describeWorkspaceRecord(workspace, projectRecord) {
+        const resolvedProjectRecord = projectRecord ?? (await this.projectRegistry.get(workspace.projectId));
+        let displayName = workspace.displayName;
+        try {
+            const placement = await this.buildProjectPlacement(workspace.cwd);
+            displayName = deriveWorkspaceDisplayName({
+                cwd: workspace.cwd,
+                checkout: placement.checkout,
+            });
+        }
+        catch {
+            // Fall back to the persisted label if checkout metadata is unavailable.
+        }
+        let diffStat = null;
+        try {
+            diffStat = await getCheckoutShortstat(workspace.cwd);
+        }
+        catch {
+            // Non-critical — leave null on failure.
+        }
+        return {
+            id: workspace.workspaceId,
+            projectId: workspace.projectId,
+            projectDisplayName: resolvedProjectRecord?.displayName ?? workspace.projectId,
+            projectRootPath: resolvedProjectRecord?.rootPath ?? workspace.cwd,
+            projectKind: resolvedProjectRecord?.kind ?? 'non_git',
+            workspaceKind: workspace.kind,
+            name: displayName,
+            status: 'done',
+            activityAt: null,
+            diffStat,
+        };
+    }
     async listWorkspaceDescriptors() {
-        const agents = await this.listAgentPayloads();
+        const [agents, persistedWorkspaces, persistedProjects] = await Promise.all([
+            this.listAgentPayloads(),
+            this.workspaceRegistry.list(),
+            this.projectRegistry.list(),
+        ]);
+        const activeRecords = persistedWorkspaces.filter((workspace) => !workspace.archivedAt);
+        const activeProjects = new Map(persistedProjects
+            .filter((project) => !project.archivedAt)
+            .map((project) => [project.projectId, project]));
         const descriptorsByWorkspaceId = new Map();
-        const placementByWorkspaceId = new Map();
-        const getPlacement = (workspaceCwd) => {
-            const key = this.normalizeWorkspaceId(workspaceCwd);
-            const existing = placementByWorkspaceId.get(key);
-            if (existing) {
-                return existing;
-            }
-            const next = this.buildProjectPlacement(workspaceCwd);
-            placementByWorkspaceId.set(key, next);
-            return next;
-        };
+        for (const workspace of activeRecords) {
+            descriptorsByWorkspaceId.set(workspace.workspaceId, await this.describeWorkspaceRecord(workspace, activeProjects.get(workspace.projectId) ?? null));
+        }
         for (const agent of agents) {
             if (agent.archivedAt) {
                 continue;
             }
-            const workspaceId = this.normalizeWorkspaceId(agent.cwd);
-            const placement = await getPlacement(workspaceId);
+            const workspaceId = normalizePersistedWorkspaceId(agent.cwd);
             const existing = descriptorsByWorkspaceId.get(workspaceId);
             if (!existing) {
-                const bucket = this.deriveWorkspaceStateBucket(agent);
-                descriptorsByWorkspaceId.set(workspaceId, {
-                    id: workspaceId,
-                    projectId: placement.projectKey,
-                    name: this.deriveWorkspaceName({
-                        cwd: workspaceId,
-                        checkout: placement.checkout,
-                    }),
-                    status: bucket,
-                    activityAt: this.accumulateLatestActivityAt(null, agent),
-                });
                 continue;
             }
             const bucket = this.deriveWorkspaceStateBucket(agent);
@@ -4399,12 +4255,62 @@ export class Session {
             });
         }
     }
+    async ensureWorkspaceRegistered(cwd) {
+        const workspaceId = normalizePersistedWorkspaceId(cwd);
+        const existing = await this.workspaceRegistry.get(workspaceId);
+        if (existing && !existing.archivedAt) {
+            return existing;
+        }
+        const placement = await this.buildProjectPlacement(workspaceId);
+        const now = new Date().toISOString();
+        const projectExisting = await this.projectRegistry.get(placement.projectKey);
+        const projectRecord = createPersistedProjectRecord({
+            projectId: placement.projectKey,
+            rootPath: deriveProjectRootPath({
+                cwd: workspaceId,
+                checkout: placement.checkout,
+            }),
+            kind: deriveProjectKind(placement.checkout),
+            displayName: placement.projectName,
+            createdAt: projectExisting?.createdAt ?? now,
+            updatedAt: now,
+            archivedAt: null,
+        });
+        await this.projectRegistry.upsert(projectRecord);
+        const workspaceRecord = createPersistedWorkspaceRecord({
+            workspaceId,
+            projectId: placement.projectKey,
+            cwd: workspaceId,
+            kind: deriveWorkspaceKind(placement.checkout),
+            displayName: deriveWorkspaceDisplayName({
+                cwd: workspaceId,
+                checkout: placement.checkout,
+            }),
+            createdAt: existing?.createdAt ?? now,
+            updatedAt: now,
+            archivedAt: null,
+        });
+        await this.workspaceRegistry.upsert(workspaceRecord);
+        return workspaceRecord;
+    }
+    async archiveWorkspaceRecord(workspaceId, archivedAt) {
+        const existing = await this.workspaceRegistry.get(workspaceId);
+        if (!existing || existing.archivedAt) {
+            return;
+        }
+        const nextArchivedAt = archivedAt ?? new Date().toISOString();
+        await this.workspaceRegistry.archive(workspaceId, nextArchivedAt);
+        const siblingWorkspaces = (await this.workspaceRegistry.list()).filter((workspace) => workspace.projectId === existing.projectId && !workspace.archivedAt);
+        if (siblingWorkspaces.length === 0) {
+            await this.projectRegistry.archive(existing.projectId, nextArchivedAt);
+        }
+    }
     async emitWorkspaceUpdateForCwd(cwd) {
         const subscription = this.workspaceUpdatesSubscription;
         if (!subscription) {
             return;
         }
-        const workspaceId = this.normalizeWorkspaceId(cwd);
+        const workspaceId = normalizePersistedWorkspaceId(cwd);
         const all = await this.listWorkspaceDescriptors();
         const workspace = all.find((entry) => entry.id === workspaceId);
         if (!workspace) {
@@ -4432,7 +4338,7 @@ export class Session {
         }
         const uniqueWorkspaceCwds = new Set();
         for (const cwd of cwds) {
-            const normalized = this.normalizeWorkspaceId(cwd);
+            const normalized = normalizePersistedWorkspaceId(cwd);
             if (!normalized) {
                 continue;
             }
@@ -4552,6 +4458,69 @@ export class Session {
             });
         }
     }
+    async handleOpenProjectRequest(request) {
+        try {
+            const workspace = await this.ensureWorkspaceRegistered(request.cwd);
+            await this.emitWorkspaceUpdateForCwd(workspace.cwd);
+            const descriptor = await this.describeWorkspaceRecord(workspace);
+            this.emit({
+                type: 'open_project_response',
+                payload: {
+                    requestId: request.requestId,
+                    workspace: descriptor,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to open project';
+            this.sessionLogger.error({ err: error, cwd: request.cwd }, 'Failed to open project');
+            this.emit({
+                type: 'open_project_response',
+                payload: {
+                    requestId: request.requestId,
+                    workspace: null,
+                    error: message,
+                },
+            });
+        }
+    }
+    async handleArchiveWorkspaceRequest(request) {
+        try {
+            const existing = await this.workspaceRegistry.get(request.workspaceId);
+            if (!existing) {
+                throw new Error(`Workspace not found: ${request.workspaceId}`);
+            }
+            if (existing.kind === 'worktree') {
+                throw new Error('Use worktree archive for Paseo worktrees');
+            }
+            const archivedAt = new Date().toISOString();
+            await this.archiveWorkspaceRecord(request.workspaceId, archivedAt);
+            await this.emitWorkspaceUpdateForCwd(existing.cwd);
+            this.emit({
+                type: 'archive_workspace_response',
+                payload: {
+                    requestId: request.requestId,
+                    workspaceId: request.workspaceId,
+                    archivedAt,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to archive workspace';
+            this.sessionLogger.error({ err: error, workspaceId: request.workspaceId }, 'Failed to archive workspace');
+            this.emit({
+                type: 'archive_workspace_response',
+                payload: {
+                    requestId: request.requestId,
+                    workspaceId: request.workspaceId,
+                    archivedAt: null,
+                    error: message,
+                },
+            });
+        }
+    }
     async handleFetchAgent(agentIdOrIdentifier, requestId) {
         const resolved = await this.resolveAgentIdentifier(agentIdOrIdentifier);
         if (!resolved.ok) {
@@ -4731,7 +4700,6 @@ export class Session {
             const agentId = resolved.agentId;
             await this.unarchiveAgentState(agentId);
             await this.ensureAgentLoaded(agentId);
-            await this.interruptAgentIfRunning(agentId);
             try {
                 this.agentManager.recordUserMessage(agentId, msg.text, {
                     messageId: msg.messageId,