@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/create-agent-lifecycle-dispatch.js

@@ -0,0 +1,166 @@
+import { randomUUID } from "node:crypto";
+import { isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
+import { archiveByScope } from "../workspace-archive-service.js";
+const inactiveRegistration = { cancel: async () => undefined };
+export class CreateAgentLifecycleDispatch {
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        this.autoArchiveAgentIds = new Set();
+    }
+    async createWorktreeForRequest(input) {
+        if (input.target && input.hasLegacyGitOptions) {
+            throw new Error("create_agent_request worktree cannot be combined with git options");
+        }
+        if (!input.target) {
+            return null;
+        }
+        return this.createWorktreeForTarget(input.cwd, input.target, input.firstAgentContext);
+    }
+    registerAutoArchiveIfRequested(input) {
+        if (input.autoArchive !== true) {
+            return inactiveRegistration;
+        }
+        return this.registerAutoArchiveOnTerminalState(input.agentId, toAutoArchiveTarget(input.createdWorktree));
+    }
+    async cleanupCreatedWorktreeAfterFailedAgentCreate(input) {
+        const { createdWorktree, createdAgentId } = input;
+        if (!createdWorktree || createdAgentId) {
+            return;
+        }
+        await this.archiveAutoCreatedWorktree({
+            agentId: null,
+            createdWorktree,
+        }).catch((archiveError) => {
+            this.dependencies.logger.warn({
+                err: archiveError,
+                worktreePath: createdWorktree.worktree.worktreePath,
+            }, "Failed to clean up worktree after create_agent_request failed");
+        });
+    }
+    async createWorktreeForTarget(cwd, target, firstAgentContext) {
+        const baseInput = {
+            cwd,
+            firstAgentContext,
+            runSetup: false,
+            paseoHome: this.dependencies.paseoHome,
+            worktreesRoot: this.dependencies.worktreesRoot,
+        };
+        switch (target.mode) {
+            case "branch-off":
+                return this.dependencies.createPaseoWorktreeWorkflow({
+                    ...baseInput,
+                    worktreeSlug: target.newBranch,
+                    action: "branch-off",
+                    ...(target.base ? { refName: target.base } : {}),
+                }, target.base ? { resolveDefaultBranch: async () => target.base } : undefined);
+            case "checkout-branch":
+                return this.dependencies.createPaseoWorktreeWorkflow({
+                    ...baseInput,
+                    action: "checkout",
+                    refName: target.branch,
+                });
+            case "checkout-pr":
+                return this.dependencies.createPaseoWorktreeWorkflow({
+                    ...baseInput,
+                    action: "checkout",
+                    githubPrNumber: target.prNumber,
+                });
+            default:
+                throw new Error("Unsupported create_agent_request worktree target");
+        }
+    }
+    registerAutoArchiveOnTerminalState(agentId, target) {
+        return registerAgentAutoArchive({
+            agentManager: this.dependencies.agentManager,
+            agentId,
+            archive: () => this.autoArchiveAgentOnce(agentId, target),
+        });
+    }
+    async autoArchiveAgentOnce(agentId, target) {
+        if (this.autoArchiveAgentIds.has(agentId)) {
+            return;
+        }
+        this.autoArchiveAgentIds.add(agentId);
+        try {
+            if (target.kind === "created-worktree") {
+                await this.archiveAutoCreatedWorktree({
+                    agentId,
+                    createdWorktree: target.result,
+                });
+                return;
+            }
+            await this.dependencies.archiveAgentForClose(agentId);
+        }
+        catch (error) {
+            this.dependencies.logger.warn({ err: error, agentId }, "Failed to auto-archive agent");
+        }
+    }
+    async archiveAutoCreatedWorktree(options) {
+        const { createdWorktree } = options;
+        const worktreePath = createdWorktree.worktree.worktreePath;
+        const ownership = await isPaseoOwnedWorktreeCwd(worktreePath, {
+            paseoHome: this.dependencies.paseoHome,
+            worktreesRoot: this.dependencies.worktreesRoot,
+        });
+        if (!ownership.allowed) {
+            throw new Error("Auto-created worktree is not a Paseo-owned worktree");
+        }
+        await archiveByScope({
+            paseoHome: this.dependencies.paseoHome,
+            paseoWorktreesBaseRoot: this.dependencies.worktreesRoot,
+            github: this.dependencies.github,
+            workspaceGitService: this.dependencies.workspaceGitService,
+            agentManager: this.dependencies.agentManager,
+            agentStorage: this.dependencies.agentStorage,
+            findWorkspaceIdForCwd: this.dependencies.findWorkspaceIdForCwd,
+            listActiveWorkspaces: this.dependencies.listActiveWorkspaces,
+            archiveWorkspaceRecord: this.dependencies.archiveWorkspaceRecord,
+            emitWorkspaceUpdatesForWorkspaceIds: this.dependencies.emitWorkspaceUpdatesForWorkspaceIds,
+            markWorkspaceArchiving: this.dependencies.markWorkspaceArchiving,
+            clearWorkspaceArchiving: this.dependencies.clearWorkspaceArchiving,
+            killTerminalsForWorkspace: this.dependencies.killTerminalsForWorkspace,
+            sessionLogger: this.dependencies.logger,
+        }, {
+            scope: { kind: "workspace", workspaceId: createdWorktree.workspace.workspaceId },
+            requestId: randomUUID(),
+        });
+        if (options.agentId) {
+            await this.dependencies.emitAgentRemove(options.agentId);
+        }
+    }
+}
+export function registerAgentAutoArchive(input) {
+    let unsubscribe = null;
+    let archiveTask = null;
+    const release = () => {
+        if (!unsubscribe)
+            return;
+        const subscribed = unsubscribe;
+        unsubscribe = null;
+        subscribed();
+    };
+    const registration = {
+        async cancel() {
+            release();
+            await archiveTask;
+        },
+    };
+    unsubscribe = input.agentManager.subscribe((event) => {
+        if (event.type !== "agent_stream")
+            return;
+        if (event.event.type !== "turn_completed" &&
+            event.event.type !== "turn_failed" &&
+            event.event.type !== "turn_canceled") {
+            return;
+        }
+        release();
+        archiveTask = input.archive();
+    }, { agentId: input.agentId, replayState: false });
+    return registration;
+}
+function toAutoArchiveTarget(createdWorktree) {
+    return createdWorktree
+        ? { kind: "created-worktree", result: createdWorktree }
+        : { kind: "agent-only" };
+}
+//# sourceMappingURL=create-agent-lifecycle-dispatch.js.map

package/dist/server/server/agent/create-agent-mode.d.ts

@@ -0,0 +1,13 @@
+import type { AgentCreateConfigParent, AgentCreateConfigUnattendedInput, AgentProvider, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
+export interface ResolveCreateAgentModeInput {
+    requestedMode: string | undefined;
+    targetProvider: AgentProvider;
+    parent: AgentCreateConfigParent | null;
+    unattended: boolean;
+    availableModes: string[] | undefined;
+    targetUnattendedMode: string | undefined;
+}
+export declare function resolveAndValidateCreateAgentMode(input: ResolveCreateAgentModeInput): string | undefined;
+export declare function resolveDefaultAgentCreateConfig(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
+export declare function isDefaultAgentCreateConfigUnattended(input: AgentCreateConfigUnattendedInput): boolean;
+//# sourceMappingURL=create-agent-mode.d.ts.map

package/dist/server/server/agent/create-agent-mode.js

@@ -0,0 +1,65 @@
+function listModes(modes) {
+    if (modes === undefined) {
+        return "unknown";
+    }
+    return modes.length > 0 ? modes.join(", ") : "(none)";
+}
+function isUnattendedCreateConfigParent(parent) {
+    return parent.isUnattended;
+}
+function formatCreateConfigParentMode(parent) {
+    return parent.modeId ?? "<none>";
+}
+function formatCreateConfigParentSource(parent) {
+    return `caller (provider '${parent.provider}')`;
+}
+export function resolveAndValidateCreateAgentMode(input) {
+    const { requestedMode, targetProvider, parent, availableModes } = input;
+    if (requestedMode !== undefined) {
+        if (availableModes !== undefined && !availableModes.includes(requestedMode)) {
+            throw new Error(`Invalid mode '${requestedMode}' for provider '${targetProvider}'. Available modes: ${listModes(availableModes)}`);
+        }
+        return requestedMode;
+    }
+    if (!parent) {
+        if (input.unattended && input.targetUnattendedMode !== undefined) {
+            return input.targetUnattendedMode;
+        }
+        return undefined;
+    }
+    if (parent.provider === targetProvider) {
+        return parent.modeId ?? undefined;
+    }
+    if ((input.unattended || isUnattendedCreateConfigParent(parent)) &&
+        input.targetUnattendedMode !== undefined) {
+        return input.targetUnattendedMode;
+    }
+    if (availableModes?.length === 0) {
+        return undefined;
+    }
+    throw new Error(`cannot inherit mode '${formatCreateConfigParentMode(parent)}' from ${formatCreateConfigParentSource(parent)} for new agent (provider '${targetProvider}'). Pass an explicit mode. Available modes for '${targetProvider}': ${listModes(availableModes)}`);
+}
+export function resolveDefaultAgentCreateConfig(input) {
+    const availableModeIds = input.availableModes?.map((mode) => mode.id);
+    return {
+        modeId: resolveAndValidateCreateAgentMode({
+            requestedMode: input.requestedMode,
+            targetProvider: input.provider,
+            parent: input.parent,
+            unattended: input.unattended,
+            availableModes: availableModeIds,
+            targetUnattendedMode: input.availableModes?.find(isUnattendedMode)?.id,
+        }),
+        featureValues: input.featureValues,
+    };
+}
+export function isDefaultAgentCreateConfigUnattended(input) {
+    if (input.modeId === null) {
+        return false;
+    }
+    return input.availableModes.some((mode) => mode.id === input.modeId && isUnattendedMode(mode));
+}
+function isUnattendedMode(mode) {
+    return mode.isUnattended === true;
+}
+//# sourceMappingURL=create-agent-mode.js.map

package/dist/server/server/agent/create-agent-title.d.ts

@@ -0,0 +1,10 @@
+import type { FirstAgentContext } from "@camerontaylor/paseo-protocol/messages";
+export declare function resolveCreateAgentTitles(options: {
+    configTitle?: string | null;
+    initialPrompt?: string | null;
+}): {
+    explicitTitle: string | null;
+    provisionalTitle: string | null;
+};
+export declare function resolveFirstAgentPromptTitle(firstAgentContext?: FirstAgentContext): string | null;
+//# sourceMappingURL=create-agent-title.d.ts.map

package/dist/server/server/agent/create-agent-title.js

@@ -0,0 +1,34 @@
+import { MAX_EXPLICIT_AGENT_TITLE_CHARS } from "@camerontaylor/paseo-protocol/agent-title-limits";
+const MAX_INITIAL_AGENT_TITLE_CHARS = Math.min(60, MAX_EXPLICIT_AGENT_TITLE_CHARS);
+function deriveInitialAgentTitle(prompt) {
+    const firstContentLine = prompt
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstContentLine) {
+        return null;
+    }
+    const normalized = firstContentLine.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+        return null;
+    }
+    const clamped = normalized.slice(0, MAX_INITIAL_AGENT_TITLE_CHARS).trim();
+    return clamped.length > 0 ? clamped : null;
+}
+export function resolveCreateAgentTitles(options) {
+    const explicitTitle = typeof options.configTitle === "string" && options.configTitle.trim().length > 0
+        ? options.configTitle.trim()
+        : null;
+    const trimmedPrompt = options.initialPrompt?.trim();
+    const provisionalTitle = explicitTitle ?? (trimmedPrompt ? deriveInitialAgentTitle(trimmedPrompt) : null);
+    return {
+        explicitTitle,
+        provisionalTitle,
+    };
+}
+export function resolveFirstAgentPromptTitle(firstAgentContext) {
+    return (resolveCreateAgentTitles({
+        initialPrompt: firstAgentContext?.prompt,
+    }).provisionalTitle ?? null);
+}
+//# sourceMappingURL=create-agent-title.js.map

package/dist/server/server/agent/dictation-debug.d.ts

@@ -0,0 +1,13 @@
+import type pino from "pino";
+export interface DictationDebugAudioMetadata {
+    sessionId: string;
+    dictationId: string;
+    format: string;
+}
+export interface DictationDebugChunkWriter {
+    folder: string;
+    writeChunk: (seq: number, pcm16: Buffer) => Promise<void>;
+}
+export declare function createDictationDebugChunkWriter(metadata: Pick<DictationDebugAudioMetadata, "sessionId" | "dictationId">, logger: pino.Logger): DictationDebugChunkWriter | null;
+export declare function maybePersistDictationDebugAudio(audio: Buffer, metadata: DictationDebugAudioMetadata, logger: pino.Logger, chunkWriterFolder?: string | null): Promise<string | null>;
+//# sourceMappingURL=dictation-debug.d.ts.map

package/dist/server/server/agent/dictation-debug.js

@@ -0,0 +1,50 @@
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { inferAudioExtension, sanitizeForFilename } from "./audio-utils.js";
+import { resolveRecordingsDebugDir } from "./recordings-debug.js";
+let announcedDir = null;
+export function createDictationDebugChunkWriter(metadata, logger) {
+    const debugDir = resolveRecordingsDebugDir("DICTATION_DEBUG_AUDIO_DIR");
+    if (!debugDir) {
+        return null;
+    }
+    if (announcedDir !== debugDir) {
+        logger.info({ debugDir }, "Dictation audio capture enabled");
+        announcedDir = debugDir;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const folder = join(debugDir, sanitizeForFilename(metadata.sessionId, "session"), `${timestamp}_${sanitizeForFilename(metadata.dictationId, "dictation")}`);
+    let folderCreated = false;
+    return {
+        folder,
+        writeChunk: async (seq, pcm16) => {
+            if (!folderCreated) {
+                await mkdir(folder, { recursive: true });
+                folderCreated = true;
+            }
+            const paddedSeq = String(seq).padStart(6, "0");
+            const filePath = join(folder, `chunk_${paddedSeq}.pcm`);
+            await writeFile(filePath, pcm16);
+        },
+    };
+}
+export async function maybePersistDictationDebugAudio(audio, metadata, logger, chunkWriterFolder) {
+    const debugDir = resolveRecordingsDebugDir("DICTATION_DEBUG_AUDIO_DIR");
+    if (!debugDir) {
+        return null;
+    }
+    if (announcedDir !== debugDir) {
+        logger.info({ debugDir }, "Dictation audio capture enabled");
+        announcedDir = debugDir;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const folder = chunkWriterFolder ?? join(debugDir, sanitizeForFilename(metadata.sessionId, "session"));
+    await mkdir(folder, { recursive: true });
+    const filename = chunkWriterFolder
+        ? `combined.${inferAudioExtension(metadata.format)}`
+        : `${timestamp}_${sanitizeForFilename(metadata.dictationId, "dictation")}.${inferAudioExtension(metadata.format)}`;
+    const filePath = join(folder, filename);
+    await writeFile(filePath, audio);
+    return filePath;
+}
+//# sourceMappingURL=dictation-debug.js.map

package/dist/server/server/agent/import-sessions.d.ts

@@ -0,0 +1,57 @@
+import type { z } from "zod";
+import type { Logger } from "pino";
+import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
+import type { AgentManager, ManagedAgent } from "./agent-manager.js";
+import type { AgentStorage } from "./agent-storage.js";
+import type { AgentProvider } from "./agent-sdk-types.js";
+import { type AgentLoaderManager } from "./agent-loading.js";
+import type { WorkspaceProvisioningService } from "../session/workspace-provisioning/workspace-provisioning-service.js";
+import type { PersistedWorkspaceRecord } from "../workspace-registry.js";
+import type { FetchRecentProviderSessionsRequestMessage, ImportAgentRequestMessageSchema, RecentProviderSessionDescriptorPayload } from "@camerontaylor/paseo-protocol/messages";
+type ImportAgentRequestMessage = z.infer<typeof ImportAgentRequestMessageSchema>;
+export type ImportSessionAgentManager = AgentLoaderManager & Pick<AgentManager, "archiveSnapshot" | "closeAgent" | "getTimeline" | "importProviderSession" | "notifyAgentState" | "unarchiveSnapshot">;
+export interface NormalizedImportAgentRequest {
+    provider: AgentProvider;
+    providerHandleId: string;
+    cwd?: string;
+    workspaceId?: string;
+    labels?: Record<string, string>;
+    requestId: string;
+}
+export declare class ImportSessionsRequestError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface ListImportableProviderSessionsInput {
+    request: FetchRecentProviderSessionsRequestMessage;
+    agentManager: Pick<AgentManager, "listAgents" | "listImportableSessions">;
+    agentStorage: Pick<AgentStorage, "list">;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "getProviderLabel">;
+}
+export interface ListImportableProviderSessionsResult {
+    entries: RecentProviderSessionDescriptorPayload[];
+    filteredAlreadyImportedCount: number;
+    providerErrors: Array<{
+        provider: string;
+        message: string;
+    }>;
+}
+export interface ImportProviderSessionInput {
+    request: NormalizedImportAgentRequest;
+    workspaceProvisioning: Pick<WorkspaceProvisioningService, "runInImportWorkspace">;
+    agentManager: ImportSessionAgentManager;
+    agentStorage: AgentStorage;
+    logger: Logger;
+}
+export interface ImportProviderSessionResult {
+    snapshot: ManagedAgent;
+    timelineSize: number;
+    createdWorkspace: PersistedWorkspaceRecord | null;
+}
+export declare function normalizeImportAgentRequest(msg: ImportAgentRequestMessage): NormalizedImportAgentRequest | {
+    error: string;
+};
+export declare function listImportableProviderSessions(input: ListImportableProviderSessionsInput): Promise<ListImportableProviderSessionsResult>;
+export declare function importProviderSession(input: ImportProviderSessionInput): Promise<ImportProviderSessionResult>;
+export {};
+//# sourceMappingURL=import-sessions.d.ts.map

package/dist/server/server/agent/import-sessions.js

@@ -0,0 +1,240 @@
+import { ensureAgentLoaded } from "./agent-loading.js";
+import { unarchiveAgentState } from "./agent-prompt.js";
+import { toRecentProviderSessionDescriptorPayload } from "./agent-projections.js";
+import { getParentAgentIdFromLabels, PARENT_AGENT_ID_LABEL } from "@camerontaylor/paseo-protocol/agent-labels";
+import { createRealpathAwarePathMatcher } from "../../utils/path.js";
+const METADATA_GENERATION_PROMPT_PREFIX = "Generate metadata for a coding agent based on the user prompt.";
+const IMPORT_SESSION_SEARCH_SCAN_LIMIT = 500;
+const providerSessionImportMutations = new WeakMap();
+export class ImportSessionsRequestError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ImportSessionsRequestError";
+    }
+}
+// COMPAT(import-agent-request-v1): accept legacy {provider, sessionId} shape
+// alongside the new {providerId, providerHandleId} shape. Old clients
+// (< target daemon floor) send the legacy fields. Drop the fallbacks and the
+// .optional() in messages.ts when the supported client floor is >= the daemon
+// version that ships the new shape (target: 2026-11-08).
+export function normalizeImportAgentRequest(msg) {
+    const provider = msg.providerId ?? msg.provider;
+    const providerHandleId = msg.providerHandleId ?? msg.sessionId;
+    if (!provider || !providerHandleId) {
+        return { error: "Import requires providerId and providerHandleId" };
+    }
+    return {
+        provider: provider,
+        providerHandleId,
+        cwd: msg.cwd,
+        workspaceId: msg.workspaceId,
+        labels: msg.labels,
+        requestId: msg.requestId,
+    };
+}
+export async function listImportableProviderSessions(input) {
+    const { request, agentManager, agentStorage, providerSnapshotManager } = input;
+    const limit = request.limit ?? 20;
+    const sinceTimestamp = parseRecentProviderSessionsSince(request.since);
+    const providerFilter = request.providers ? new Set(request.providers) : undefined;
+    const importedSessions = await collectImportedProviderSessions(agentManager, agentStorage, providerFilter);
+    const importedHandles = importedSessions.handles;
+    const query = normalizeImportSessionQuery(request.query);
+    const listingLimit = query ? IMPORT_SESSION_SEARCH_SCAN_LIMIT : limit + importedSessions.count;
+    const listing = await agentManager.listImportableSessions({
+        limit: listingLimit,
+        ...(query ? { query } : {}),
+        ...(query ? { scanLimit: IMPORT_SESSION_SEARCH_SCAN_LIMIT } : {}),
+        providerFilter,
+        cwd: request.cwd,
+    });
+    let filteredAlreadyImportedCount = 0;
+    const candidates = [];
+    const matchesRequestCwd = request.cwd ? createRealpathAwarePathMatcher(request.cwd) : null;
+    for (const session of listing.sessions) {
+        if (matchesRequestCwd && !matchesRequestCwd(session.cwd)) {
+            continue;
+        }
+        if (sinceTimestamp !== null && session.lastActivityAt.getTime() < sinceTimestamp) {
+            continue;
+        }
+        if (isMetadataGenerationSession(session)) {
+            continue;
+        }
+        if (importedHandles.has(toProviderSessionHandleKey(session.provider, session.providerHandleId))) {
+            filteredAlreadyImportedCount += 1;
+            continue;
+        }
+        candidates.push(session);
+    }
+    const entries = candidates
+        .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
+        .slice(0, limit)
+        .map((descriptor) => toRecentProviderSessionDescriptorPayload(descriptor, {
+        providerLabel: providerSnapshotManager.getProviderLabel(descriptor.provider),
+    }));
+    return {
+        entries,
+        filteredAlreadyImportedCount,
+        providerErrors: listing.providerErrors,
+    };
+}
+function normalizeImportSessionQuery(query) {
+    const normalized = query?.trim().toLowerCase();
+    return normalized ? normalized : null;
+}
+export async function importProviderSession(input) {
+    const cwd = input.request.cwd;
+    if (!cwd) {
+        throw new Error("Import requires cwd from the selected provider session");
+    }
+    const key = await resolveProviderSessionImportMutationKey(input);
+    return serializeProviderSessionImport(input.agentManager, key, async () => {
+        const placement = await input.workspaceProvisioning.runInImportWorkspace({ cwd, requestedWorkspaceId: input.request.workspaceId }, (workspace) => importProviderSessionNow(input, cwd, workspace.workspaceId));
+        return { ...placement.value, createdWorkspace: placement.createdWorkspace };
+    });
+}
+async function importProviderSessionNow(input, cwd, workspaceId) {
+    const { provider, providerHandleId, labels } = input.request;
+    const matchingRecords = await input.agentStorage.listByProviderSession(provider, providerHandleId);
+    const activeRecord = matchingRecords.find((record) => !record.archivedAt);
+    if (activeRecord) {
+        throw new Error(`Provider session is already imported: ${providerHandleId}`);
+    }
+    const archivedRecord = matchingRecords.find((record) => record.archivedAt);
+    if (archivedRecord?.persistence && archivedRecord.archivedAt) {
+        if (!createRealpathAwarePathMatcher(cwd)(archivedRecord.cwd)) {
+            throw new Error(`Provider session cwd does not match import cwd: ${providerHandleId}`);
+        }
+        const requestedParentAgentId = getParentAgentIdFromLabels(input.request.labels);
+        const labelPatch = { ...input.request.labels };
+        if (Object.hasOwn(archivedRecord.labels, PARENT_AGENT_ID_LABEL) ||
+            Object.hasOwn(input.request.labels ?? {}, PARENT_AGENT_ID_LABEL)) {
+            labelPatch[PARENT_AGENT_ID_LABEL] = requestedParentAgentId;
+        }
+        await unarchiveAgentState(input.agentStorage, input.agentManager, archivedRecord.id, {
+            workspaceId,
+            labels: Object.keys(labelPatch).length > 0 ? labelPatch : undefined,
+        });
+        try {
+            const snapshot = await ensureAgentLoaded(archivedRecord.id, {
+                agentManager: input.agentManager,
+                agentStorage: input.agentStorage,
+                logger: input.logger,
+            });
+            return {
+                snapshot,
+                timelineSize: input.agentManager.getTimeline(snapshot.id).length,
+            };
+        }
+        catch (error) {
+            await rollbackArchivedImport(input, archivedRecord, archivedRecord.archivedAt);
+            throw error;
+        }
+    }
+    const snapshot = await input.agentManager.importProviderSession({
+        provider,
+        providerHandleId,
+        cwd,
+        workspaceId,
+        labels,
+    });
+    await unarchiveAgentState(input.agentStorage, input.agentManager, snapshot.id);
+    return {
+        snapshot,
+        timelineSize: input.agentManager.getTimeline(snapshot.id).length,
+    };
+}
+async function serializeProviderSessionImport(agentManager, key, operation) {
+    let mutations = providerSessionImportMutations.get(agentManager);
+    if (!mutations) {
+        mutations = new Map();
+        providerSessionImportMutations.set(agentManager, mutations);
+    }
+    const previous = mutations.get(key) ?? Promise.resolve();
+    const next = previous.catch(() => undefined).then(operation);
+    mutations.set(key, next);
+    try {
+        return await next;
+    }
+    finally {
+        if (mutations.get(key) === next) {
+            mutations.delete(key);
+        }
+    }
+}
+async function resolveProviderSessionImportMutationKey(input) {
+    const matchingRecord = (await input.agentStorage.listByProviderSession(input.request.provider, input.request.providerHandleId)).at(0);
+    return matchingRecord
+        ? `agent\0${matchingRecord.id}`
+        : `handle\0${toProviderSessionHandleKey(input.request.provider, input.request.providerHandleId)}`;
+}
+async function rollbackArchivedImport(input, archivedRecord, archivedAt) {
+    try {
+        if (input.agentManager.getAgent(archivedRecord.id)) {
+            await input.agentManager.closeAgent(archivedRecord.id);
+        }
+        await input.agentManager.archiveSnapshot(archivedRecord.id, archivedAt);
+    }
+    catch (error) {
+        input.logger.error({ err: error, agentId: archivedRecord.id }, "Failed to re-archive provider session after import failure");
+    }
+    try {
+        await input.agentStorage.upsert(archivedRecord);
+    }
+    catch (error) {
+        input.logger.error({ err: error, agentId: archivedRecord.id }, "Failed to restore archived agent record after import failure");
+    }
+}
+function parseRecentProviderSessionsSince(since) {
+    if (!since) {
+        return null;
+    }
+    const timestamp = Date.parse(since);
+    if (Number.isNaN(timestamp)) {
+        throw new ImportSessionsRequestError("invalid_since", "Invalid recent provider sessions since");
+    }
+    return timestamp;
+}
+async function collectImportedProviderSessions(agentManager, agentStorage, providerFilter) {
+    const handles = new Set();
+    const sessions = new Set();
+    const records = await agentStorage.list();
+    const storedRecordsById = new Map(records.map((record) => [record.id, record]));
+    const collect = (provider, persistence) => {
+        if (!persistence || (providerFilter && !providerFilter.has(provider)))
+            return;
+        sessions.add(toProviderSessionHandleKey(provider, persistence.sessionId));
+        collectProviderSessionHandleKeys(handles, provider, persistence);
+    };
+    for (const agent of agentManager.listAgents()) {
+        if (storedRecordsById.get(agent.id)?.archivedAt) {
+            continue;
+        }
+        collect(agent.provider, agent.persistence);
+    }
+    for (const record of records) {
+        if (record.archivedAt) {
+            continue;
+        }
+        collect(record.provider, record.persistence);
+    }
+    return { handles, count: sessions.size };
+}
+function toProviderSessionHandleKey(provider, providerHandleId) {
+    return `${provider}\0${providerHandleId}`;
+}
+function isMetadataGenerationSession(input) {
+    return (input.firstPromptPreview?.trimStart().startsWith(METADATA_GENERATION_PROMPT_PREFIX) ?? false);
+}
+function collectProviderSessionHandleKeys(target, provider, persistence) {
+    if (!persistence) {
+        return;
+    }
+    target.add(toProviderSessionHandleKey(provider, persistence.sessionId));
+    if (persistence.nativeHandle) {
+        target.add(toProviderSessionHandleKey(provider, persistence.nativeHandle));
+    }
+}
+//# sourceMappingURL=import-sessions.js.map