@junctionpanel/server 0.1.18 → 0.1.20

package/dist/server/server/session.js

@@ -17,7 +17,8 @@ import { projectTimelineRows, selectTimelineWindowByProjectedLimit, } from './ag
 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 { listDirectoryEntries, readExplorerFile, getDownloadableFileInfo, } from './file-explorer/service.js';
-import { slugify, validateBranchSlug, listJunctionWorktrees, deleteJunctionWorktree, isJunctionOwnedWorktreeCwd, resolveJunctionWorktreeRootForCwd, createInRepoWorktree, } from '../utils/worktree.js';
+import { slugify, validateBranchSlug, listJunctionWorktrees, deleteJunctionWorktree, isJunctionOwnedWorktreeCwd, resolveJunctionWorktreeRootForCwd, createInRepoWorktree, restoreInRepoWorktree, } from '../utils/worktree.js';
+import { readJunctionWorktreeMetadata } from '../utils/worktree-metadata.js';
 import { runAsyncWorktreeBootstrap } from './worktree-bootstrap.js';
 import { getCheckoutDiff, getCheckoutStatus, getCheckoutStatusLite, listBranchSuggestions, NotGitRepoError, MergeConflictError, MergeFromBaseConflictError, commitChanges, mergeToBase, mergeFromBase, pushCurrentBranch, createPullRequest, getPullRequestStatus, resolveBaseRef, } from '../utils/checkout-git.js';
 import { getProjectIcon } from '../utils/project-icon.js';
@@ -26,11 +27,13 @@ import { searchHomeDirectories, searchWorkspaceEntries, searchGitRepositories, c
 import { cloneRepository } from '../utils/git-clone.js';
 import { initRepository } from '../utils/git-init.js';
 import { resolveClientMessageId } from './client-message-id.js';
+import { deriveProjectGroupingKey, deriveProjectGroupingName } from '../shared/project-grouping.js';
 const execAsync = promisify(exec);
 const READ_ONLY_GIT_ENV = {
     ...process.env,
     GIT_OPTIONAL_LOCKS: '0',
 };
+const DEFAULT_STORED_TIMELINE_FETCH_LIMIT = 200;
 const pendingAgentInitializations = new Map();
 const DEFAULT_AGENT_PROVIDER = AGENT_PROVIDER_IDS[0];
 const CHECKOUT_DIFF_WATCH_DEBOUNCE_MS = 150;
@@ -38,67 +41,7 @@ const CHECKOUT_DIFF_FALLBACK_REFRESH_MS = 5000;
 const TERMINAL_STREAM_WINDOW_BYTES = 256 * 1024;
 const TERMINAL_STREAM_MAX_PENDING_BYTES = 2 * 1024 * 1024;
 const TERMINAL_STREAM_MAX_PENDING_CHUNKS = 2048;
-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 worktreeMarker = '.junction/';
-    const idx = options.cwd.indexOf(worktreeMarker);
-    if (idx !== -1) {
-        return options.cwd.slice(0, idx).replace(/\/$/, '');
-    }
-    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;
-}
+const DIRTY_WORKTREE_CONFIRMATION_REQUIRED = 'dirty_worktree_confirmation_required';
 class SessionRequestError extends Error {
     constructor(code, message) {
         super(message);
@@ -431,6 +374,123 @@ export class Session {
             labels: record.labels,
         };
     }
+    fetchStoredTimeline(record, options) {
+        const rows = (record.timelineRows ?? []).map((row) => ({ ...row }));
+        const epoch = record.timelineEpoch ?? record.id;
+        const nextSeq = record.timelineNextSeq ??
+            (rows.length > 0 ? rows[rows.length - 1].seq + 1 : 1);
+        const minSeq = rows.length > 0 ? rows[0].seq : 0;
+        const maxSeq = rows.length > 0 ? rows[rows.length - 1].seq : 0;
+        const direction = options?.direction ?? 'tail';
+        const requestedLimit = options?.limit;
+        const limit = requestedLimit === undefined
+            ? DEFAULT_STORED_TIMELINE_FETCH_LIMIT
+            : Math.max(0, Math.floor(requestedLimit));
+        const cursor = options?.cursor;
+        const window = { minSeq, maxSeq, nextSeq };
+        if (cursor && cursor.epoch !== epoch) {
+            return {
+                epoch,
+                direction,
+                reset: true,
+                staleCursor: true,
+                gap: false,
+                window,
+                hasOlder: false,
+                hasNewer: false,
+                rows,
+            };
+        }
+        const selectAll = limit === 0;
+        const cloneRows = (items) => items.map((row) => ({ ...row }));
+        if (direction === 'after' && cursor && rows.length > 0 && cursor.seq < minSeq - 1) {
+            return {
+                epoch,
+                direction,
+                reset: true,
+                staleCursor: false,
+                gap: true,
+                window,
+                hasOlder: false,
+                hasNewer: false,
+                rows,
+            };
+        }
+        if (rows.length === 0) {
+            return {
+                epoch,
+                direction,
+                reset: false,
+                staleCursor: false,
+                gap: false,
+                window,
+                hasOlder: false,
+                hasNewer: false,
+                rows: [],
+            };
+        }
+        if (direction === 'tail') {
+            const selected = selectAll || limit >= rows.length ? rows : rows.slice(rows.length - limit);
+            return {
+                epoch,
+                direction,
+                reset: false,
+                staleCursor: false,
+                gap: false,
+                window,
+                hasOlder: selected.length > 0 && selected[0].seq > minSeq,
+                hasNewer: false,
+                rows: cloneRows(selected),
+            };
+        }
+        if (direction === 'after') {
+            const baseSeq = cursor?.seq ?? 0;
+            const startIdx = rows.findIndex((row) => row.seq > baseSeq);
+            if (startIdx < 0) {
+                return {
+                    epoch,
+                    direction,
+                    reset: false,
+                    staleCursor: false,
+                    gap: false,
+                    window,
+                    hasOlder: baseSeq >= minSeq,
+                    hasNewer: false,
+                    rows: [],
+                };
+            }
+            const selected = selectAll ? rows.slice(startIdx) : rows.slice(startIdx, startIdx + limit);
+            const lastSelected = selected[selected.length - 1];
+            return {
+                epoch,
+                direction,
+                reset: false,
+                staleCursor: false,
+                gap: false,
+                window,
+                hasOlder: selected[0].seq > minSeq,
+                hasNewer: Boolean(lastSelected && lastSelected.seq < maxSeq),
+                rows: cloneRows(selected),
+            };
+        }
+        const beforeSeq = cursor?.seq ?? nextSeq;
+        const endExclusive = rows.findIndex((row) => row.seq >= beforeSeq);
+        const boundedRows = endExclusive < 0 ? rows : rows.slice(0, endExclusive);
+        const selected = selectAll || limit >= boundedRows.length
+            ? boundedRows
+            : boundedRows.slice(boundedRows.length - limit);
+        return {
+            epoch,
+            direction,
+            reset: false,
+            staleCursor: false,
+            gap: false,
+            window,
+            hasOlder: selected.length > 0 && selected[0].seq > minSeq,
+            hasNewer: endExclusive >= 0,
+            rows: cloneRows(selected),
+        };
+    }
     async ensureAgentLoaded(agentId) {
         const existing = this.agentManager.getAgent(agentId);
         if (existing) {
@@ -632,6 +692,36 @@ export class Session {
             this.sessionLogger.error({ err: error }, 'Failed to emit agent update');
         }
     }
+    async forwardStoredAgentRecordUpdate(record) {
+        try {
+            const subscription = this.agentUpdatesSubscription;
+            if (!subscription || record.internal) {
+                return;
+            }
+            const payload = this.buildStoredAgentPayload(record);
+            const project = await this.buildProjectPlacement(payload.cwd);
+            const matches = this.matchesAgentFilter({
+                agent: payload,
+                project,
+                filter: subscription.filter,
+            });
+            if (matches) {
+                this.bufferOrEmitAgentUpdate(subscription, {
+                    kind: 'upsert',
+                    agent: payload,
+                    project,
+                });
+                return;
+            }
+            this.bufferOrEmitAgentUpdate(subscription, {
+                kind: 'remove',
+                agentId: payload.id,
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, agentId: record.id }, 'Failed to emit stored agent update');
+        }
+    }
     /**
      * Main entry point for processing session messages
      */
@@ -651,7 +741,10 @@ export class Session {
                     await this.handleDeleteAgentRequest(msg.agentId, msg.requestId);
                     break;
                 case 'archive_agent_request':
-                    await this.handleArchiveAgentRequest(msg.agentId, msg.requestId);
+                    await this.handleArchiveAgentRequest(msg.agentId, msg.requestId, msg.dirtyWorktreeBehavior ?? 'reject');
+                    break;
+                case 'unarchive_agent_request':
+                    await this.handleUnarchiveAgentRequest(msg.agentId, msg.requestId);
                     break;
                 case 'update_agent_request':
                     await this.handleUpdateAgentRequest(msg.agentId, msg.name, msg.labels, msg.requestId);
@@ -821,13 +914,15 @@ export class Session {
             const requestId = msg.requestId;
             if (typeof requestId === 'string') {
                 try {
+                    const message = error instanceof SessionRequestError ? error.message : 'Request failed';
+                    const code = error instanceof SessionRequestError ? error.code : 'handler_error';
                     this.emit({
                         type: 'rpc_error',
                         payload: {
                             requestId,
                             requestType: msg.type,
-                            error: 'Request failed',
-                            code: 'handler_error',
+                            error: message,
+                            code,
                         },
                     });
                 }
@@ -976,9 +1071,10 @@ export class Session {
             });
         }
     }
-    async handleArchiveAgentRequest(agentId, requestId) {
+    async handleArchiveAgentRequest(agentId, requestId, dirtyWorktreeBehavior) {
         this.sessionLogger.info({ agentId }, `Archiving agent ${agentId}`);
-        if (this.agentManager.getAgent(agentId)) {
+        const liveAgent = this.agentManager.getAgent(agentId);
+        if (liveAgent) {
             await this.interruptAgentIfRunning(agentId);
         }
         const archivedAt = new Date().toISOString();
@@ -997,12 +1093,27 @@ export class Session {
                 throw new Error(`Agent not found in storage after snapshot: ${agentId}`);
             }
         }
+        const worktreeArchiveTarget = await this.resolveWorktreeArchiveTargetAfterAgentArchive({
+            archivedAgentId: agentId,
+            archivedAgentCwd: archivedRecord.cwd,
+        });
+        if (worktreeArchiveTarget &&
+            dirtyWorktreeBehavior !== 'discard' &&
+            (await this.hasDirtyWorktreeState(worktreeArchiveTarget.targetPath))) {
+            throw new SessionRequestError(DIRTY_WORKTREE_CONFIRMATION_REQUIRED, 'Archiving this agent will discard uncommitted or untracked files in the worktree.');
+        }
         archivedRecord = {
             ...archivedRecord,
             archivedAt,
+            archivedWorktree: await this.buildArchivedWorktreeState(archivedRecord.cwd, archivedAt),
         };
         await this.agentStorage.upsert(archivedRecord);
-        this.agentManager.notifyAgentState(agentId);
+        if (liveAgent) {
+            this.agentManager.notifyAgentState(agentId);
+        }
+        else {
+            await this.forwardStoredAgentRecordUpdate(archivedRecord);
+        }
         this.emit({
             type: 'agent_archived',
             payload: {
@@ -1011,11 +1122,124 @@ export class Session {
                 requestId,
             },
         });
-        await this.maybeArchiveWorktreeAfterLastAgentArchived({
-            archivedAgentId: agentId,
-            archivedAgentCwd: archivedRecord.cwd,
-            requestId,
+        if (worktreeArchiveTarget) {
+            try {
+                await this.archiveJunctionWorktree({
+                    targetPath: worktreeArchiveTarget.targetPath,
+                    repoRoot: worktreeArchiveTarget.repoRoot,
+                    requestId,
+                });
+            }
+            catch (error) {
+                this.sessionLogger.warn({ err: error, agentId, cwd: archivedRecord.cwd }, 'Failed to auto-archive worktree after agent archive');
+            }
+        }
+    }
+    async handleUnarchiveAgentRequest(agentId, requestId) {
+        this.sessionLogger.info({ agentId }, `Unarchiving agent ${agentId}`);
+        const record = await this.agentStorage.get(agentId);
+        if (!record) {
+            throw new Error(`Agent not found: ${agentId}`);
+        }
+        let nextRecord = {
+            ...record,
+            archivedAt: null,
+        };
+        let restoredWorktree = null;
+        if (record.archivedWorktree?.cleanupState === 'deleted') {
+            restoredWorktree = await restoreInRepoWorktree({
+                repoRoot: record.archivedWorktree.repoRoot,
+                baseBranch: record.archivedWorktree.baseBranch,
+                branchName: record.archivedWorktree.branchName,
+                worktreeSlug: record.archivedWorktree.worktreeSlug,
+                runSetup: false,
+            });
+            nextRecord = {
+                ...nextRecord,
+                cwd: restoredWorktree.worktreePath,
+                archivedWorktree: {
+                    ...record.archivedWorktree,
+                    originalCwd: restoredWorktree.worktreePath,
+                    cleanupState: 'active',
+                    cleanedUpAt: null,
+                },
+            };
+        }
+        await this.agentStorage.upsert(nextRecord);
+        const liveAgent = this.agentManager.getAgent(agentId);
+        if (liveAgent) {
+            this.agentManager.notifyAgentState(agentId);
+        }
+        else {
+            await this.forwardStoredAgentRecordUpdate(nextRecord);
+        }
+        this.emit({
+            type: 'agent_unarchived',
+            payload: {
+                agentId,
+                requestId,
+            },
         });
+        if (restoredWorktree) {
+            void runAsyncWorktreeBootstrap({
+                agentId,
+                worktree: restoredWorktree,
+                terminalManager: this.terminalManager,
+                appendTimelineItem: (item) => appendTimelineItemIfAgentKnown({
+                    agentManager: this.agentManager,
+                    agentId,
+                    item,
+                }),
+                emitLiveTimelineItem: (item) => emitLiveTimelineItemIfAgentKnown({
+                    agentManager: this.agentManager,
+                    agentId,
+                    item,
+                }),
+                logger: this.sessionLogger,
+            });
+        }
+    }
+    async buildArchivedWorktreeState(cwd, archivedAt) {
+        try {
+            const ownership = await isJunctionOwnedWorktreeCwd(cwd, {
+                junctionHome: this.junctionHome,
+            });
+            if (!ownership.allowed || !ownership.repoRoot) {
+                return null;
+            }
+            const resolvedWorktree = await resolveJunctionWorktreeRootForCwd(cwd, {
+                junctionHome: this.junctionHome,
+            });
+            if (!resolvedWorktree) {
+                return null;
+            }
+            const metadata = readJunctionWorktreeMetadata(resolvedWorktree.worktreePath);
+            if (!metadata?.baseRefName) {
+                return null;
+            }
+            const { stdout } = await execAsync('git branch --show-current', {
+                cwd: resolvedWorktree.worktreePath,
+                env: READ_ONLY_GIT_ENV,
+            });
+            const branchName = stdout.trim();
+            if (!branchName) {
+                return null;
+            }
+            return {
+                repoRoot: ownership.repoRoot,
+                baseBranch: metadata.baseRefName,
+                branchName,
+                worktreeSlug: basename(resolvedWorktree.worktreePath),
+                originalCwd: resolvedWorktree.worktreePath,
+                cleanupState: 'active',
+                archivedAt,
+                cleanedUpAt: null,
+            };
+        }
+        catch (error) {
+            this.sessionLogger.warn({ err: error, cwd }, 'Failed to capture archived worktree restore metadata');
+            return null;
+        }
     }
     async getArchivedAt(agentId) {
         const record = await this.agentStorage.get(agentId);
@@ -1095,6 +1319,11 @@ export class Session {
      */
     async handleSendAgentMessage(agentId, text, messageId, images, runOptions) {
         this.sessionLogger.info({ agentId, textPreview: text.substring(0, 50), imageCount: images?.length ?? 0 }, `Sending text to agent ${agentId}${images && images.length > 0 ? ` with ${images.length} image attachment(s)` : ''}`);
+        const archivedAt = await this.getArchivedAt(agentId);
+        if (archivedAt) {
+            this.handleAgentRunError(agentId, new Error(`Agent ${agentId} is archived`), 'Refusing to send prompt to archived agent');
+            return;
+        }
         try {
             await this.ensureAgentLoaded(agentId);
         }
@@ -1102,11 +1331,6 @@ export class Session {
             this.handleAgentRunError(agentId, error, 'Failed to initialize agent before sending prompt');
             return;
         }
-        const archivedAt = await this.getArchivedAt(agentId);
-        if (archivedAt) {
-            this.handleAgentRunError(agentId, new Error(`Agent ${agentId} is archived`), 'Refusing to send prompt to archived agent');
-            return;
-        }
         try {
             await this.interruptAgentIfRunning(agentId);
         }
@@ -2695,58 +2919,59 @@ export class Session {
             });
         }
     }
-    async maybeArchiveWorktreeAfterLastAgentArchived(options) {
-        try {
-            const ownership = await isJunctionOwnedWorktreeCwd(options.archivedAgentCwd, {
-                junctionHome: this.junctionHome,
-            });
-            if (!ownership.allowed) {
-                return;
-            }
-            const resolvedWorktree = await resolveJunctionWorktreeRootForCwd(options.archivedAgentCwd, {
-                junctionHome: this.junctionHome,
-            });
-            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;
+    async resolveWorktreeArchiveTargetAfterAgentArchive(options) {
+        const ownership = await isJunctionOwnedWorktreeCwd(options.archivedAgentCwd, {
+            junctionHome: this.junctionHome,
+        });
+        if (!ownership.allowed) {
+            return null;
+        }
+        const resolvedWorktree = await resolveJunctionWorktreeRootForCwd(options.archivedAgentCwd, {
+            junctionHome: this.junctionHome,
+        });
+        if (!resolvedWorktree) {
+            return null;
+        }
+        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;
             }
-            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;
+            return this.isPathWithinRoot(targetPath, record.cwd);
+        });
+        if (hasRemainingNonArchivedRecord) {
+            return null;
+        }
+        const hasUnknownLiveAgent = this.agentManager.listAgents().some((agent) => {
+            if (agent.id === options.archivedAgentId) {
+                return false;
             }
-            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;
+            if (!this.isPathWithinRoot(targetPath, agent.cwd)) {
+                return false;
             }
-            await this.archiveJunctionWorktree({
-                targetPath,
-                repoRoot,
-                requestId: options.requestId,
-            });
+            return !recordsById.has(agent.id);
+        });
+        if (hasUnknownLiveAgent) {
+            return null;
         }
-        catch (error) {
-            this.sessionLogger.warn({ err: error, agentId: options.archivedAgentId, cwd: options.archivedAgentCwd }, 'Failed to auto-archive worktree after agent archive');
+        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 null;
         }
+        return {
+            targetPath,
+            repoRoot,
+        };
+    }
+    async hasDirtyWorktreeState(cwd) {
+        const { stdout } = await execAsync('git status --porcelain', {
+            cwd,
+            env: READ_ONLY_GIT_ENV,
+        });
+        return stdout.trim().length > 0;
     }
     async archiveJunctionWorktree(options) {
         let targetPath = options.targetPath;
@@ -2757,16 +2982,32 @@ export class Session {
             targetPath = resolvedWorktree.worktreePath;
         }
         const removedAgents = new Set();
+        const preservedArchivedRecords = new Map();
+        const cleanedUpAt = new Date().toISOString();
         const agents = this.agentManager.listAgents();
         for (const agent of agents) {
             if (this.isPathWithinRoot(targetPath, agent.cwd)) {
-                removedAgents.add(agent.id);
                 try {
                     await this.agentManager.closeAgent(agent.id);
                 }
                 catch {
                     // ignore cleanup errors
                 }
+                const record = await this.agentStorage.get(agent.id);
+                if (record?.archivedAt) {
+                    preservedArchivedRecords.set(agent.id, {
+                        ...record,
+                        archivedWorktree: record.archivedWorktree
+                            ? {
+                                ...record.archivedWorktree,
+                                cleanupState: 'deleted',
+                                cleanedUpAt,
+                            }
+                            : record.archivedWorktree,
+                    });
+                    continue;
+                }
+                removedAgents.add(agent.id);
                 try {
                     await this.agentStorage.remove(agent.id);
                 }
@@ -2778,6 +3019,19 @@ export class Session {
         const registryRecords = await this.agentStorage.list();
         for (const record of registryRecords) {
             if (this.isPathWithinRoot(targetPath, record.cwd)) {
+                if (record.archivedAt) {
+                    preservedArchivedRecords.set(record.id, {
+                        ...record,
+                        archivedWorktree: record.archivedWorktree
+                            ? {
+                                ...record.archivedWorktree,
+                                cleanupState: 'deleted',
+                                cleanedUpAt,
+                            }
+                            : record.archivedWorktree,
+                    });
+                    continue;
+                }
                 removedAgents.add(record.id);
                 try {
                     await this.agentStorage.remove(record.id);
@@ -2793,6 +3047,9 @@ export class Session {
             worktreePath: targetPath,
             junctionHome: this.junctionHome,
         });
+        for (const record of preservedArchivedRecords.values()) {
+            await this.agentStorage.upsert(record);
+        }
         for (const agentId of removedAgents) {
             this.emit({
                 type: 'agent_deleted',
@@ -3496,14 +3753,38 @@ export class Session {
             }
             : undefined;
         try {
-            const snapshot = await this.ensureAgentLoaded(msg.agentId);
-            let timeline = this.agentManager.fetchTimeline(msg.agentId, {
-                direction,
-                cursor,
-                limit: shouldLimitByProjectedWindow && typeof requestedLimit === 'number'
-                    ? Math.max(1, Math.floor(requestedLimit))
-                    : limit,
-            });
+            const liveAgent = this.agentManager.getAgent(msg.agentId);
+            const storedRecord = liveAgent ? null : await this.agentStorage.get(msg.agentId);
+            const fetchLimit = shouldLimitByProjectedWindow && typeof requestedLimit === 'number'
+                ? Math.max(1, Math.floor(requestedLimit))
+                : limit;
+            let provider;
+            let timeline;
+            if (liveAgent) {
+                provider = liveAgent.provider;
+                timeline = this.agentManager.fetchTimeline(msg.agentId, {
+                    direction,
+                    cursor,
+                    limit: fetchLimit,
+                });
+            }
+            else if (storedRecord?.archivedAt) {
+                provider = coerceAgentProvider(this.sessionLogger, storedRecord.provider, storedRecord.id);
+                timeline = this.fetchStoredTimeline(storedRecord, {
+                    direction,
+                    cursor,
+                    limit: fetchLimit,
+                });
+            }
+            else {
+                const snapshot = await this.ensureAgentLoaded(msg.agentId);
+                provider = snapshot.provider;
+                timeline = this.agentManager.fetchTimeline(msg.agentId, {
+                    direction,
+                    cursor,
+                    limit: fetchLimit,
+                });
+            }
             let hasOlder = timeline.hasOlder;
             let hasNewer = timeline.hasNewer;
             let startCursor = null;
@@ -3511,10 +3792,10 @@ export class Session {
             let entries;
             if (shouldLimitByProjectedWindow) {
                 const projectedLimit = Math.max(1, Math.floor(requestedLimit));
-                let fetchLimit = projectedLimit;
+                let projectedFetchLimit = projectedLimit;
                 let projectedWindow = selectTimelineWindowByProjectedLimit({
                     rows: timeline.rows,
-                    provider: snapshot.provider,
+                    provider,
                     direction,
                     limit: projectedLimit,
                     collapseToolLifecycle: false,
@@ -3531,26 +3812,33 @@ export class Session {
                         break;
                     }
                     const maxRows = Math.max(0, timeline.window.maxSeq - timeline.window.minSeq + 1);
-                    const nextFetchLimit = Math.min(maxRows, fetchLimit * 2);
-                    if (nextFetchLimit <= fetchLimit) {
+                    const nextFetchLimit = Math.min(maxRows, projectedFetchLimit * 2);
+                    if (nextFetchLimit <= projectedFetchLimit) {
                         break;
                     }
-                    fetchLimit = nextFetchLimit;
-                    timeline = this.agentManager.fetchTimeline(msg.agentId, {
-                        direction,
-                        cursor,
-                        limit: fetchLimit,
-                    });
+                    projectedFetchLimit = nextFetchLimit;
+                    timeline =
+                        storedRecord?.archivedAt && !liveAgent
+                            ? this.fetchStoredTimeline(storedRecord, {
+                                direction,
+                                cursor,
+                                limit: projectedFetchLimit,
+                            })
+                            : this.agentManager.fetchTimeline(msg.agentId, {
+                                direction,
+                                cursor,
+                                limit: projectedFetchLimit,
+                            });
                     projectedWindow = selectTimelineWindowByProjectedLimit({
                         rows: timeline.rows,
-                        provider: snapshot.provider,
+                        provider,
                         direction,
                         limit: projectedLimit,
                         collapseToolLifecycle: false,
                     });
                 }
                 const selectedRows = projectedWindow.selectedRows;
-                entries = projectTimelineRows(selectedRows, snapshot.provider, projection);
+                entries = projectTimelineRows(selectedRows, provider, projection);
                 if (projectedWindow.minSeq !== null && projectedWindow.maxSeq !== null) {
                     startCursor = { epoch: timeline.epoch, seq: projectedWindow.minSeq };
                     endCursor = { epoch: timeline.epoch, seq: projectedWindow.maxSeq };
@@ -3563,7 +3851,7 @@ export class Session {
                 const lastRow = timeline.rows[timeline.rows.length - 1];
                 startCursor = firstRow ? { epoch: timeline.epoch, seq: firstRow.seq } : null;
                 endCursor = lastRow ? { epoch: timeline.epoch, seq: lastRow.seq } : null;
-                entries = projectTimelineRows(timeline.rows, snapshot.provider, projection);
+                entries = projectTimelineRows(timeline.rows, provider, projection);
             }
             this.emit({
                 type: 'fetch_agent_timeline_response',