@getpaseo/server 0.1.96 → 0.1.97-beta.1

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

@@ -1,19 +1,15 @@
 import type { Logger } from "pino";
 import type { TerminalManager } from "../../../terminal/terminal-manager.js";
-import type { WorkspaceGitService } from "../../workspace-git-service.js";
 import type { AgentWorktreeSetupContinuation, CreatePaseoWorktreeWorkflowFn } from "../../worktree-session.js";
 import type { AgentAttachment, FirstAgentContext, GitSetupOptions } from "../../messages.js";
 import type { AgentManager, ManagedAgent } from "../agent-manager.js";
-import type { StructuredGenerationDaemonConfig } from "../structured-generation-providers.js";
 import type { AgentSessionConfig } from "../agent-sdk-types.js";
 import type { AgentStorage } from "../agent-storage.js";
 import type { ProviderSnapshotManager } from "../provider-snapshot-manager.js";
-export interface CreateAgentWorkspace {
-    workspaceId: string;
-}
 export interface CreateAgentSessionWorktreeResult {
     sessionConfig: AgentSessionConfig;
     setupContinuation?: AgentWorktreeSetupContinuation;
+    createdWorkspaceId?: string;
 }
 interface CreateAgentCommandDependencies {
     agentManager: AgentManager;
@@ -21,11 +17,10 @@ interface CreateAgentCommandDependencies {
     logger: Logger;
     paseoHome?: string;
     worktreesRoot?: string;
-    workspaceGitService?: Pick<WorkspaceGitService, "getSnapshot" | "listWorktrees" | "resolveRepoRoot">;
     terminalManager?: TerminalManager | null;
     providerSnapshotManager: ProviderSnapshotManager;
-    daemonConfig?: StructuredGenerationDaemonConfig | null;
     createPaseoWorktree?: CreatePaseoWorktreeWorkflowFn;
+    ensureWorkspaceForCreate?: (cwd: string) => Promise<string>;
 }
 export interface CreateAgentFromSessionInput {
     kind: "session";
@@ -44,13 +39,8 @@ export interface CreateAgentFromSessionInput {
     labels: Record<string, string>;
     env?: Record<string, string>;
     provisionalTitle: string | null;
-    explicitTitle: string | null;
     firstAgentContext: FirstAgentContext;
     buildSessionConfig: (config: AgentSessionConfig, gitOptions?: GitSetupOptions, legacyWorktreeName?: string, firstAgentContext?: FirstAgentContext) => Promise<CreateAgentSessionWorktreeResult>;
-    resolveWorkspace: (input: {
-        cwd: string;
-        workspaceId?: string;
-    }) => Promise<CreateAgentWorkspace>;
 }
 export interface CreateAgentFromMcpInput {
     kind: "mcp";

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

@@ -1,7 +1,6 @@
 import { PARENT_AGENT_ID_LABEL } from "@getpaseo/protocol/agent-labels";
 import { expandUserPath, resolvePathFromBase } from "../../path-utils.js";
 import { toWorktreeRequestError } from "../../worktree-errors.js";
-import { scheduleAgentMetadataGeneration } from "../agent-metadata-generator.js";
 import { setupFinishNotification, startCreatedAgentInitialPrompt } from "../agent-prompt.js";
 import { normalizeClientMessageId, resolveClientMessageId } from "../../client-message-id.js";
 import { resolveRequiredProviderModel } from "../mcp-shared.js";
@@ -39,11 +38,7 @@ export async function createAgentCommand(dependencies, input) {
 }
 async function resolveSessionCreateAgent(dependencies, input) {
     const trimmedPrompt = input.initialPrompt?.trim();
-    const { sessionConfig, setupContinuation } = await input.buildSessionConfig(input.config, input.git, input.worktreeName, input.firstAgentContext);
-    const workspace = await input.resolveWorkspace({
-        cwd: sessionConfig.cwd,
-        workspaceId: input.workspaceId,
-    });
+    const { sessionConfig, setupContinuation, createdWorkspaceId } = await input.buildSessionConfig(input.config, input.git, input.worktreeName, input.firstAgentContext);
     const prompt = buildAgentPrompt(trimmedPrompt ?? "", input.images, input.attachments);
     const hasPromptContent = Array.isArray(prompt) ? prompt.length > 0 : prompt.length > 0;
     const clientMessageId = normalizeClientMessageId(input.clientMessageId);
@@ -57,15 +52,16 @@ async function resolveSessionCreateAgent(dependencies, input) {
         config: sessionConfig,
         createOptions: {
             labels: input.labels,
-            workspaceId: workspace.workspaceId,
             initialPrompt: trimmedPrompt,
             env: input.env,
             initialTitle: input.provisionalTitle,
+            // A legacy git/worktreeName worktree creates a fresh workspace, so the
+            // agent belongs to that workspace, not the source one (mirrors the MCP
+            // path). createdWorkspaceId is the freshly created worktree's workspace.
+            workspaceId: setupContinuation ? createdWorkspaceId : input.workspaceId,
         },
-        metadataInitialPrompt: trimmedPrompt,
         prompt: hasPromptContent ? prompt : undefined,
         runOptions,
-        explicitTitle: input.explicitTitle,
         setupContinuation,
         background: true,
         promptFailure: "throw",
@@ -88,12 +84,21 @@ async function resolveMcpCreateAgent(dependencies, input) {
             allowCustomCwd: input.callerContext?.allowCustomCwd ?? true,
         })
         : expandUserPath(input.cwd ?? process.cwd());
-    const { resolvedCwd, setupContinuation } = await resolveMcpCwd({
+    const { resolvedCwd, setupContinuation, createdWorkspaceId } = await resolveMcpCwd({
         dependencies,
         cwd,
         worktree: input.worktree,
         initialPrompt: input.initialPrompt,
     });
+    // A child agent created in its parent's working tree belongs to the parent's
+    // workspace. When a new worktree is created the child lives in that fresh
+    // workspace, so it is stamped with the new worktree's workspaceId instead
+    // (mirrors the session path) — keeping the agent discoverable by
+    // workspaceId-scoped archive. With neither a parent nor a worktree, the agent
+    // mints its own workspace; ownership is never resolved from cwd.
+    const workspaceId = setupContinuation
+        ? createdWorkspaceId
+        : (parentAgent?.workspaceId ?? (await ensureWorkspaceForMcpCreate(dependencies, resolvedCwd)));
     const { modeId: resolvedMode, featureValues: resolvedFeatures } = await dependencies.providerSnapshotManager.resolveCreateConfig({
         cwd: resolvedCwd,
         provider,
@@ -119,33 +124,25 @@ async function resolveMcpCreateAgent(dependencies, input) {
             thinkingOptionId: input.thinking,
             ...(resolvedFeatures ? { featureValues: resolvedFeatures } : {}),
         },
-        createOptions: labels ? { labels } : undefined,
-        metadataInitialPrompt: trimmedPrompt,
+        createOptions: labels || workspaceId
+            ? {
+                ...(labels ? { labels } : {}),
+                ...(workspaceId ? { workspaceId } : {}),
+            }
+            : undefined,
         prompt: trimmedPrompt,
-        explicitTitle: input.title.trim(),
         setupContinuation,
         background: input.background,
         promptFailure: "log",
     };
 }
+async function ensureWorkspaceForMcpCreate(dependencies, cwd) {
+    if (!dependencies.ensureWorkspaceForCreate) {
+        return undefined;
+    }
+    return dependencies.ensureWorkspaceForCreate(cwd);
+}
 async function sendInitialPrompt(dependencies, resolved, snapshot) {
-    scheduleAgentMetadataGeneration({
-        agentManager: dependencies.agentManager,
-        agentId: snapshot.id,
-        cwd: snapshot.cwd,
-        workspaceGitService: dependencies.workspaceGitService,
-        providerSnapshotManager: dependencies.providerSnapshotManager,
-        daemonConfig: dependencies.daemonConfig,
-        currentSelection: {
-            provider: snapshot.provider,
-            model: snapshot.runtimeInfo?.model ?? resolved.config.model,
-            thinkingOptionId: snapshot.runtimeInfo?.thinkingOptionId ?? resolved.config.thinkingOptionId ?? null,
-        },
-        initialPrompt: resolved.metadataInitialPrompt,
-        explicitTitle: resolved.explicitTitle,
-        paseoHome: dependencies.paseoHome,
-        logger: dependencies.logger,
-    });
     try {
         const prompt = resolved.prompt;
         if (prompt === undefined) {
@@ -256,6 +253,7 @@ async function resolveMcpCwd(params) {
     return {
         resolvedCwd: createdWorktree.worktree.worktreePath,
         setupContinuation: createdWorktree.setupContinuation,
+        createdWorkspaceId: createdWorktree.workspace.workspaceId,
     };
 }
 async function createMcpWorktree(options) {

package/dist/server/server/agent/create-agent-lifecycle-dispatch.d.ts

@@ -1,5 +1,6 @@
 import type pino from "pino";
 import type { GitHubService } from "../../services/github-service.js";
+import { type ActiveWorkspaceRef } from "../workspace-archive-service.js";
 import type { CreatePaseoWorktreeWorkflowFn, CreatePaseoWorktreeWorkflowResult } from "../worktree-session.js";
 import type { WorkspaceGitService } from "../workspace-git-service.js";
 import type { CreateAgentWorktreeTarget, FirstAgentContext, SessionOutboundMessage } from "../messages.js";
@@ -14,14 +15,15 @@ interface CreateAgentLifecycleDispatchDependencies {
     workspaceGitService: WorkspaceGitService;
     createPaseoWorktreeWorkflow: CreatePaseoWorktreeWorkflowFn;
     archiveAgentForClose: (agentId: string) => Promise<unknown>;
+    findWorkspaceIdForCwd: (cwd: string) => Promise<string | null>;
+    listActiveWorkspaces: () => Promise<ActiveWorkspaceRef[]>;
     archiveWorkspaceRecord: (workspaceId: string) => Promise<void>;
     emit: (message: SessionOutboundMessage) => void;
     emitAgentRemove: (agentId: string) => void;
     emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds: Iterable<string>) => Promise<void>;
     markWorkspaceArchiving: (workspaceIds: Iterable<string>, archivingAt: string) => void;
     clearWorkspaceArchiving: (workspaceIds: Iterable<string>) => void;
-    isPathWithinRoot: (rootPath: string, candidatePath: string) => boolean;
-    killTerminalsUnderPath: (rootPath: string) => Promise<void>;
+    killTerminalsForWorkspace: (workspaceId: string) => Promise<void>;
     logger: pino.Logger;
 }
 export declare class CreateAgentLifecycleDispatch {

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

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
-import { archivePaseoWorktree } from "../paseo-worktree-archive-service.js";
+import { archiveByScope, resolveWorkspaceIdAtPath, } from "../workspace-archive-service.js";
 export class CreateAgentLifecycleDispatch {
     constructor(dependencies) {
         this.dependencies = dependencies;
@@ -114,27 +114,36 @@ export class CreateAgentLifecycleDispatch {
         if (!ownership.allowed) {
             throw new Error("Auto-created worktree is not a Paseo-owned worktree");
         }
-        await archivePaseoWorktree({
-            paseoHome: this.dependencies.paseoHome,
-            worktreesRoot: this.dependencies.worktreesRoot,
-            github: this.dependencies.github,
-            workspaceGitService: this.dependencies.workspaceGitService,
-            agentManager: this.dependencies.agentManager,
-            agentStorage: this.dependencies.agentStorage,
-            archiveWorkspaceRecord: this.dependencies.archiveWorkspaceRecord,
-            emitWorkspaceUpdatesForWorkspaceIds: this.dependencies.emitWorkspaceUpdatesForWorkspaceIds,
-            markWorkspaceArchiving: this.dependencies.markWorkspaceArchiving,
-            clearWorkspaceArchiving: this.dependencies.clearWorkspaceArchiving,
-            isPathWithinRoot: this.dependencies.isPathWithinRoot,
-            killTerminalsUnderPath: this.dependencies.killTerminalsUnderPath,
-            sessionLogger: this.dependencies.logger,
-        }, {
-            targetPath: options.worktreePath,
-            repoRoot: options.repoRoot ?? ownership.repoRoot ?? null,
-            worktreesRoot: ownership.worktreeRoot,
-            worktreesBaseRoot: this.dependencies.worktreesRoot,
-            requestId: randomUUID(),
-        });
+        const workspaceId = await resolveWorkspaceIdAtPath({
+            findWorkspaceIdForCwd: this.dependencies.findWorkspaceIdForCwd,
+            listActiveWorkspaces: this.dependencies.listActiveWorkspaces,
+        }, options.worktreePath);
+        if (!workspaceId) {
+            this.dependencies.logger.warn({ worktreePath: options.worktreePath }, "Could not resolve workspace for auto-archive; skipping");
+        }
+        else {
+            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 },
+                repoRoot: options.repoRoot ?? ownership.repoRoot ?? null,
+                paseoWorktreesBaseRoot: this.dependencies.worktreesRoot,
+                requestId: randomUUID(),
+            });
+        }
         if (options.agentId) {
             this.dependencies.emitAgentRemove(options.agentId);
         }

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

@@ -4,10 +4,7 @@ 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 { scheduleAgentMetadataGeneration } from "./agent-metadata-generator.js";
-import type { StructuredGenerationDaemonConfig } from "./structured-generation-providers.js";
 import type { FetchRecentProviderSessionsRequestMessage, ImportAgentRequestMessageSchema, RecentProviderSessionDescriptorPayload } from "@getpaseo/protocol/messages";
-import type { WorkspaceGitService } from "../workspace-git-service.js";
 type ImportAgentRequestMessage = z.infer<typeof ImportAgentRequestMessageSchema>;
 export interface NormalizedImportAgentRequest {
     provider: AgentProvider;
@@ -32,16 +29,10 @@ export interface ListImportableProviderSessionsResult {
 }
 export interface ImportProviderSessionInput {
     request: NormalizedImportAgentRequest;
+    workspaceId: string;
     agentManager: AgentManager;
     agentStorage: AgentStorage;
-    workspaceGitService?: Pick<WorkspaceGitService, "resolveRepoRoot">;
-    providerSnapshotManager?: Pick<ProviderSnapshotManager, "listProviders">;
-    daemonConfig?: StructuredGenerationDaemonConfig | null;
-    paseoHome?: string;
     logger: Logger;
-    deps?: {
-        scheduleAgentMetadataGeneration?: typeof scheduleAgentMetadataGeneration;
-    };
 }
 export interface ImportProviderSessionResult {
     snapshot: ManagedAgent;

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

@@ -1,5 +1,3 @@
-import { scheduleAgentMetadataGeneration } from "./agent-metadata-generator.js";
-import { resolveCreateAgentTitles } from "./create-agent-title.js";
 import { unarchiveAgentState } from "./agent-prompt.js";
 import { toRecentProviderSessionDescriptorPayload } from "./agent-projections.js";
 import { createRealpathAwarePathMatcher } from "../../utils/path.js";
@@ -79,19 +77,10 @@ export async function importProviderSession(input) {
         provider,
         providerHandleId,
         cwd,
+        workspaceId: input.workspaceId,
         labels,
     });
     await unarchiveAgentState(input.agentStorage, input.agentManager, snapshot.id);
-    scheduleImportedAgentMetadata({
-        snapshot,
-        agentManager: input.agentManager,
-        workspaceGitService: input.workspaceGitService,
-        providerSnapshotManager: input.providerSnapshotManager,
-        daemonConfig: input.daemonConfig,
-        paseoHome: input.paseoHome,
-        logger: input.logger,
-        scheduleAgentMetadataGeneration: input.deps?.scheduleAgentMetadataGeneration ?? scheduleAgentMetadataGeneration,
-    });
     return {
         snapshot,
         timelineSize: input.agentManager.getTimeline(snapshot.id).length,
@@ -107,35 +96,6 @@ async function unarchiveAgentByHandle(agentStorage, agentManager, handle) {
     }
     await unarchiveAgentState(agentStorage, agentManager, matched.id);
 }
-function scheduleImportedAgentMetadata(input) {
-    const initialPrompt = getFirstUserMessageText(input.agentManager.getTimeline(input.snapshot.id));
-    if (!initialPrompt) {
-        return;
-    }
-    const { explicitTitle } = resolveCreateAgentTitles({
-        configTitle: input.snapshot.config.title,
-        initialPrompt,
-    });
-    input.scheduleAgentMetadataGeneration({
-        agentManager: input.agentManager,
-        agentId: input.snapshot.id,
-        cwd: input.snapshot.cwd,
-        workspaceGitService: input.workspaceGitService,
-        providerSnapshotManager: input.providerSnapshotManager,
-        daemonConfig: input.daemonConfig,
-        currentSelection: {
-            provider: input.snapshot.provider,
-            model: input.snapshot.runtimeInfo?.model ?? input.snapshot.config.model,
-            thinkingOptionId: input.snapshot.runtimeInfo?.thinkingOptionId ??
-                input.snapshot.config.thinkingOptionId ??
-                null,
-        },
-        initialPrompt,
-        explicitTitle,
-        paseoHome: input.paseoHome,
-        logger: input.logger,
-    });
-}
 function parseRecentProviderSessionsSince(since) {
     if (!since) {
         return null;
@@ -157,18 +117,6 @@ function buildImportPersistenceHandle(input) {
         },
     };
 }
-function getFirstUserMessageText(timeline) {
-    for (const item of timeline) {
-        if (item.type !== "user_message") {
-            continue;
-        }
-        const text = item.text.trim();
-        if (text) {
-            return text;
-        }
-    }
-    return null;
-}
 async function collectImportedProviderSessionHandles(agentManager, agentStorage) {
     const handles = new Set();
     for (const agent of agentManager.listAgents()) {

package/dist/server/server/agent/lifecycle-command.js

@@ -24,15 +24,16 @@ export async function cancelAgentRunCommand(dependencies, agentId) {
 }
 export async function archiveAgentCommand(dependencies, agentId) {
     const liveAgent = dependencies.agentManager.getAgent(agentId);
+    let record;
     if (liveAgent) {
         await cancelAgentRunCommand(dependencies, agentId);
         await dependencies.agentManager.clearAgentAttention(agentId).catch(() => undefined);
         await dependencies.agentManager.archiveAgent(agentId);
+        record = await dependencies.agentStorage.get(agentId);
     }
     else {
-        await archiveStoredAgent(dependencies, agentId);
+        record = await archiveStoredAgent(dependencies, agentId);
     }
-    const record = await dependencies.agentStorage.get(agentId);
     if (!record) {
         throw new Error(`Agent not found in storage after archive: ${agentId}`);
     }
@@ -76,9 +77,9 @@ async function archiveStoredAgent(dependencies, agentId) {
         throw new Error(`Agent not found: ${agentId}`);
     }
     if (existing.archivedAt) {
-        return;
+        return existing;
     }
     const archivedAt = new Date().toISOString();
-    await dependencies.agentManager.archiveSnapshot(agentId, archivedAt);
+    return dependencies.agentManager.archiveSnapshot(agentId, archivedAt);
 }
 //# sourceMappingURL=lifecycle-command.js.map

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

@@ -2,7 +2,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { Logger } from "pino";
 import type { AgentManager } from "./agent-manager.js";
 import type { AgentStorage } from "./agent-storage.js";
-import { type ArchivePaseoWorktreeDependencies } from "../paseo-worktree-archive-service.js";
+import { type ArchiveDependencies } from "../workspace-archive-service.js";
 import type { VoiceCallerContext, VoiceSpeakHandler } from "../voice-types.js";
 import type { TerminalManager } from "../../terminal/terminal-manager.js";
 import type { CreatePaseoWorktreeWorkflowFn } from "../worktree-session.js";
@@ -19,11 +19,14 @@ export interface AgentMcpServerOptions {
     providerSnapshotManager: ProviderSnapshotManager;
     github?: GitHubService;
     workspaceGitService?: Pick<WorkspaceGitService, "getSnapshot" | "listWorktrees" | "resolveRepoRoot">;
-    archiveWorkspaceRecord?: ArchivePaseoWorktreeDependencies["archiveWorkspaceRecord"];
-    emitWorkspaceUpdatesForWorkspaceIds?: ArchivePaseoWorktreeDependencies["emitWorkspaceUpdatesForWorkspaceIds"];
-    markWorkspaceArchiving?: ArchivePaseoWorktreeDependencies["markWorkspaceArchiving"];
-    clearWorkspaceArchiving?: ArchivePaseoWorktreeDependencies["clearWorkspaceArchiving"];
+    findWorkspaceIdForCwd?: ArchiveDependencies["findWorkspaceIdForCwd"];
+    listActiveWorkspaces?: ArchiveDependencies["listActiveWorkspaces"];
+    archiveWorkspaceRecord?: ArchiveDependencies["archiveWorkspaceRecord"];
+    emitWorkspaceUpdatesForWorkspaceIds?: ArchiveDependencies["emitWorkspaceUpdatesForWorkspaceIds"];
+    markWorkspaceArchiving?: ArchiveDependencies["markWorkspaceArchiving"];
+    clearWorkspaceArchiving?: ArchiveDependencies["clearWorkspaceArchiving"];
     createPaseoWorktree?: CreatePaseoWorktreeWorkflowFn;
+    ensureWorkspaceForCreate?: (cwd: string) => Promise<string>;
     paseoHome?: string;
     worktreesRoot?: string;
     /**

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

@@ -7,7 +7,7 @@ import { curateAgentActivity } from "./activity-curator.js";
 import { selectItemsByProjectedLimit } from "./timeline-projection.js";
 import { ensureAgentLoaded } from "./agent-loading.js";
 import { isStoredAgentProviderAvailable } from "../persistence-hooks.js";
-import { killTerminalsUnderPath, } from "../paseo-worktree-archive-service.js";
+import { killTerminalsForWorkspace, } from "../workspace-archive-service.js";
 import { WaitForAgentTracker } from "./wait-for-agent-tracker.js";
 import { createAgentCommand } from "./create-agent/create.js";
 import { expandUserPath, isSameOrDescendantPath, resolvePathFromBase } from "../path-utils.js";
@@ -18,7 +18,7 @@ import { sendPromptToAgent, setupFinishNotification } from "./agent-prompt.js";
 import { respondToAgentPermission } from "./permission-response.js";
 import { archiveAgentCommand, cancelAgentRunCommand, closeAgentCommand, setAgentModeCommand, updateAgentCommand, } from "./lifecycle-command.js";
 import { WorktreeRequestError } from "../worktree-errors.js";
-import { archivePaseoWorktreeCommand, createPaseoWorktreeCommand, listPaseoWorktreesCommand, } from "../worktree/commands.js";
+import { archiveCommand, createPaseoWorktreeCommand, listPaseoWorktreesCommand, } from "../worktree/commands.js";
 function addModelVisibleStructuredContent(result) {
     if (result.structuredContent === undefined || result.content.length > 0) {
         return result;
@@ -346,6 +346,20 @@ export async function createAgentMcpServer(options) {
         }
         return expandUserPath(trimmedCwd);
     };
+    async function resolveTerminalWorkspaceId(resolvedCwd) {
+        // An MCP-spawned terminal belongs to the caller agent's workspace. Only if
+        // the caller has no workspace do we mint one for the cwd.
+        const callerAgent = callerAgentId ? agentManager.getAgent(callerAgentId) : null;
+        if (callerAgent?.workspaceId) {
+            return callerAgent.workspaceId;
+        }
+        if (!options.ensureWorkspaceForCreate) {
+            throw new Error(callerAgentId
+                ? `Caller agent ${callerAgentId} has no workspace and workspace minting is not configured`
+                : "workspaceId is required outside an agent-scoped session");
+        }
+        return options.ensureWorkspaceForCreate(resolvedCwd);
+    }
     const buildCallerAgentScheduleConfigExtras = (callerAgent) => {
         return {
             ...(callerAgent.config.thinkingOptionId
@@ -644,10 +658,12 @@ export async function createAgentMcpServer(options) {
             logger: childLogger,
             paseoHome: options.paseoHome,
             worktreesRoot: options.worktreesRoot,
-            workspaceGitService: options.workspaceGitService,
             terminalManager,
             providerSnapshotManager,
             createPaseoWorktree: options.createPaseoWorktree,
+            ...(options.ensureWorkspaceForCreate
+                ? { ensureWorkspaceForCreate: options.ensureWorkspaceForCreate }
+                : {}),
         }, {
             kind: "mcp",
             provider: parsedArgs.provider,
@@ -913,7 +929,7 @@ export async function createAgentMcpServer(options) {
         if (!record || record.internal) {
             throw new Error(`Agent ${agentId} not found`);
         }
-        const structuredSnapshot = buildStoredAgentPayload(record, providerSnapshotManager.listRegisteredProviderIds());
+        const structuredSnapshot = buildStoredAgentPayload(record, new Set(providerSnapshotManager.listRegisteredProviderIds()));
         return {
             content: [],
             structuredContent: ensureValidJson({
@@ -950,7 +966,7 @@ export async function createAgentMcpServer(options) {
         const liveAgents = await Promise.all(liveSnapshots.map((snapshot) => serializeSnapshotWithMetadata(agentStorage, snapshot, childLogger)));
         const liveIds = new Set(liveSnapshots.map((snapshot) => snapshot.id));
         const storedRecords = await agentStorage.list();
-        const registeredProviderIds = providerSnapshotManager.listRegisteredProviderIds();
+        const registeredProviderIds = new Set(providerSnapshotManager.listRegisteredProviderIds());
         const storedAgents = storedRecords
             .filter((record) => !record.internal && !liveIds.has(record.id))
             .filter((record) => includeArchived || !record.archivedAt)
@@ -1106,8 +1122,11 @@ export async function createAgentMcpServer(options) {
         if (!terminalManager) {
             throw new Error("Terminal manager is not configured");
         }
+        const resolvedCwd = resolveScopedCwd(cwd, { required: true });
+        const workspaceId = await resolveTerminalWorkspaceId(resolvedCwd);
         const terminal = await terminalManager.createTerminal({
-            cwd: resolveScopedCwd(cwd, { required: true }),
+            cwd: resolvedCwd,
+            workspaceId,
             ...(name?.trim() ? { name: name.trim() } : {}),
         });
         return {
@@ -1661,7 +1680,7 @@ export async function createAgentMcpServer(options) {
             throw new Error("WorkspaceGitService is required to archive worktrees");
         }
         const repoRoot = await options.workspaceGitService.resolveRepoRoot(resolvedCwd);
-        const result = await archivePaseoWorktreeCommand(archiveWorktreeDependencies(options, {
+        const result = await archiveCommand(archiveWorktreeDependencies(options, {
             agentManager,
             agentStorage,
             terminalManager: terminalManager ?? null,
@@ -1671,6 +1690,9 @@ export async function createAgentMcpServer(options) {
             repoRoot,
             worktreePath,
             worktreeSlug,
+            // This tool archives every workspace on the directory, then removes the
+            // directory. Disk removal is derived from scope + last-reference.
+            scope: "worktree",
         });
         if (!result.ok) {
             throw new Error(result.message);
@@ -1765,7 +1787,7 @@ export async function createAgentMcpServer(options) {
             return payload.pendingPermissions.map((request) => ({
                 agentId: agent.id,
                 status: payload.status,
-                request,
+                request: sanitizePermissionRequest(request),
             }));
         });
         return {
@@ -1809,6 +1831,12 @@ function archiveWorktreeDependencies(options, context) {
     if (!options.archiveWorkspaceRecord) {
         throw new Error("Workspace registry archiver is required to archive worktrees");
     }
+    if (!options.findWorkspaceIdForCwd) {
+        throw new Error("Workspace resolver is required to archive worktrees");
+    }
+    if (!options.listActiveWorkspaces) {
+        throw new Error("Active workspace lister is required to archive worktrees");
+    }
     if (!options.emitWorkspaceUpdatesForWorkspaceIds) {
         throw new Error("Workspace update emitter is required to archive worktrees");
     }
@@ -1820,22 +1848,21 @@ function archiveWorktreeDependencies(options, context) {
     }
     return {
         paseoHome: options.paseoHome,
-        worktreesRoot: options.worktreesRoot,
+        paseoWorktreesBaseRoot: options.worktreesRoot,
         github: options.github,
         workspaceGitService: options.workspaceGitService,
         agentManager: context.agentManager,
         agentStorage: context.agentStorage,
+        findWorkspaceIdForCwd: options.findWorkspaceIdForCwd,
+        listActiveWorkspaces: options.listActiveWorkspaces,
         archiveWorkspaceRecord: options.archiveWorkspaceRecord,
         emitWorkspaceUpdatesForWorkspaceIds: options.emitWorkspaceUpdatesForWorkspaceIds,
         markWorkspaceArchiving: options.markWorkspaceArchiving,
         clearWorkspaceArchiving: options.clearWorkspaceArchiving,
-        isPathWithinRoot: isSameOrDescendantPath,
-        killTerminalsUnderPath: (rootPath) => killTerminalsUnderPath({
+        killTerminalsForWorkspace: (workspaceId) => killTerminalsForWorkspace({
             terminalManager: context.terminalManager,
-            isPathWithinRoot: isSameOrDescendantPath,
-            killTrackedTerminal: () => { },
             sessionLogger: context.logger,
-        }, rootPath),
+        }, workspaceId),
         sessionLogger: context.logger,
     };
 }

package/dist/server/server/agent/mcp-shared.d.ts

@@ -215,6 +215,8 @@ export declare function waitForAgentWithTimeout(agentManager: AgentManager, agen
     signal?: AbortSignal;
     waitForActive?: boolean;
 }): Promise<WaitForAgentResult>;
+export declare function sanitizePermissionRequest(permission: AgentPermissionRequest): AgentPermissionRequest;
+export declare function sanitizePermissionRequest(permission: null | undefined): null;
 export declare function sanitizePermissionRequest(permission: AgentPermissionRequest | null | undefined): AgentPermissionRequest | null;
 export declare function resolveAgentTitle(agentStorage: AgentStorage, agentId: string, logger: Logger): Promise<string | null>;
 export declare function serializeSnapshotWithMetadata(agentStorage: AgentStorage, snapshot: ManagedAgent, logger: Logger): Promise<{
@@ -233,17 +235,18 @@ export declare function serializeSnapshotWithMetadata(agentStorage: AgentStorage
     pendingPermissions: import("@getpaseo/protocol/agent-types").AgentPermissionRequest[];
     persistence: import("@getpaseo/protocol/agent-types").AgentPersistenceHandle | null;
     labels: Record<string, string>;
+    attentionReason?: "finished" | "error" | "permission" | null | undefined;
     thinkingOptionId?: string | null | undefined;
+    workspaceId?: string | 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;
@@ -252,6 +255,7 @@ export declare function serializeSnapshotWithMetadata(agentStorage: AgentStorage
             metadata?: Record<string, unknown> | undefined;
             isDefault?: boolean | undefined;
         }[];
+        type: "select";
         id: string;
         label: string;
         description?: string | undefined;
@@ -263,7 +267,6 @@ export declare function serializeSnapshotWithMetadata(agentStorage: AgentStorage
     lastUsage?: import("@getpaseo/protocol/agent-types").AgentUsage | undefined;
     lastError?: string | undefined;
     requiresAttention?: boolean | undefined;
-    attentionReason?: "finished" | "error" | "permission" | null | undefined;
     attentionTimestamp?: string | null | undefined;
     archivedAt?: string | null | undefined;
     providerUnavailable?: boolean | undefined;

package/dist/server/server/agent/mcp-shared.js

@@ -133,6 +133,9 @@ export function sanitizePermissionRequest(permission) {
     if (sanitized.input === undefined) {
         delete sanitized.input;
     }
+    if (sanitized.detail === undefined) {
+        delete sanitized.detail;
+    }
     if (sanitized.suggestions === undefined) {
         delete sanitized.suggestions;
     }

package/dist/server/server/agent/provider-launch-config.js

@@ -1,5 +1,5 @@
 import { isAbsolute } from "node:path";
-import { executableExists, findExecutable } from "../../utils/executable.js";
+import { executableExists, findExecutable, } from "../../executable-resolution/executable-resolution.js";
 import { createExternalProcessEnv } from "../paseo-env.js";
 export { AgentProviderRuntimeSettingsMapSchema, ProviderCommandSchema, ProviderOverrideSchema, ProviderOverridesSchema, ProviderProfileModelSchema, ProviderRuntimeSettingsSchema, } from "@getpaseo/protocol/provider-config";
 import { ProviderOverrideSchema, ProviderOverridesSchema, ProviderRuntimeSettingsSchema, } from "@getpaseo/protocol/provider-config";