@getpaseo/server 0.1.84 → 0.1.86

package/dist/server/server/agent/providers/tool-call-mapper-utils.js

@@ -112,6 +112,68 @@ export function flattenReadContent(value) {
     }
     return (nonEmptyString(value.text) ?? nonEmptyString(value.content) ?? nonEmptyString(value.output));
 }
+// Claude's Read tool returns `cat -n`-style content: each line prefixed with a
+// right-aligned line number and a tab (`␣␣␣1\timport ...`). Other providers
+// return raw source. We strip the gutter here so `read.content` is uniformly
+// raw source across providers, and surface the first line number as `offset`
+// so the client can rebuild the gutter itself. Guarded tightly (first line must
+// match, near-total match ratio, strictly sequential numbering) so real source
+// is never mistaken for a gutter.
+const READ_GUTTER_LINE = /^\s*(\d+)\t(.*)$/;
+export function stripReadLineNumberGutter(content) {
+    const text = nonEmptyString(content);
+    if (!text) {
+        return undefined;
+    }
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const stripped = [];
+    let nonEmpty = 0;
+    let matched = 0;
+    let startLine;
+    let prevNumber;
+    let sequential = true;
+    let firstNonEmptyMatched = false;
+    let sawNonEmpty = false;
+    for (const line of lines) {
+        if (line.length === 0) {
+            stripped.push(line);
+            continue;
+        }
+        nonEmpty += 1;
+        const match = line.match(READ_GUTTER_LINE);
+        if (!match) {
+            if (!sawNonEmpty) {
+                return undefined;
+            }
+            stripped.push(line);
+            sawNonEmpty = true;
+            continue;
+        }
+        if (!sawNonEmpty) {
+            firstNonEmptyMatched = true;
+        }
+        sawNonEmpty = true;
+        matched += 1;
+        const lineNumber = Number.parseInt(match[1], 10);
+        if (startLine === undefined) {
+            startLine = lineNumber;
+        }
+        if (prevNumber !== undefined && lineNumber !== prevNumber + 1) {
+            sequential = false;
+        }
+        prevNumber = lineNumber;
+        stripped.push(match[2]);
+    }
+    if (!firstNonEmptyMatched || !sequential || nonEmpty === 0) {
+        return undefined;
+    }
+    // Sequential numbering from the first line is already a strong signal; the
+    // ratio only rejects source that has a couple of coincidental matches.
+    if (matched / nonEmpty < 0.5) {
+        return undefined;
+    }
+    return { content: stripped.join("\n"), startLine };
+}
 export function truncateDiffText(text, maxChars = 12000) {
     if (typeof text !== "string") {
         return undefined;

package/dist/server/server/agent/structured-generation-providers.d.ts

@@ -0,0 +1,29 @@
+import type { AgentProvider } from "./agent-sdk-types.js";
+import type { StructuredGenerationProvider } from "./agent-response-loop.js";
+import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
+export interface StructuredGenerationDaemonConfig {
+    metadataGeneration?: {
+        providers?: Array<{
+            provider: string;
+            model?: string;
+            thinkingOptionId?: string;
+        }>;
+    };
+}
+export interface StructuredGenerationProviderIdentifier {
+    modelSubstring: string;
+    thinkingOptionId?: string;
+}
+export declare const DEFAULT_STRUCTURED_GENERATION_PROVIDERS: readonly StructuredGenerationProviderIdentifier[];
+export interface ResolveStructuredGenerationProvidersOptions {
+    cwd: string;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "listProviders">;
+    daemonConfig?: StructuredGenerationDaemonConfig | null;
+    currentSelection?: {
+        provider?: AgentProvider | null;
+        model?: string | null;
+        thinkingOptionId?: string | null;
+    };
+}
+export declare function resolveStructuredGenerationProviders(options: ResolveStructuredGenerationProvidersOptions): Promise<StructuredGenerationProvider[]>;
+//# sourceMappingURL=structured-generation-providers.d.ts.map

package/dist/server/server/agent/structured-generation-providers.js

@@ -0,0 +1,192 @@
+export const DEFAULT_STRUCTURED_GENERATION_PROVIDERS = [
+    { modelSubstring: "haiku" },
+    { modelSubstring: "gpt-5.4-mini", thinkingOptionId: "low" },
+    { modelSubstring: "minimax-m2.5" },
+    { modelSubstring: "nemotron-3-super" },
+];
+export async function resolveStructuredGenerationProviders(options) {
+    const providerEntries = await options.providerSnapshotManager.listProviders({
+        cwd: options.cwd,
+        wait: true,
+    });
+    const enabledEntries = providerEntries.filter((entry) => entry.enabled);
+    const modelEntries = enabledEntries.filter((entry) => (entry.models?.length ?? 0) > 0);
+    const entriesByProvider = new Map(enabledEntries.map((entry) => [entry.provider, entry]));
+    const providers = [];
+    for (const configured of readConfiguredProviders(options.daemonConfig)) {
+        const resolvedConfigured = resolveConfiguredCandidate(configured, modelEntries, entriesByProvider);
+        if (!resolvedConfigured) {
+            continue;
+        }
+        providers.push(resolvedConfigured);
+    }
+    for (const identifier of DEFAULT_STRUCTURED_GENERATION_PROVIDERS) {
+        const resolved = resolveByModelSubstring(modelEntries, identifier);
+        if (resolved) {
+            providers.push(resolved);
+        }
+    }
+    const currentSelection = resolveCurrentSelection(options.currentSelection, modelEntries, entriesByProvider);
+    if (currentSelection) {
+        providers.push(currentSelection);
+    }
+    return dedupeProviders(providers);
+}
+function resolveCurrentSelection(selection, readyEntries, entriesByProvider) {
+    if (!selection) {
+        return null;
+    }
+    const provider = selection.provider?.trim();
+    if (!provider) {
+        return null;
+    }
+    const normalized = resolveConfiguredCandidate({
+        provider,
+        ...(selection.model ? { model: selection.model } : {}),
+        ...(selection.thinkingOptionId ? { thinkingOptionId: selection.thinkingOptionId } : {}),
+    }, readyEntries, entriesByProvider);
+    if (normalized) {
+        return normalized;
+    }
+    const explicitModel = selection.model?.trim();
+    if (explicitModel) {
+        return {
+            provider,
+            model: explicitModel,
+            ...(selection.thinkingOptionId ? { thinkingOptionId: selection.thinkingOptionId } : {}),
+        };
+    }
+    const model = selectDefaultModel(entriesByProvider.get(provider)?.models ?? []);
+    if (!model) {
+        return { provider };
+    }
+    const thinkingOptionId = resolveThinkingOptionId(model, selection.thinkingOptionId);
+    return {
+        provider,
+        model: model.id,
+        ...(thinkingOptionId ? { thinkingOptionId } : {}),
+    };
+}
+function resolveConfiguredCandidate(candidate, readyEntries, entriesByProvider) {
+    const provider = candidate.provider.trim();
+    if (!provider) {
+        return null;
+    }
+    const topLevelEntry = entriesByProvider.get(provider);
+    const configuredModel = candidate.model?.trim();
+    if (topLevelEntry) {
+        if (configuredModel) {
+            return {
+                provider,
+                model: configuredModel,
+                ...(candidate.thinkingOptionId ? { thinkingOptionId: candidate.thinkingOptionId } : {}),
+            };
+        }
+        const model = selectDefaultModel(topLevelEntry.models ?? []);
+        const thinkingOptionId = resolveThinkingOptionId(model, candidate.thinkingOptionId);
+        return {
+            provider,
+            ...(model ? { model: model.id } : {}),
+            ...(thinkingOptionId ? { thinkingOptionId } : {}),
+        };
+    }
+    if (!configuredModel) {
+        return {
+            provider,
+            ...(candidate.thinkingOptionId ? { thinkingOptionId: candidate.thinkingOptionId } : {}),
+        };
+    }
+    const nestedMatch = resolveNestedProviderModel(provider, configuredModel, readyEntries);
+    if (!nestedMatch) {
+        return {
+            provider,
+            model: configuredModel,
+            ...(candidate.thinkingOptionId ? { thinkingOptionId: candidate.thinkingOptionId } : {}),
+        };
+    }
+    const thinkingOptionId = resolveThinkingOptionId(nestedMatch.model, candidate.thinkingOptionId);
+    return {
+        provider: nestedMatch.provider,
+        model: nestedMatch.model.id,
+        ...(thinkingOptionId ? { thinkingOptionId } : {}),
+    };
+}
+function resolveNestedProviderModel(providerId, modelId, entries) {
+    const normalizedProviderId = providerId.trim().toLowerCase();
+    const normalizedModelId = modelId.trim().toLowerCase();
+    for (const entry of entries) {
+        for (const model of entry.models ?? []) {
+            const modelProviderId = readModelMetadataString(model, "providerId")?.toLowerCase();
+            const nestedModelId = readModelMetadataString(model, "modelId")?.toLowerCase();
+            if (modelProviderId !== normalizedProviderId) {
+                continue;
+            }
+            if (normalizedModelId === model.id.toLowerCase() ||
+                normalizedModelId === nestedModelId ||
+                model.id.toLowerCase() === `${normalizedProviderId}/${normalizedModelId}`) {
+                return { provider: entry.provider, model };
+            }
+        }
+    }
+    return null;
+}
+function resolveByModelSubstring(entries, identifier) {
+    const needle = identifier.modelSubstring.trim().toLowerCase();
+    if (!needle) {
+        return null;
+    }
+    for (const entry of entries) {
+        for (const model of entry.models ?? []) {
+            const haystacks = [model.id, model.label].map((value) => value.toLowerCase());
+            if (!haystacks.some((value) => value.includes(needle))) {
+                continue;
+            }
+            const thinkingOptionId = resolveThinkingOptionId(model, identifier.thinkingOptionId);
+            return {
+                provider: entry.provider,
+                model: model.id,
+                ...(thinkingOptionId ? { thinkingOptionId } : {}),
+            };
+        }
+    }
+    return null;
+}
+function readConfiguredProviders(daemonConfig) {
+    const metadataGeneration = daemonConfig?.metadataGeneration;
+    if (!metadataGeneration || typeof metadataGeneration !== "object") {
+        return [];
+    }
+    const providers = "providers" in metadataGeneration ? metadataGeneration.providers : undefined;
+    return Array.isArray(providers) ? providers : [];
+}
+function selectDefaultModel(models) {
+    return models.find((model) => model.isDefault) ?? models[0] ?? null;
+}
+function resolveThinkingOptionId(model, preferredThinkingOptionId) {
+    if (!model) {
+        return undefined;
+    }
+    if (preferredThinkingOptionId &&
+        model.thinkingOptions?.some((option) => option.id === preferredThinkingOptionId)) {
+        return preferredThinkingOptionId;
+    }
+    return model.defaultThinkingOptionId;
+}
+function dedupeProviders(providers) {
+    const seen = new Set();
+    const deduped = [];
+    for (const provider of providers) {
+        const key = [provider.provider, provider.model ?? "", provider.thinkingOptionId ?? ""].join("\0");
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(provider);
+    }
+    return deduped;
+}
+function readModelMetadataString(model, key) {
+    const value = model.metadata?.[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+//# sourceMappingURL=structured-generation-providers.js.map

package/dist/server/server/auto-archive-on-merge/archive-if-safe.d.ts

@@ -2,7 +2,6 @@ import type { Logger } from "pino";
 import type { AgentManager } from "../agent/agent-manager.js";
 import type { AgentStorage } from "../agent/agent-storage.js";
 import type { DaemonConfigStore } from "../daemon-config-store.js";
-import type { SessionOutboundMessage } from "../messages.js";
 import { archivePaseoWorktree, killTerminalsUnderPath } from "../paseo-worktree-archive-service.js";
 import { isSameOrDescendantPath } from "../path-utils.js";
 import type { WorkspaceGitRuntimeSnapshot, WorkspaceGitServiceImpl } from "../workspace-git-service.js";
@@ -21,7 +20,6 @@ export interface AutoArchiveArchiveOptions {
     markWorkspaceArchiving: (workspaceIds: Iterable<string>, archivingAt: string) => void;
     clearWorkspaceArchiving: (workspaceIds: Iterable<string>) => void;
     emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds: Iterable<string>) => Promise<void>;
-    emitSessionMessage: (message: SessionOutboundMessage) => void;
 }
 export interface ArchiveIfSafeDependencies {
     archivePaseoWorktree: typeof archivePaseoWorktree;

package/dist/server/server/auto-archive-on-merge/archive-if-safe.js

@@ -49,7 +49,6 @@ export async function archiveIfSafe(input) {
                 agentManager: options.agentManager,
                 agentStorage: options.agentStorage,
                 archiveWorkspaceRecord: options.archiveWorkspaceRecord,
-                emit: options.emitSessionMessage,
                 emitWorkspaceUpdatesForWorkspaceIds: options.emitWorkspaceUpdatesForWorkspaceIds,
                 markWorkspaceArchiving: options.markWorkspaceArchiving,
                 clearWorkspaceArchiving: options.clearWorkspaceArchiving,

package/dist/server/server/bootstrap.d.ts

@@ -76,6 +76,13 @@ export interface PaseoDaemonConfig {
     dictationFinalTimeoutMs?: number;
     downloadTokenTtlMs?: number;
     agentProviderSettings?: AgentProviderRuntimeSettingsMap;
+    metadataGeneration?: {
+        providers?: Array<{
+            provider: string;
+            model?: string;
+            thinkingOptionId?: string;
+        }>;
+    };
     providerOverrides?: Record<string, ProviderOverride>;
     log?: PersistedConfig["log"];
     onLifecycleIntent?: (intent: DaemonLifecycleIntent) => void;

package/dist/server/server/bootstrap.js

@@ -169,6 +169,9 @@ export async function createPaseoDaemon(config, rootLogger) {
                 ...(override.additionalModels ? { additionalModels: override.additionalModels } : {}),
             },
         ])),
+        metadataGeneration: {
+            providers: config.metadataGeneration?.providers ?? [],
+        },
         autoArchiveAfterMerge: config.autoArchiveAfterMerge ?? false,
         appendSystemPrompt: config.appendSystemPrompt ?? "",
     }, logger);
@@ -417,6 +420,14 @@ export async function createPaseoDaemon(config, rootLogger) {
         agentStorage,
     });
     await scheduleService.start();
+    agentManager.setAgentArchivedCallback(async (agentId) => {
+        try {
+            await scheduleService.deleteForAgent(agentId);
+        }
+        catch (error) {
+            logger.warn({ err: error, agentId }, "Failed to delete schedules for archived agent");
+        }
+    });
     logger.info({ elapsed: elapsed() }, "Schedule service initialized");
     logger.info({ elapsed: elapsed() }, "Loading persisted agent registry");
     const persistedRecords = await agentStorage.list();
@@ -467,7 +478,6 @@ export async function createPaseoDaemon(config, rootLogger) {
         markWorkspaceArchiving: markWorkspaceArchivingExternal,
         clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
         emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
-        emitSessionMessage: emitExternalSessionMessage,
     });
     const mcpEnabled = config.mcpEnabled ?? true;
     let agentMcpBaseUrl = null;
@@ -488,7 +498,6 @@ export async function createPaseoDaemon(config, rootLogger) {
                 emitWorkspaceUpdatesForWorkspaceIds: emitWorkspaceUpdatesExternal,
                 markWorkspaceArchiving: markWorkspaceArchivingExternal,
                 clearWorkspaceArchiving: clearWorkspaceArchivingExternal,
-                emitSessionMessage: emitExternalSessionMessage,
                 createPaseoWorktree: async (input, serviceOptions) => {
                     return createPaseoWorktreeWorkflow({
                         paseoHome: config.paseoHome,

package/dist/server/server/config.js

@@ -207,6 +207,7 @@ export function loadConfig(paseoHome, options) {
         voiceLlmProviderExplicit: voiceLlm.providerExplicit,
         voiceLlmModel: voiceLlm.model,
         agentProviderSettings: extractAgentProviderSettings(providerOverrides),
+        metadataGeneration: persisted.agents?.metadataGeneration,
         providerOverrides,
         log: resolveLogConfigFromEnv(env, persisted),
     };

package/dist/server/server/daemon-config-store.js

@@ -114,8 +114,29 @@ export class DaemonConfigStore {
 }
 function mergeMutableConfigIntoPersistedConfig(params) {
     const { persisted, mutable } = params;
+    const metadataGenerationProviders = readMetadataGenerationProviders(mutable);
     const providerOverrides = applyMutableProviderConfigToOverrides(persisted.agents?.providers, mutable.providers);
     const persistedAgents = persisted.agents;
+    const persistedMetadataGeneration = {
+        providers: metadataGenerationProviders,
+    };
+    const shouldPersistMetadataGeneration = metadataGenerationProviders.length > 0 || persisted.agents?.metadataGeneration !== undefined;
+    let nextAgents = persisted.agents;
+    if (providerOverrides && Object.keys(providerOverrides).length > 0) {
+        nextAgents = {
+            ...persistedAgents,
+            providers: providerOverrides,
+            ...(shouldPersistMetadataGeneration
+                ? { metadataGeneration: persistedMetadataGeneration }
+                : {}),
+        };
+    }
+    else if (shouldPersistMetadataGeneration) {
+        nextAgents = {
+            ...persistedAgents,
+            metadataGeneration: persistedMetadataGeneration,
+        };
+    }
     return {
         ...persisted,
         daemon: {
@@ -127,12 +148,31 @@ function mergeMutableConfigIntoPersistedConfig(params) {
             autoArchiveAfterMerge: mutable.autoArchiveAfterMerge,
             appendSystemPrompt: mutable.appendSystemPrompt,
         },
-        agents: providerOverrides && Object.keys(providerOverrides).length > 0
-            ? {
-                ...persistedAgents,
-                providers: providerOverrides,
-            }
-            : persisted.agents,
+        agents: nextAgents,
     };
 }
+function readMetadataGenerationProviders(mutable) {
+    const metadataGeneration = mutable.metadataGeneration;
+    if (!isRecord(metadataGeneration)) {
+        return [];
+    }
+    const providers = metadataGeneration["providers"];
+    if (!Array.isArray(providers)) {
+        return [];
+    }
+    return providers.flatMap((entry) => {
+        if (!isRecord(entry) || typeof entry["provider"] !== "string") {
+            return [];
+        }
+        return [
+            {
+                provider: entry["provider"],
+                ...(typeof entry["model"] === "string" ? { model: entry["model"] } : {}),
+                ...(typeof entry["thinkingOptionId"] === "string"
+                    ? { thinkingOptionId: entry["thinkingOptionId"] }
+                    : {}),
+            },
+        ];
+    });
+}
 //# sourceMappingURL=daemon-config-store.js.map

package/dist/server/server/daemon-worker.js

@@ -2,6 +2,7 @@ import { createPaseoDaemon } from "./bootstrap.js";
 import { loadConfig } from "./config.js";
 import { resolvePaseoHome } from "./paseo-home.js";
 import { createRootLogger } from "./logger.js";
+process.title = "Paseo Daemon";
 function bootstrapFromEnvironment() {
     try {
         const paseoHome = resolvePaseoHome();

package/dist/server/server/file-explorer/service.js

@@ -1,6 +1,6 @@
 import { constants, promises as fs } from "fs";
 import path from "path";
-import { resolvePathFromBase } from "../path-utils.js";
+import { expandUserPath, resolvePathFromBase } from "../path-utils.js";
 const TEXT_MIME_TYPES = {
     ".json": "application/json",
 };
@@ -168,7 +168,7 @@ export async function getDownloadableFileInfo({ root, relativePath }) {
     }
 }
 async function resolveScopedPath({ root, relativePath = ".", }) {
-    const normalizedRoot = path.resolve(root);
+    const normalizedRoot = expandUserPath(root);
     const requestedPath = resolvePathFromBase(normalizedRoot, relativePath);
     const relative = path.relative(normalizedRoot, requestedPath);
     if (relative !== "" && (relative.startsWith("..") || path.isAbsolute(relative))) {
@@ -215,8 +215,8 @@ function isOutsideWorkspaceError(error) {
     return error instanceof Error && error.message === ACCESS_OUTSIDE_WORKSPACE_MESSAGE;
 }
 function normalizeRelativePath({ root, targetPath }) {
-    const normalizedRoot = path.resolve(root);
-    const normalizedTarget = path.resolve(targetPath);
+    const normalizedRoot = expandUserPath(root);
+    const normalizedTarget = expandUserPath(targetPath);
     const relative = path.relative(normalizedRoot, normalizedTarget);
     return relative === "" ? "." : relative.split(path.sep).join("/");
 }

package/dist/server/server/paseo-worktree-archive-service.d.ts

@@ -1,19 +1,16 @@
 import type { Logger } from "pino";
 import type { AgentManager } from "./agent/agent-manager.js";
 import type { AgentStorage } from "./agent/agent-storage.js";
-import type { SessionOutboundMessage } from "./messages.js";
 import type { WorkspaceGitService } from "./workspace-git-service.js";
 import type { GitHubService } from "../services/github-service.js";
 import type { TerminalManager } from "../terminal/terminal-manager.js";
-type EmitSessionMessage = (message: SessionOutboundMessage) => void;
 export interface ArchivePaseoWorktreeDependencies {
     paseoHome?: string;
     github: GitHubService;
     workspaceGitService: Pick<WorkspaceGitService, "getSnapshot">;
-    agentManager: Pick<AgentManager, "listAgents" | "closeAgent">;
-    agentStorage: Pick<AgentStorage, "list" | "remove">;
+    agentManager: Pick<AgentManager, "listAgents" | "archiveAgent" | "archiveSnapshot">;
+    agentStorage: Pick<AgentStorage, "list">;
     archiveWorkspaceRecord: (workspaceId: string) => Promise<void>;
-    emit: EmitSessionMessage;
     emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds: Iterable<string>) => Promise<void>;
     markWorkspaceArchiving: (workspaceIds: Iterable<string>, archivingAt: string) => void;
     clearWorkspaceArchiving: (workspaceIds: Iterable<string>) => void;
@@ -39,5 +36,4 @@ export declare function archivePaseoWorktree(dependencies: ArchivePaseoWorktreeD
     requestId: string;
 }): Promise<string[]>;
 export declare function killTerminalsUnderPath(dependencies: KillTerminalsUnderPathDependencies, rootPath: string): Promise<void>;
-export {};
 //# sourceMappingURL=paseo-worktree-archive-service.d.ts.map

package/dist/server/server/paseo-worktree-archive-service.js

@@ -8,14 +8,14 @@ export async function archivePaseoWorktree(dependencies, options) {
     if (resolvedWorktree) {
         targetPath = resolvedWorktree.worktreePath;
     }
-    const removedAgents = new Set();
+    const archivedAgents = new Set();
     const affectedWorkspaceCwds = new Set([targetPath]);
     const affectedWorkspaceIds = new Set([normalizePersistedWorkspaceId(targetPath)]);
     const liveAgents = dependencies.agentManager
         .listAgents()
         .filter((agent) => dependencies.isPathWithinRoot(targetPath, agent.cwd));
     for (const agent of liveAgents) {
-        removedAgents.add(agent.id);
+        archivedAgents.add(agent.id);
         affectedWorkspaceCwds.add(agent.cwd);
         affectedWorkspaceIds.add(normalizePersistedWorkspaceId(agent.cwd));
     }
@@ -26,41 +26,30 @@ export async function archivePaseoWorktree(dependencies, options) {
     catch (error) {
         dependencies.sessionLogger?.warn({ err: error, targetPath }, "Failed to list stored agents during worktree archive; continuing");
     }
+    const liveAgentIds = new Set(liveAgents.map((agent) => agent.id));
     const matchingStoredRecords = storedRecords.filter((record) => dependencies.isPathWithinRoot(targetPath, record.cwd));
     for (const record of matchingStoredRecords) {
-        removedAgents.add(record.id);
+        archivedAgents.add(record.id);
         affectedWorkspaceCwds.add(record.cwd);
         affectedWorkspaceIds.add(normalizePersistedWorkspaceId(record.cwd));
     }
-    const agentIdsToRemoveFromStorage = new Set([
-        ...liveAgents.map((agent) => agent.id),
-        ...matchingStoredRecords.map((record) => record.id),
-    ]);
     const affectedWorkspaceIdList = Array.from(affectedWorkspaceIds);
     dependencies.markWorkspaceArchiving(affectedWorkspaceIdList, new Date().toISOString());
     try {
         await dependencies.emitWorkspaceUpdatesForWorkspaceIds(affectedWorkspaceIdList);
-        const teardownResults = await Promise.allSettled([
-            ...liveAgents.map((agent) => dependencies.agentManager.closeAgent(agent.id)),
+        const archivedAt = new Date().toISOString();
+        const archiveResults = await Promise.allSettled([
+            ...liveAgents.map((agent) => dependencies.agentManager.archiveAgent(agent.id)),
+            ...matchingStoredRecords
+                .filter((record) => !liveAgentIds.has(record.id) && !record.archivedAt)
+                .map((record) => dependencies.agentManager.archiveSnapshot(record.id, archivedAt)),
             dependencies.killTerminalsUnderPath(targetPath),
         ]);
-        for (const result of teardownResults) {
+        for (const result of archiveResults) {
             if (result.status === "rejected") {
-                dependencies.sessionLogger?.warn({ err: result.reason, targetPath }, "Worktree teardown step failed during archive; continuing");
+                dependencies.sessionLogger?.warn({ err: result.reason, targetPath }, "Worktree archive teardown step failed; continuing");
             }
         }
-        const agentIdsToRemove = Array.from(agentIdsToRemoveFromStorage);
-        const storageRemovalResults = await Promise.allSettled(agentIdsToRemove.map((agentId) => dependencies.agentStorage.remove(agentId)));
-        storageRemovalResults.forEach((result, index) => {
-            if (result.status === "fulfilled") {
-                return;
-            }
-            dependencies.sessionLogger?.warn({
-                err: result.reason,
-                agentId: agentIdsToRemove[index],
-                targetPath,
-            }, "Failed to remove archived worktree agent from storage; continuing");
-        });
         await deletePaseoWorktree({
             cwd: options.repoRoot,
             worktreePath: targetPath,
@@ -89,21 +78,12 @@ export async function archivePaseoWorktree(dependencies, options) {
                 dependencies.sessionLogger?.warn({ err: error, workspaceId }, "Failed to archive workspace record; worktree FS already removed");
             }
         }));
-        for (const agentId of removedAgents) {
-            dependencies.emit({
-                type: "agent_deleted",
-                payload: {
-                    agentId,
-                    requestId: options.requestId,
-                },
-            });
-        }
     }
     finally {
         dependencies.clearWorkspaceArchiving(affectedWorkspaceIdList);
         await dependencies.emitWorkspaceUpdatesForWorkspaceIds(affectedWorkspaceIdList);
     }
-    return Array.from(removedAgents);
+    return Array.from(archivedAgents);
 }
 export async function killTerminalsUnderPath(dependencies, rootPath) {
     const terminalManager = dependencies.terminalManager;