@getpaseo/server 0.1.96 → 0.1.97-beta.2

package/dist/server/{utils/executable.d.ts → executable-resolution/executable-resolution.d.ts}

@@ -1,5 +1,5 @@
 import { existsSync } from "node:fs";
-export { quoteWindowsArgument, quoteWindowsCommand } from "./windows-command.js";
+export { quoteWindowsArgument, quoteWindowsCommand } from "../utils/windows-command.js";
 export declare function probeExecutable(executablePath: string, timeoutMs?: number): Promise<boolean>;
 /**
  * Check a literal executable path. PATH search is handled by findExecutable().
@@ -7,4 +7,4 @@ export declare function probeExecutable(executablePath: string, timeoutMs?: numb
 export declare function executableExists(executablePath: string, exists?: typeof existsSync): string | null;
 export declare function findExecutable(name: string, probeTimeoutMs?: number): Promise<string | null>;
 export declare function isCommandAvailable(command: string): Promise<boolean>;
-//# sourceMappingURL=executable.d.ts.map
+//# sourceMappingURL=executable-resolution.d.ts.map

package/dist/server/{utils/executable.js → executable-resolution/executable-resolution.js}

@@ -1,9 +1,9 @@
 import { createRequire } from "node:module";
 import { existsSync } from "node:fs";
-import { extname } from "node:path";
-import { execCommand } from "./spawn.js";
-import { isWindowsCommandScript } from "./windows-command.js";
-export { quoteWindowsArgument, quoteWindowsCommand } from "./windows-command.js";
+import { execCommand } from "../utils/spawn.js";
+import { isWindowsCommandScript } from "../utils/windows-command.js";
+import { windowsExecutableResolution } from "./windows.js";
+export { quoteWindowsArgument, quoteWindowsCommand } from "../utils/windows-command.js";
 const require = createRequire(import.meta.url);
 const which = require("which");
 const PROBE_TIMEOUT_MS = 2000;
@@ -83,22 +83,24 @@ function classifyProbeError(error) {
  * Check a literal executable path. PATH search is handled by findExecutable().
  */
 export function executableExists(executablePath, exists = existsSync) {
-    if (exists(executablePath))
-        return executablePath;
-    if (process.platform === "win32" && !extname(executablePath)) {
-        for (const ext of [".exe", ".cmd"]) {
-            const candidate = executablePath + ext;
-            if (exists(candidate))
-                return candidate;
-        }
+    if (process.platform === "win32") {
+        return windowsExecutableResolution.exists(executablePath, { exists });
     }
-    return null;
+    return exists(executablePath) ? executablePath : null;
 }
 export async function findExecutable(name, probeTimeoutMs = PROBE_TIMEOUT_MS) {
     const trimmed = name.trim();
     if (!trimmed) {
         return null;
     }
+    if (process.platform === "win32") {
+        return windowsExecutableResolution.find(trimmed, {
+            enumeratePathCandidates: enumerateCandidates,
+            probeExecutable,
+            exists: existsSync,
+            probeTimeoutMs,
+        });
+    }
     if (hasPathSeparator(trimmed)) {
         return (await probeExecutable(trimmed, probeTimeoutMs)) ? trimmed : null;
     }
@@ -113,4 +115,4 @@ export async function findExecutable(name, probeTimeoutMs = PROBE_TIMEOUT_MS) {
 export async function isCommandAvailable(command) {
     return (await findExecutable(command)) !== null;
 }
-//# sourceMappingURL=executable.js.map
+//# sourceMappingURL=executable-resolution.js.map

package/dist/server/executable-resolution/windows.d.ts

@@ -0,0 +1,18 @@
+interface WindowsFindExecutableOptions {
+    enumeratePathCandidates: (name: string) => Promise<string[]>;
+    probeExecutable: (executablePath: string, timeoutMs: number) => Promise<boolean>;
+    exists: (path: string) => boolean;
+    localAppData?: string;
+    probeTimeoutMs: number;
+}
+interface WindowsExecutableExistsOptions {
+    exists: (path: string) => boolean;
+}
+declare function find(input: string, options: WindowsFindExecutableOptions): Promise<string | null>;
+declare function exists(executablePath: string, options: WindowsExecutableExistsOptions): string | null;
+export declare const windowsExecutableResolution: {
+    exists: typeof exists;
+    find: typeof find;
+};
+export {};
+//# sourceMappingURL=windows.d.ts.map

package/dist/server/executable-resolution/windows.js

@@ -0,0 +1,62 @@
+import { readdirSync } from "node:fs";
+import { extname, join } from "node:path";
+function hasPathSeparator(value) {
+    return value.includes("/") || value.includes("\\");
+}
+function enumerateLiteralPathCandidates(executablePath) {
+    if (extname(executablePath)) {
+        return [executablePath];
+    }
+    return [executablePath, `${executablePath}.exe`, `${executablePath}.cmd`];
+}
+function enumerateWingetPackageCandidates(name, localAppData) {
+    if (!localAppData) {
+        return [];
+    }
+    const wingetPackages = join(localAppData, "Microsoft", "WinGet", "Packages");
+    let packageDirs;
+    try {
+        packageDirs = readdirSync(wingetPackages, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+    const exeName = `${name}.exe`;
+    return packageDirs.map((packageDir) => join(wingetPackages, packageDir, exeName));
+}
+async function find(input, options) {
+    if (hasPathSeparator(input)) {
+        return findFirstProbeable(enumerateLiteralPathCandidates(input), options);
+    }
+    const pathCandidates = await options.enumeratePathCandidates(input);
+    const wingetCandidates = enumerateWingetPackageCandidates(input, options.localAppData ?? process.env.LOCALAPPDATA).filter(options.exists);
+    return findFirstProbeable([...pathCandidates, ...wingetCandidates], options);
+}
+async function findFirstProbeable(candidates, options) {
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate)) {
+            continue;
+        }
+        seen.add(candidate);
+        if (await options.probeExecutable(candidate, options.probeTimeoutMs)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function exists(executablePath, options) {
+    for (const candidate of enumerateLiteralPathCandidates(executablePath)) {
+        if (options.exists(candidate)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+export const windowsExecutableResolution = {
+    exists,
+    find,
+};
+//# sourceMappingURL=windows.js.map

package/dist/server/server/agent/agent-loading.js

@@ -31,7 +31,10 @@ export async function ensureAgentLoaded(agentId, deps) {
             if (!config) {
                 throw new Error(`Agent ${agentId} references unavailable provider '${record.provider}'`);
             }
-            snapshot = await deps.agentManager.createAgent(config, agentId, { labels: record.labels });
+            snapshot = await deps.agentManager.createAgent(config, agentId, {
+                labels: record.labels,
+                workspaceId: record.workspaceId,
+            });
             deps.logger.info({ agentId, provider: record.provider }, "Agent created from stored config");
         }
         await deps.agentManager.hydrateTimelineFromProvider(agentId);

package/dist/server/server/agent/agent-manager.d.ts

@@ -100,6 +100,12 @@ interface ManagedAgentBase {
     id: string;
     provider: AgentProvider;
     cwd: string;
+    /**
+     * Workspace this agent belongs to, stamped at creation. Independent of cwd:
+     * cwd answers "where does it run", workspaceId answers "which workspace owns it".
+     * Null/undefined for legacy agents created before ownership stamping.
+     */
+    workspaceId?: string;
     capabilities: AgentCapabilityFlags;
     config: AgentSessionConfig;
     runtimeInfo?: AgentRuntimeInfo;
@@ -217,6 +223,7 @@ export declare class AgentManager {
     listImportableSessions(options?: ImportablePersistedAgentQueryOptions): Promise<ManagedImportableProviderSession[]>;
     private isProviderImportable;
     listProviderAvailability(): Promise<ProviderAvailability[]>;
+    getProviderAvailability(provider: AgentProvider): Promise<ProviderAvailability>;
     listDraftCommands(config: AgentSessionConfig): Promise<AgentSlashCommand[]>;
     listDraftFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
     getAgent(id: string): ManagedAgent | null;
@@ -225,11 +232,11 @@ export declare class AgentManager {
     fetchTimeline(id: string, options?: AgentTimelineFetchOptions): AgentTimelineFetchResult;
     createAgent(config: AgentSessionConfig, agentId?: string, options?: {
         labels?: Record<string, string>;
-        workspaceId?: string;
         initialPrompt?: string;
         env?: Record<string, string>;
         persistSession?: boolean;
         initialTitle?: string | null;
+        workspaceId?: string;
     }): Promise<ManagedAgent>;
     private buildCreateSessionOptions;
     resumeAgentFromPersistence(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, agentId?: string, options?: {
@@ -237,11 +244,13 @@ export declare class AgentManager {
         updatedAt?: Date;
         lastUserMessageAt?: Date | null;
         labels?: Record<string, string>;
+        workspaceId?: string;
     }): Promise<ManagedAgent>;
     importProviderSession(input: {
         provider: AgentProvider;
         providerHandleId: string;
         cwd: string;
+        workspaceId: string;
         labels?: Record<string, string>;
     }): Promise<ManagedAgent>;
     reloadAgentSession(agentId: string, overrides?: Partial<AgentSessionConfig>, options?: {
@@ -262,7 +271,6 @@ export declare class AgentManager {
     setAgentThinkingOption(agentId: string, thinkingOptionId: string | null): Promise<void>;
     setAgentFeature(agentId: string, featureId: string, value: unknown): Promise<void>;
     setTitle(agentId: string, title: string): Promise<void>;
-    setGeneratedTitle(agentId: string, title: string): Promise<void>;
     setLabels(agentId: string, labels: Record<string, string>): Promise<void>;
     notifyAgentState(agentId: string): void;
     clearAgentAttention(agentId: string): Promise<void>;

package/dist/server/server/agent/agent-manager.js

@@ -361,34 +361,34 @@ export class AgentManager {
         return true;
     }
     async listProviderAvailability() {
-        const checks = Array.from(this.clients.keys()).map(async (provider) => {
-            const client = this.clients.get(provider);
-            if (!client) {
-                return {
-                    provider,
-                    available: false,
-                    error: `No client registered for provider '${provider}'`,
-                };
-            }
-            try {
-                const available = await client.isAvailable();
-                return {
-                    provider,
-                    available,
-                    error: null,
-                };
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                this.logger.warn({ err: error, provider }, "Failed to check provider availability");
-                return {
-                    provider,
-                    available: false,
-                    error: message,
-                };
-            }
-        });
-        return Promise.all(checks);
+        return Promise.all(Array.from(this.clients.keys()).map((provider) => this.getProviderAvailability(provider)));
+    }
+    async getProviderAvailability(provider) {
+        const client = this.clients.get(provider);
+        if (!client) {
+            return {
+                provider,
+                available: false,
+                error: `No client registered for provider '${provider}'`,
+            };
+        }
+        try {
+            const available = await client.isAvailable();
+            return {
+                provider,
+                available,
+                error: null,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ err: error, provider }, "Failed to check provider availability");
+            return {
+                provider,
+                available: false,
+                error: message,
+            };
+        }
     }
     async listDraftCommands(config) {
         const normalizedConfig = await this.normalizeConfig(config);
@@ -470,8 +470,8 @@ export class AgentManager {
         const session = await client.createSession(launchConfig, launchContext, createOptions);
         return this.registerSession(session, storedConfig, resolvedAgentId, {
             labels: options?.labels,
-            workspaceId: options?.workspaceId,
             initialTitle: options?.initialTitle,
+            workspaceId: options?.workspaceId,
         });
     }
     buildCreateSessionOptions(options) {
@@ -520,6 +520,7 @@ export class AgentManager {
         const initialTitle = resolveImportedAgentTitle(importedConfig, timelineRows);
         return this.registerSession(imported.session, importedConfig, resolvedAgentId, {
             labels: input.labels,
+            workspaceId: input.workspaceId,
             timelineRows,
             timelineNextSeq: timelineRows.length + 1,
             persistence: imported.persistence,
@@ -577,6 +578,7 @@ export class AgentManager {
         // Preserve existing labels and timeline during reload.
         return this.registerSession(session, storedConfig, agentId, {
             labels: existing.labels,
+            workspaceId: existing.workspaceId,
             createdAt: existing.createdAt,
             updatedAt: existing.updatedAt,
             lastUserMessageAt: existing.lastUserMessageAt,
@@ -734,6 +736,7 @@ export class AgentManager {
                 id: record.id,
                 provider: record.provider,
                 cwd: record.cwd,
+                workspaceId: record.workspaceId,
                 session: null,
                 capabilities: STORED_AGENT_CAPABILITIES,
                 config: buildStoredAgentConfig(record),
@@ -832,17 +835,6 @@ export class AgentManager {
         await this.persistSnapshot(agent, { title: normalizedTitle });
         this.emitState(agent, { persist: false });
     }
-    async setGeneratedTitle(agentId, title) {
-        const agent = this.requireAgent(agentId);
-        const normalizedTitle = title.trim();
-        if (!normalizedTitle) {
-            return;
-        }
-        const registry = this.requireRegistry();
-        const persisted = await registry.setGeneratedTitle(agent.id, normalizedTitle);
-        agent.updatedAt = new Date(persisted.updatedAt);
-        this.emitState(agent, { persist: false });
-    }
     async setLabels(agentId, labels) {
         const agent = this.requireAgent(agentId);
         agent.labels = { ...agent.labels, ...labels };
@@ -1677,7 +1669,6 @@ export class AgentManager {
         this.previousStatuses.set(resolvedAgentId, managed.lifecycle);
         await this.refreshRuntimeInfo(managed, { emit: !options?.publishWhenReady });
         await this.persistSnapshot(managed, {
-            workspaceId: options?.workspaceId,
             title: initialPersistedTitle,
         });
         if (!options?.publishWhenReady) {
@@ -1685,7 +1676,7 @@ export class AgentManager {
         }
         await this.refreshSessionState(managed, { emit: !options?.publishWhenReady });
         managed.lifecycle = "idle";
-        await this.persistSnapshot(managed, { workspaceId: options?.workspaceId });
+        await this.persistSnapshot(managed);
         this.emitState(managed, { persist: false });
         this.subscribeToSession(managed);
         return { ...managed };
@@ -1715,6 +1706,7 @@ export class AgentManager {
             id: resolvedAgentId,
             provider: config.provider,
             cwd: config.cwd,
+            workspaceId: options?.workspaceId,
             session,
             capabilities: session.capabilities,
             config,
@@ -1872,10 +1864,6 @@ export class AgentManager {
         if (agent.internal) {
             return;
         }
-        if (options?.workspaceId !== undefined) {
-            await this.registry.applySnapshot(agent, options.workspaceId, options);
-            return;
-        }
         await this.registry.applySnapshot(agent, options);
     }
     requireRegistry() {

package/dist/server/server/agent/agent-projections.js

@@ -27,6 +27,7 @@ export function toStoredAgentRecord(agent, options) {
         id: agent.id,
         provider: agent.provider,
         cwd: agent.cwd,
+        workspaceId: agent.workspaceId,
         createdAt,
         updatedAt: agent.updatedAt.toISOString(),
         lastActivityAt: agent.updatedAt.toISOString(),
@@ -59,6 +60,7 @@ export function toAgentPayload(agent, options) {
         id: agent.id,
         provider: agent.provider,
         cwd: agent.cwd,
+        ...(agent.workspaceId ? { workspaceId: agent.workspaceId } : {}),
         model: agent.config.model ?? null,
         thinkingOptionId,
         effectiveThinkingOptionId,
@@ -145,6 +147,7 @@ export function buildStoredAgentPayload(record, validProviders) {
         id: record.id,
         provider: record.provider,
         cwd: record.cwd,
+        ...(record.workspaceId ? { workspaceId: record.workspaceId } : {}),
         model: record.config?.model ?? null,
         thinkingOptionId: record.config?.thinkingOptionId ?? null,
         effectiveThinkingOptionId: resolveEffectiveThinkingOptionId({

package/dist/server/server/agent/agent-prompt.js

@@ -148,6 +148,14 @@ export async function startCreatedAgentInitialPrompt(params) {
     }
     return refreshedSnapshot;
 }
+function formatFinishNotificationBody(params) {
+    const statusLine = `Agent ${params.childAgentId} (${params.title}) ${params.reason}.`;
+    const lastAssistantMessage = params.lastAssistantMessage?.trim();
+    if (!lastAssistantMessage) {
+        return statusLine;
+    }
+    return `${statusLine}\n\n<agent-response>\n${lastAssistantMessage}\n</agent-response>`;
+}
 export function setupFinishNotification(params) {
     const { agentManager, agentStorage, childAgentId, callerAgentId, logger } = params;
     let hasSeenRunning = false;
@@ -159,9 +167,19 @@ export function setupFinishNotification(params) {
         }
         fired = true;
         unsubscribe?.();
+        const callerRecord = await agentStorage.get(callerAgentId);
+        if (callerRecord?.archivedAt) {
+            return;
+        }
         const record = await agentStorage.get(childAgentId);
         const title = record?.title ?? childAgentId;
-        const body = `Agent ${childAgentId} (${title}) ${reason}.`;
+        const lastAssistantMessage = await agentManager.getLastAssistantMessage(childAgentId);
+        const body = formatFinishNotificationBody({
+            childAgentId,
+            title,
+            reason,
+            lastAssistantMessage,
+        });
         await sendPromptToAgent({
             agentManager,
             agentStorage,

package/dist/server/server/agent/agent-response-loop.js

@@ -265,12 +265,10 @@ export async function generateStructuredAgentResponseWithFallback(options) {
     }
     const runStructured = runner ??
         ((input) => generateStructuredAgentResponse(input));
-    const availability = await manager.listProviderAvailability();
-    const availabilityByProvider = new Map(availability.map((entry) => [entry.provider, entry]));
     const attempts = [];
     for (const candidate of providers) {
-        const availabilityEntry = availabilityByProvider.get(candidate.provider);
-        if (availabilityEntry && !availabilityEntry.available) {
+        const availabilityEntry = await manager.getProviderAvailability(candidate.provider);
+        if (!availabilityEntry.available) {
             const reason = availabilityEntry.error ?? "unavailable";
             attempts.push({
                 provider: candidate.provider,

package/dist/server/server/agent/agent-storage.d.ts

@@ -6,6 +6,7 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     id: z.ZodString;
     provider: z.ZodString;
     cwd: z.ZodString;
+    workspaceId: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
     lastActivityAt: z.ZodOptional<z.ZodString>;
@@ -70,16 +71,16 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
         icon: z.ZodOptional<z.ZodString>;
         value: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
-        type: "toggle";
         value: boolean;
+        type: "toggle";
         id: string;
         label: string;
         description?: string | undefined;
         icon?: string | undefined;
         tooltip?: string | undefined;
     }, {
-        type: "toggle";
         value: boolean;
+        type: "toggle";
         id: string;
         label: string;
         description?: string | undefined;
@@ -113,7 +114,6 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
             isDefault?: boolean | undefined;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
-        type: "select";
         value: string | null;
         options: {
             id: string;
@@ -122,13 +122,13 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
             metadata?: Record<string, unknown> | undefined;
             isDefault?: boolean | undefined;
         }[];
+        type: "select";
         id: string;
         label: string;
         description?: string | undefined;
         icon?: string | undefined;
         tooltip?: string | undefined;
     }, {
-        type: "select";
         value: string | null;
         options: {
             id: string;
@@ -137,6 +137,7 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
             metadata?: Record<string, unknown> | undefined;
             isDefault?: boolean | undefined;
         }[];
+        type: "select";
         id: string;
         label: string;
         description?: string | undefined;
@@ -172,7 +173,10 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     createdAt: string;
     updatedAt: string;
     labels: Record<string, string>;
-    lastStatus: "error" | "running" | "initializing" | "idle" | "closed";
+    lastStatus: "error" | "idle" | "running" | "initializing" | "closed";
+    workspaceId?: string | undefined;
+    internal?: boolean | undefined;
+    attentionReason?: "finished" | "error" | "permission" | null | undefined;
     title?: string | null | undefined;
     persistence?: {
         provider: string;
@@ -201,15 +205,14 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
         extra?: Record<string, unknown> | undefined;
     } | undefined;
     features?: ({
-        type: "toggle";
         value: boolean;
+        type: "toggle";
         id: string;
         label: string;
         description?: string | undefined;
         icon?: string | undefined;
         tooltip?: string | undefined;
     } | {
-        type: "select";
         value: string | null;
         options: {
             id: string;
@@ -218,6 +221,7 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
             metadata?: Record<string, unknown> | undefined;
             isDefault?: boolean | undefined;
         }[];
+        type: "select";
         id: string;
         label: string;
         description?: string | undefined;
@@ -226,9 +230,7 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     })[] | undefined;
     lastError?: string | null | undefined;
     requiresAttention?: boolean | undefined;
-    attentionReason?: "finished" | "error" | "permission" | null | undefined;
     attentionTimestamp?: string | null | undefined;
-    internal?: boolean | undefined;
     archivedAt?: string | null | undefined;
 }, {
     cwd: string;
@@ -236,6 +238,9 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     provider: string;
     createdAt: string;
     updatedAt: string;
+    workspaceId?: string | undefined;
+    internal?: boolean | undefined;
+    attentionReason?: "finished" | "error" | "permission" | null | undefined;
     title?: string | null | undefined;
     persistence?: {
         provider: string;
@@ -246,7 +251,7 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     lastActivityAt?: string | undefined;
     lastUserMessageAt?: string | null | undefined;
     labels?: Record<string, string> | undefined;
-    lastStatus?: "error" | "running" | "initializing" | "idle" | "closed" | undefined;
+    lastStatus?: "error" | "idle" | "running" | "initializing" | "closed" | undefined;
     lastModeId?: string | null | undefined;
     config?: {
         modeId?: string | null | undefined;
@@ -266,15 +271,14 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
         extra?: Record<string, unknown> | undefined;
     } | undefined;
     features?: ({
-        type: "toggle";
         value: boolean;
+        type: "toggle";
         id: string;
         label: string;
         description?: string | undefined;
         icon?: string | undefined;
         tooltip?: string | undefined;
     } | {
-        type: "select";
         value: string | null;
         options: {
             id: string;
@@ -283,6 +287,7 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
             metadata?: Record<string, unknown> | undefined;
             isDefault?: boolean | undefined;
         }[];
+        type: "select";
         id: string;
         label: string;
         description?: string | undefined;
@@ -291,9 +296,7 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     })[] | undefined;
     lastError?: string | null | undefined;
     requiresAttention?: boolean | undefined;
-    attentionReason?: "finished" | "error" | "permission" | null | undefined;
     attentionTimestamp?: string | null | undefined;
-    internal?: boolean | undefined;
     archivedAt?: string | null | undefined;
 }>;
 export type SerializableAgentConfig = Pick<AgentSessionConfig, "modeId" | "model" | "thinkingOptionId" | "featureValues" | "extra" | "systemPrompt" | "mcpServers">;
@@ -318,15 +321,11 @@ export declare class AgentStorage {
     private writeRecord;
     beginDelete(agentId: string): void;
     remove(agentId: string): Promise<void>;
-    applySnapshot(agent: ManagedAgent, workspaceIdOrOptions?: string | {
-        title?: string | null;
-        internal?: boolean;
-    }, options?: {
+    applySnapshot(agent: ManagedAgent, options?: {
         title?: string | null;
         internal?: boolean;
     }): Promise<void>;
     setTitle(agentId: string, title: string): Promise<void>;
-    setGeneratedTitle(agentId: string, title: string): Promise<StoredAgentRecord>;
     flush(): Promise<void>;
     private load;
     private doLoad;

package/dist/server/server/agent/agent-storage.js

@@ -29,6 +29,7 @@ const STORED_AGENT_SCHEMA = z.object({
     id: z.string(),
     provider: z.string(),
     cwd: z.string(),
+    workspaceId: z.string().optional(),
     createdAt: z.string(),
     updatedAt: z.string(),
     lastActivityAt: z.string().optional(),
@@ -146,19 +147,16 @@ export class AgentStorage {
         this.pathById.delete(agentId);
         this.pathsById.delete(agentId);
     }
-    async applySnapshot(agent, workspaceIdOrOptions, options) {
-        const nextOptions = typeof workspaceIdOrOptions === "string" ? options : workspaceIdOrOptions;
+    async applySnapshot(agent, options) {
         await this.load();
         await this.waitForPendingWrite(agent.id);
         const existing = (await this.get(agent.id)) ?? null;
-        const hasTitleOverride = nextOptions !== undefined && Object.prototype.hasOwnProperty.call(nextOptions, "title");
-        const hasInternalOverride = nextOptions !== undefined && Object.prototype.hasOwnProperty.call(nextOptions, "internal");
+        const hasTitleOverride = options !== undefined && Object.prototype.hasOwnProperty.call(options, "title");
+        const hasInternalOverride = options !== undefined && Object.prototype.hasOwnProperty.call(options, "internal");
         const record = toStoredAgentRecord(agent, {
-            title: hasTitleOverride ? (nextOptions?.title ?? null) : (existing?.title ?? null),
+            title: hasTitleOverride ? (options?.title ?? null) : (existing?.title ?? null),
             createdAt: existing?.createdAt,
-            internal: hasInternalOverride
-                ? nextOptions?.internal
-                : (agent.internal ?? existing?.internal),
+            internal: hasInternalOverride ? options?.internal : (agent.internal ?? existing?.internal),
         });
         // Preserve soft-delete/archive status across snapshot flushes.
         // `archivedAt` is not part of the ManagedAgent snapshot, so a naive projection
@@ -177,21 +175,6 @@ export class AgentStorage {
         }
         await this.upsert({ ...record, title });
     }
-    async setGeneratedTitle(agentId, title) {
-        await this.load();
-        await this.waitForPendingWrite(agentId);
-        const record = this.cache.get(agentId) ?? null;
-        if (!record) {
-            throw new Error(`Agent ${agentId} not found`);
-        }
-        const nextRecord = {
-            ...record,
-            title,
-            updatedAt: new Date().toISOString(),
-        };
-        await this.queueRecordWrite(nextRecord);
-        return nextRecord;
-    }
     async flush() {
         await this.load().catch(() => undefined);
         const writes = Array.from(this.pendingWrites.values());