@getpaseo/server 0.1.88 → 0.1.89

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

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { resolve } from "node:path";
 import { stat } from "node:fs/promises";
 import { AGENT_LIFECYCLE_STATUSES, } from "@getpaseo/protocol/agent-lifecycle";
-import { PARENT_AGENT_ID_LABEL } from "@getpaseo/protocol/agent-labels";
+import { isDelegatedAgent, PARENT_AGENT_ID_LABEL } from "@getpaseo/protocol/agent-labels";
 import { z } from "zod";
 import { getAgentStreamEventTurnId, } from "./agent-sdk-types.js";
 import { buildArchivedAgentRecord } from "./agent-archive.js";
@@ -2402,6 +2402,9 @@ export class AgentManager {
         }
     }
     broadcastAgentAttention(agent, reason) {
+        if (isDelegatedAgent(agent)) {
+            return;
+        }
         this.onAgentAttention?.({
             agentId: agent.id,
             provider: agent.provider,

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

@@ -167,22 +167,12 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     archivedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     cwd: string;
-    createdAt: string;
     id: string;
     provider: string;
+    createdAt: string;
     updatedAt: string;
     labels: Record<string, string>;
     lastStatus: "error" | "running" | "initializing" | "idle" | "closed";
-    config?: {
-        modeId?: string | null | undefined;
-        model?: string | null | undefined;
-        thinkingOptionId?: string | null | undefined;
-        featureValues?: Record<string, unknown> | null | undefined;
-        extra?: Record<string, any> | null | undefined;
-        systemPrompt?: string | null | undefined;
-        mcpServers?: Record<string, any> | null | undefined;
-    } | null | undefined;
-    internal?: boolean | undefined;
     title?: string | null | undefined;
     persistence?: {
         provider: string;
@@ -193,6 +183,15 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     lastActivityAt?: string | undefined;
     lastUserMessageAt?: string | null | undefined;
     lastModeId?: string | null | undefined;
+    config?: {
+        modeId?: string | null | undefined;
+        model?: string | null | undefined;
+        thinkingOptionId?: string | null | undefined;
+        featureValues?: Record<string, unknown> | null | undefined;
+        extra?: Record<string, any> | null | undefined;
+        systemPrompt?: string | null | undefined;
+        mcpServers?: Record<string, any> | null | undefined;
+    } | null | undefined;
     runtimeInfo?: {
         provider: string;
         sessionId: string | null;
@@ -229,23 +228,14 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     requiresAttention?: boolean | undefined;
     attentionReason?: "finished" | "error" | "permission" | null | undefined;
     attentionTimestamp?: string | null | undefined;
+    internal?: boolean | undefined;
     archivedAt?: string | null | undefined;
 }, {
     cwd: string;
-    createdAt: string;
     id: string;
     provider: string;
+    createdAt: string;
     updatedAt: string;
-    config?: {
-        modeId?: string | null | undefined;
-        model?: string | null | undefined;
-        thinkingOptionId?: string | null | undefined;
-        featureValues?: Record<string, unknown> | null | undefined;
-        extra?: Record<string, any> | null | undefined;
-        systemPrompt?: string | null | undefined;
-        mcpServers?: Record<string, any> | null | undefined;
-    } | null | undefined;
-    internal?: boolean | undefined;
     title?: string | null | undefined;
     persistence?: {
         provider: string;
@@ -258,6 +248,15 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     labels?: Record<string, string> | undefined;
     lastStatus?: "error" | "running" | "initializing" | "idle" | "closed" | undefined;
     lastModeId?: string | null | undefined;
+    config?: {
+        modeId?: string | null | undefined;
+        model?: string | null | undefined;
+        thinkingOptionId?: string | null | undefined;
+        featureValues?: Record<string, unknown> | null | undefined;
+        extra?: Record<string, any> | null | undefined;
+        systemPrompt?: string | null | undefined;
+        mcpServers?: Record<string, any> | null | undefined;
+    } | null | undefined;
     runtimeInfo?: {
         provider: string;
         sessionId: string | null;
@@ -294,6 +293,7 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
     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">;

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

@@ -20,6 +20,7 @@ interface CreateAgentCommandDependencies {
     agentStorage: AgentStorage;
     logger: Logger;
     paseoHome?: string;
+    worktreesRoot?: string;
     workspaceGitService?: Pick<WorkspaceGitService, "getSnapshot" | "listWorktrees" | "resolveRepoRoot">;
     terminalManager?: TerminalManager | null;
     providerSnapshotManager: ProviderSnapshotManager;
@@ -63,6 +64,7 @@ export interface CreateAgentFromMcpInput {
     mode?: string;
     background: boolean;
     notifyOnFinish: boolean;
+    detached?: boolean;
     callerAgentId?: string;
     callerContext?: {
         lockedCwd?: string;

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

@@ -94,7 +94,12 @@ async function resolveMcpCreateAgent(dependencies, input) {
         featureValues: input.features,
         parent: parentAgent,
     });
-    const labels = mergeLabels(input.callerAgentId, input.callerContext?.childAgentDefaultLabels, input.labels);
+    const labels = mergeLabels({
+        callerAgentId: input.callerAgentId,
+        detached: input.detached ?? false,
+        childAgentDefaultLabels: input.callerContext?.childAgentDefaultLabels,
+        labels: input.labels,
+    });
     const trimmedPrompt = input.initialPrompt.trim();
     return {
         config: {
@@ -220,6 +225,7 @@ async function resolveMcpCwd(params) {
             ...(params.initialPrompt ? { firstAgentContext: { prompt: params.initialPrompt } } : {}),
             runSetup: false,
             paseoHome: dependencies.paseoHome,
+            worktreesRoot: dependencies.worktreesRoot,
         },
         createPaseoWorktree: dependencies.createPaseoWorktree,
         resolveDefaultBranch: baseBranch ? async () => baseBranch : undefined,
@@ -260,12 +266,17 @@ async function createMcpWorktree(options) {
         throw toWorktreeRequestError(error);
     }
 }
-function mergeLabels(callerAgentId, childAgentDefaultLabels, labels) {
+function mergeLabels(params) {
     const mergedLabels = {
-        ...(callerAgentId ? { [PARENT_AGENT_ID_LABEL]: callerAgentId } : {}),
-        ...childAgentDefaultLabels,
-        ...labels,
+        ...(!params.detached && params.callerAgentId
+            ? { [PARENT_AGENT_ID_LABEL]: params.callerAgentId }
+            : {}),
+        ...params.childAgentDefaultLabels,
+        ...params.labels,
     };
+    if (params.detached) {
+        delete mergedLabels[PARENT_AGENT_ID_LABEL];
+    }
     return Object.keys(mergedLabels).length > 0 ? mergedLabels : undefined;
 }
 //# sourceMappingURL=create.js.map

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

@@ -7,6 +7,7 @@ import type { AgentManager } from "./agent-manager.js";
 import type { AgentStorage } from "./agent-storage.js";
 interface CreateAgentLifecycleDispatchDependencies {
     paseoHome: string;
+    worktreesRoot?: string;
     agentManager: AgentManager;
     agentStorage: AgentStorage;
     github: GitHubService;

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

@@ -46,6 +46,7 @@ export class CreateAgentLifecycleDispatch {
             firstAgentContext,
             runSetup: false,
             paseoHome: this.dependencies.paseoHome,
+            worktreesRoot: this.dependencies.worktreesRoot,
         };
         switch (target.mode) {
             case "branch-off":
@@ -108,12 +109,14 @@ export class CreateAgentLifecycleDispatch {
     async archiveAutoCreatedWorktree(options) {
         const ownership = await isPaseoOwnedWorktreeCwd(options.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 archivePaseoWorktree({
             paseoHome: this.dependencies.paseoHome,
+            worktreesRoot: this.dependencies.worktreesRoot,
             github: this.dependencies.github,
             workspaceGitService: this.dependencies.workspaceGitService,
             agentManager: this.dependencies.agentManager,
@@ -129,6 +132,7 @@ export class CreateAgentLifecycleDispatch {
             targetPath: options.worktreePath,
             repoRoot: options.repoRoot ?? ownership.repoRoot ?? null,
             worktreesRoot: ownership.worktreeRoot,
+            worktreesBaseRoot: this.dependencies.worktreesRoot,
             requestId: randomUUID(),
         });
         if (options.agentId) {

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

@@ -25,6 +25,7 @@ export interface AgentMcpServerOptions {
     clearWorkspaceArchiving?: ArchivePaseoWorktreeDependencies["clearWorkspaceArchiving"];
     createPaseoWorktree?: CreatePaseoWorktreeWorkflowFn;
     paseoHome?: string;
+    worktreesRoot?: string;
     /**
      * ID of the agent that is connecting to this MCP server.
      * Used for cwd/mode inheritance when agents spawn child agents.

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

@@ -300,6 +300,23 @@ export async function createAgentMcpServer(options) {
     });
     const registerRawTool = server.registerTool.bind(server);
     const registerTool = (name, config, handler) => registerRawTool(name, relaxMcpToolOutputSchema(config), (async (args, extra) => addModelVisibleStructuredContent(await handler(args, extra))));
+    const buildCronScheduleCadence = (input) => {
+        const expression = input.cron?.trim() ?? "";
+        if (!expression) {
+            throw new Error("cron is required");
+        }
+        const timezone = normalizeScheduleTimeZoneArg(input.timezone);
+        return {
+            type: "cron",
+            expression,
+            ...(timezone !== undefined ? { timezone } : {}),
+        };
+    };
+    const buildScheduleExpiry = (expiresIn) => {
+        return expiresIn === undefined
+            ? undefined
+            : new Date(Date.now() + parseDurationString(expiresIn)).toISOString();
+    };
     const resolveCallerAgent = () => {
         if (!callerAgentId) {
             return null;
@@ -325,7 +342,7 @@ export async function createAgentMcpServer(options) {
             if (opts?.required) {
                 throw new Error("cwd is required");
             }
-            throw new Error("cwd is required when no caller agent is available");
+            throw new Error("cwd is required outside an agent-scoped session");
         }
         return expandUserPath(trimmedCwd);
     };
@@ -469,7 +486,7 @@ export async function createAgentMcpServer(options) {
         cwd: z
             .string()
             .optional()
-            .describe("Optional working directory. Defaults to the caller agent working directory."),
+            .describe("Optional working directory. Defaults to your current working directory."),
         title: z
             .string()
             .trim()
@@ -484,16 +501,16 @@ export async function createAgentMcpServer(options) {
             .trim()
             .min(1, "initialPrompt is required")
             .describe("Required first task to run immediately after creation."),
-        background: z
+        detached: z
             .boolean()
             .optional()
             .default(false)
-            .describe("Run agent in background. If false (default), waits for completion or permission request. If true, returns immediately."),
+            .describe("If true, the created agent stands on its own: it does not appear in your subagent track and is not archived with you."),
         notifyOnFinish: z
             .boolean()
             .optional()
-            .default(false)
-            .describe("Send a notification prompt to the caller agent when this agent finishes, errors, or needs permission. Requires a caller agent context."),
+            .default(true)
+            .describe("Get notified when the created agent finishes, errors, or needs permission. Set false only for truly fire-and-forget agents."),
     };
     const topLevelInputSchema = {
         cwd: z
@@ -541,7 +558,7 @@ export async function createAgentMcpServer(options) {
             .boolean()
             .optional()
             .default(false)
-            .describe("Send a notification prompt to the caller agent when this agent finishes, errors, or needs permission. Requires a caller agent context."),
+            .describe("Agent-scoped only: get notified when the created agent finishes, errors, or needs permission."),
     };
     const createAgentInputSchema = callerAgentId ? agentToAgentInputSchema : topLevelInputSchema;
     const agentToAgentCreateAgentArgsSchema = z.object(agentToAgentInputSchema).strict();
@@ -574,7 +591,7 @@ export async function createAgentMcpServer(options) {
             }
             const handler = resolveSpeakHandler?.(callerAgentId) ?? null;
             if (!handler) {
-                throw new Error(`No speak handler registered for caller agent '${callerAgentId}'`);
+                throw new Error(`No speak handler registered for your session '${callerAgentId}'`);
             }
             await handler({
                 text: args.text,
@@ -603,14 +620,30 @@ export async function createAgentMcpServer(options) {
             availableModes: z.array(ProviderModeSchema),
             lastMessage: z.string().nullable().optional(),
             permission: AgentPermissionRequestPayloadSchema.nullable().optional(),
+            guidance: z.string().optional(),
         },
     }, async (args) => {
-        const { parsedArgs, worktree } = resolveCreateAgentToolArgs(args);
-        const { snapshot, background, initialPromptStarted } = await createAgentCommand({
+        const resolvedArgs = resolveCreateAgentToolArgs(args);
+        const { parsedArgs, worktree } = resolvedArgs;
+        let requestedBackground;
+        let notifyOnFinish;
+        let detached;
+        if (resolvedArgs.kind === "agent-scoped") {
+            requestedBackground = true;
+            notifyOnFinish = resolvedArgs.parsedArgs.notifyOnFinish;
+            detached = resolvedArgs.parsedArgs.detached;
+        }
+        else {
+            requestedBackground = resolvedArgs.parsedArgs.background;
+            notifyOnFinish = resolvedArgs.parsedArgs.notifyOnFinish ?? false;
+            detached = false;
+        }
+        const { snapshot, background: createdInBackground, initialPromptStarted, } = await createAgentCommand({
             agentManager,
             agentStorage,
             logger: childLogger,
             paseoHome: options.paseoHome,
+            worktreesRoot: options.worktreesRoot,
             workspaceGitService: options.workspaceGitService,
             terminalManager,
             providerSnapshotManager,
@@ -625,14 +658,15 @@ export async function createAgentMcpServer(options) {
             features: parsedArgs.settings?.features,
             labels: parsedArgs.labels,
             mode: parsedArgs.settings?.modeId,
-            background: parsedArgs.background ?? false,
-            notifyOnFinish: parsedArgs.notifyOnFinish ?? false,
+            background: requestedBackground,
+            notifyOnFinish,
+            detached,
             callerAgentId,
             callerContext,
             worktree,
         });
         try {
-            if (!background && initialPromptStarted) {
+            if (!createdInBackground && initialPromptStarted) {
                 const result = await waitForAgentWithTimeout(agentManager, snapshot.id, {
                     waitForActive: true,
                 });
@@ -659,8 +693,11 @@ export async function createAgentMcpServer(options) {
             childLogger.error({ err: error, agentId: snapshot.id }, "Failed to run initial prompt");
             throw error;
         }
-        // Return immediately if background=true
+        // Return immediately for async creation.
         const currentSnapshot = agentManager.getAgent(snapshot.id) ?? snapshot;
+        const guidance = callerAgentId && notifyOnFinish && initialPromptStarted
+            ? "You will get notified when the created agent finishes, errors, or needs permission. Do not call wait_for_agent or poll for status; continue with other work until the notification arrives."
+            : undefined;
         const response = {
             content: [],
             structuredContent: ensureValidJson({
@@ -672,6 +709,7 @@ export async function createAgentMcpServer(options) {
                 availableModes: currentSnapshot.availableModes,
                 lastMessage: null,
                 permission: null,
+                ...(guidance ? { guidance } : {}),
             }),
         };
         return response;
@@ -679,12 +717,14 @@ export async function createAgentMcpServer(options) {
     function resolveCreateAgentToolArgs(args) {
         if (callerAgentId) {
             return {
+                kind: "agent-scoped",
                 parsedArgs: agentToAgentCreateAgentArgsSchema.parse(args),
                 worktree: undefined,
             };
         }
         const parsedArgs = topLevelCreateAgentArgsSchema.parse(args);
         return {
+            kind: "top-level",
             parsedArgs,
             worktree: resolveTopLevelCreateAgentWorktree(parsedArgs),
         };
@@ -784,7 +824,7 @@ export async function createAgentMcpServer(options) {
                 .boolean()
                 .optional()
                 .default(false)
-                .describe("Send a notification prompt to the caller agent when this agent finishes, errors, or needs permission."),
+                .describe("Agent-scoped only: get notified when this run finishes, errors, or needs permission."),
         },
         outputSchema: {
             success: z.boolean(),
@@ -1025,7 +1065,7 @@ export async function createAgentMcpServer(options) {
             cwd: z
                 .string()
                 .optional()
-                .describe("Optional working directory. Defaults to the caller agent cwd."),
+                .describe("Optional working directory. Defaults to your current working directory."),
             all: z.boolean().optional().describe("List terminals across all working directories."),
         },
         outputSchema: {
@@ -1058,7 +1098,7 @@ export async function createAgentMcpServer(options) {
             cwd: z
                 .string()
                 .optional()
-                .describe("Optional working directory. Defaults to the caller agent cwd."),
+                .describe("Optional working directory. Defaults to your current working directory."),
             name: z.string().optional().describe("Optional terminal name."),
         },
         outputSchema: TerminalSummarySchema.shape,
@@ -1168,79 +1208,80 @@ export async function createAgentMcpServer(options) {
     });
     registerTool("create_schedule", {
         title: "Create schedule",
-        description: "Create a recurring schedule that runs on an agent or a new agent.",
+        description: "Create a recurring schedule that starts a new agent on a cron cadence.",
         inputSchema: {
             prompt: z.string().trim().min(1, "prompt is required"),
-            every: z.string().optional(),
-            cron: z.string().optional(),
+            cron: z.string().trim().min(1, "cron is required"),
             timezone: z
                 .string()
                 .trim()
                 .min(1)
                 .optional()
-                .describe("IANA time zone for cron cadence; requires cron. For example: America/New_York."),
+                .describe("IANA time zone for the cron cadence. For example: America/New_York."),
             name: z.string().optional(),
-            target: z.enum(["self", "new-agent"]).optional(),
-            provider: AgentProviderEnum.optional().describe("Provider, or provider/model (for example: codex or codex/gpt-5.4)."),
+            provider: AgentProviderEnum.describe("Provider, or provider/model (for example: codex or codex/gpt-5.4)."),
             cwd: z.string().optional(),
             maxRuns: z.number().int().positive().optional(),
             expiresIn: z.string().optional(),
         },
         outputSchema: ScheduleSummarySchema.shape,
-    }, async ({ prompt, every, cron, timezone, name, target, provider, cwd, maxRuns, expiresIn }) => {
+    }, async ({ prompt, cron, timezone, name, provider, cwd, maxRuns, expiresIn }) => {
         if (!scheduleService) {
             throw new Error("Schedule service is not configured");
         }
-        const normalizedEvery = normalizeScheduleCadenceArg(every);
-        const normalizedCron = normalizeScheduleCadenceArg(cron);
-        const normalizedTimeZone = normalizeScheduleTimeZoneArg(timezone);
-        const cadenceCount = Number(normalizedEvery !== undefined) + Number(normalizedCron !== undefined);
-        if (cadenceCount !== 1) {
-            throw new Error("Specify exactly one of every or cron");
+        const expiresAt = buildScheduleExpiry(expiresIn);
+        const schedule = await scheduleService.create({
+            prompt: prompt.trim(),
+            cadence: buildCronScheduleCadence({
+                cron,
+                ...(timezone !== undefined ? { timezone } : {}),
+            }),
+            target: resolveNewAgentScheduleTarget({ provider, cwd }),
+            ...(name?.trim() ? { name: name.trim() } : {}),
+            ...(maxRuns === undefined ? {} : { maxRuns }),
+            ...(expiresAt === undefined ? {} : { expiresAt }),
+        });
+        return {
+            content: [],
+            structuredContent: ensureValidJson(toScheduleSummary(schedule)),
+        };
+    });
+    registerTool("create_heartbeat", {
+        title: "Create heartbeat",
+        description: "Create a recurring heartbeat that sends you a prompt on a cron cadence.",
+        inputSchema: {
+            prompt: z.string().trim().min(1, "prompt is required"),
+            cron: z.string().trim().min(1, "cron is required"),
+            timezone: z
+                .string()
+                .trim()
+                .min(1)
+                .optional()
+                .describe("IANA time zone for the cron cadence. For example: America/New_York."),
+            name: z.string().optional(),
+            maxRuns: z.number().int().positive().optional(),
+            expiresIn: z.string().optional(),
+        },
+        outputSchema: ScheduleSummarySchema.shape,
+    }, async ({ prompt, cron, timezone, name, maxRuns, expiresIn }) => {
+        if (!scheduleService) {
+            throw new Error("Schedule service is not configured");
         }
-        if (normalizedTimeZone !== undefined && normalizedCron === undefined) {
-            throw new Error("timezone can only be used with cron");
+        if (!callerAgentId) {
+            throw new Error("create_heartbeat requires an agent-scoped session");
         }
-        const scheduleTarget = target === "self"
-            ? (() => {
-                const callerAgent = resolveCallerAgent();
-                if (!callerAgentId || !callerAgent) {
-                    throw new Error("target=self requires a caller agent");
-                }
-                const trimmedCwd = cwd?.trim();
-                if (trimmedCwd && expandUserPath(trimmedCwd) !== callerAgent.cwd) {
-                    throw new Error("cwd can only differ from the caller agent when target=new-agent");
-                }
-                if (provider !== undefined) {
-                    const resolved = resolveScheduleProviderAndModel({
-                        provider,
-                        defaultProvider: callerAgent.provider,
-                    });
-                    if (resolved.provider !== callerAgent.provider ||
-                        (resolved.model !== undefined && resolved.model !== callerAgent.config.model)) {
-                        throw new Error("provider can only differ from the caller agent when target=new-agent");
-                    }
-                }
-                return { type: "agent", agentId: callerAgentId };
-            })()
-            : (() => {
-                return resolveNewAgentScheduleTarget({ provider, cwd });
-            })();
+        resolveCallerAgent();
+        const expiresAt = buildScheduleExpiry(expiresIn);
         const schedule = await scheduleService.create({
             prompt: prompt.trim(),
-            cadence: normalizedEvery !== undefined
-                ? { type: "every", everyMs: parseDurationString(normalizedEvery) }
-                : {
-                    type: "cron",
-                    expression: normalizedCron,
-                    ...(normalizedTimeZone !== undefined ? { timezone: normalizedTimeZone } : {}),
-                },
-            target: scheduleTarget,
+            cadence: buildCronScheduleCadence({
+                cron,
+                ...(timezone !== undefined ? { timezone } : {}),
+            }),
+            target: { type: "agent", agentId: callerAgentId },
             ...(name?.trim() ? { name: name.trim() } : {}),
             ...(maxRuns === undefined ? {} : { maxRuns }),
-            ...(expiresIn === undefined
-                ? {}
-                : { expiresAt: new Date(Date.now() + parseDurationString(expiresIn)).toISOString() }),
+            ...(expiresAt === undefined ? {} : { expiresAt }),
         });
         return {
             content: [],
@@ -1518,7 +1559,7 @@ export async function createAgentMcpServer(options) {
             cwd: z
                 .string()
                 .optional()
-                .describe("Optional repository cwd. Defaults to the caller agent cwd."),
+                .describe("Optional repository cwd. Defaults to your current working directory."),
         },
         outputSchema: {
             worktrees: z.array(WorktreeSummarySchema),
@@ -1578,6 +1619,7 @@ export async function createAgentMcpServer(options) {
         const repoRoot = resolveScopedCwd(cwd, { required: true });
         const commandResult = await createPaseoWorktreeCommand({
             paseoHome: options.paseoHome,
+            worktreesRoot: options.worktreesRoot,
             createPaseoWorktreeWorkflow: options.createPaseoWorktree,
         }, createMcpWorktreeCommandInput(repoRoot, target));
         if (!commandResult.ok) {
@@ -1603,7 +1645,7 @@ export async function createAgentMcpServer(options) {
             cwd: z
                 .string()
                 .optional()
-                .describe("Optional repository cwd. Defaults to the caller agent cwd."),
+                .describe("Optional repository cwd. Defaults to your current working directory."),
             worktreePath: z.string().optional(),
             worktreeSlug: z.string().optional(),
         },
@@ -1778,6 +1820,7 @@ function archiveWorktreeDependencies(options, context) {
     }
     return {
         paseoHome: options.paseoHome,
+        worktreesRoot: options.worktreesRoot,
         github: options.github,
         workspaceGitService: options.workspaceGitService,
         agentManager: context.agentManager,

package/dist/server/server/agent/providers/pi/agent.js

@@ -1148,6 +1148,19 @@ export class PiRpcAgentSession {
         }
     }
     handleMessageEnd(event, turnId) {
+        if (event.message.role === "custom") {
+            const text = getUserMessageText(event.message.content);
+            if (text) {
+                this.emit({
+                    type: "timeline",
+                    provider: PI_PROVIDER,
+                    turnId,
+                    item: { type: "assistant_message", text },
+                });
+            }
+            this.completeTurn(turnId, []);
+            return;
+        }
         if (event.message.role !== "user") {
             return;
         }

package/dist/server/server/agent/providers/pi/rpc-types.d.ts

@@ -22,6 +22,9 @@ export type PiAssistantContent = PiTextContent | PiThinkingContent | PiToolCallC
 export type PiAgentMessage = {
     role: "user";
     content: string | Array<PiTextContent | PiImageContent>;
+} | {
+    role: "custom";
+    content: string | Array<PiTextContent | PiImageContent>;
 } | {
     role: "assistant";
     content: PiAssistantContent[];

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

@@ -10,6 +10,7 @@ import type { TerminalManager } from "../../terminal/terminal-manager.js";
 import { isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
 export interface AutoArchiveArchiveOptions {
     paseoHome: string;
+    worktreesRoot?: string;
     daemonConfigStore: DaemonConfigStore;
     workspaceGitService: WorkspaceGitServiceImpl;
     github: GitHubService;

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

@@ -37,13 +37,17 @@ export async function archiveIfSafe(input) {
         if (snapshot.git.isDirty === true || (snapshot.git.aheadOfOrigin ?? 0) > 0) {
             return;
         }
-        const ownership = await deps.isPaseoOwnedWorktreeCwd(cwd, { paseoHome: options.paseoHome });
+        const ownership = await deps.isPaseoOwnedWorktreeCwd(cwd, {
+            paseoHome: options.paseoHome,
+            worktreesRoot: options.worktreesRoot,
+        });
         if (!ownership.allowed) {
             return;
         }
         try {
             await deps.archivePaseoWorktree({
                 paseoHome: options.paseoHome,
+                worktreesRoot: options.worktreesRoot,
                 github: options.github,
                 workspaceGitService: options.workspaceGitService,
                 agentManager: options.agentManager,
@@ -64,6 +68,7 @@ export async function archiveIfSafe(input) {
                 targetPath: cwd,
                 repoRoot: ownership.repoRoot ?? null,
                 worktreesRoot: ownership.worktreeRoot,
+                worktreesBaseRoot: options.worktreesRoot,
                 requestId: "auto-archive-on-merge",
             });
             log.info({ cwd }, "Auto-archived worktree after PR merge");