@hyperdrive.bot/fleet-server 0.3.99

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

@@ -0,0 +1,378 @@
+import { PARENT_AGENT_ID_LABEL } from "@hyperdrive.bot/fleet-protocol/agent-labels";
+import { attachAgentRoutine, planAgentRoutine, } from "./routine.js";
+import { expandUserPath, resolvePathFromBase } from "../../path-utils.js";
+import { toWorktreeRequestError } from "../../worktree-errors.js";
+import { setupFinishNotification, startCreatedAgentInitialPrompt } from "../agent-prompt.js";
+import { normalizeClientMessageId, resolveClientMessageId } from "../../client-message-id.js";
+import { resolveRequiredProviderModel } from "../mcp-shared.js";
+import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from "../timeline-append.js";
+/**
+ * Everything about a routine that can be rejected without creating anything.
+ *
+ * Deliberately run BEFORE the resolve step rather than after: resolving an MCP
+ * create can cut a git worktree, and a whitespace-only system prompt should not
+ * cost the user a stray branch on disk. Both input kinds already know their
+ * system prompt at this point, so nothing is lost by checking early.
+ */
+function planRoutineBeforeCreate(input) {
+    if (!input.routine) {
+        return undefined;
+    }
+    const systemPrompt = input.kind === "session" ? input.config.systemPrompt : (input.systemPrompt ?? undefined);
+    return planAgentRoutine({ routine: input.routine, systemPrompt, now: new Date() });
+}
+/**
+ * The durable descriptions, trimmed, with whitespace-only dropped.
+ *
+ * Same rule as `systemPrompt`: a value of spaces configures nothing, and
+ * storing it would put an empty line on every surface that renders the field.
+ * Extracted rather than inlined because `resolveMcpCreateAgent` is already at
+ * the lint complexity ceiling, and two more conditional spreads inside its
+ * return would push it over.
+ */
+function buildDurableDescriptionConfig(input) {
+    const goal = input.goal?.trim();
+    const jobToBeDone = input.jobToBeDone?.trim();
+    return {
+        ...(goal ? { goal } : {}),
+        ...(jobToBeDone ? { jobToBeDone } : {}),
+    };
+}
+/**
+ * Attach the routine to the agent that was just created, and undo the agent if
+ * that fails.
+ *
+ * Rollback rather than a named orphan, for one reason: this runs BEFORE the
+ * initial prompt starts, so at this instant the agent has done no work and
+ * archiving destroys nothing. The alternative contract ("leave it and name the
+ * id") is what you are forced into once real work exists; here it would just
+ * leave a session-shaped agent behind for a human to clean up by hand, which is
+ * the exact state this whole feature exists to prevent.
+ *
+ * If the rollback ITSELF fails the orphan is unavoidable, so the error names the
+ * agent id and both causes. That path is the only way a half-made durable agent
+ * can survive this function, and it says so out loud instead of failing silently.
+ */
+async function attachRoutineOrRollback(params) {
+    const { dependencies, plan, agentId } = params;
+    try {
+        return await attachAgentRoutine({
+            scheduleService: dependencies.scheduleService,
+            agentId,
+            plan,
+        });
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        try {
+            await dependencies.agentManager.archiveAgent(agentId);
+        }
+        catch (rollbackError) {
+            const rollbackReason = rollbackError instanceof Error ? rollbackError.message : String(rollbackError);
+            dependencies.logger.error({ err: rollbackError, agentId }, "Failed to roll back agent after its routine could not be created");
+            throw new Error(`Failed to create the routine (${reason}) and failed to roll back agent ${agentId} (${rollbackReason}). Agent ${agentId} exists with no routine: archive it or attach a schedule to it by hand.`, { cause: rollbackError });
+        }
+        dependencies.logger.warn({ err: error, agentId }, "Rolled back agent because its routine could not be created");
+        throw new Error(`Failed to create the routine, so agent ${agentId} was rolled back: ${reason}`, {
+            cause: error,
+        });
+    }
+}
+export async function createAgentCommand(dependencies, input) {
+    const routinePlan = planRoutineBeforeCreate(input);
+    const resolved = input.kind === "session"
+        ? await resolveSessionCreateAgent(dependencies, input)
+        : await resolveMcpCreateAgent(dependencies, input);
+    const snapshot = await dependencies.agentManager.createAgent(resolved.config, undefined, resolved.createOptions);
+    resolved.setupContinuation?.startAfterAgentCreate({
+        agentId: snapshot.id,
+    });
+    // Before the initial prompt, so the agent is either durable or gone. Running
+    // it after would mean rolling back an agent that had already started working.
+    const routine = routinePlan
+        ? await attachRoutineOrRollback({ dependencies, plan: routinePlan, agentId: snapshot.id })
+        : undefined;
+    let liveSnapshot = snapshot;
+    let initialPromptStarted = false;
+    if (resolved.prompt !== undefined) {
+        const sendResult = await sendInitialPrompt(dependencies, resolved, snapshot);
+        initialPromptStarted = sendResult.started;
+        liveSnapshot = sendResult.liveSnapshot;
+    }
+    if (input.kind === "mcp" && input.notifyOnFinish && input.callerAgentId && initialPromptStarted) {
+        setupFinishNotification({
+            agentManager: dependencies.agentManager,
+            agentStorage: dependencies.agentStorage,
+            childAgentId: snapshot.id,
+            callerAgentId: input.callerAgentId,
+            logger: dependencies.logger,
+        });
+    }
+    return {
+        snapshot,
+        liveSnapshot,
+        background: resolved.background,
+        initialPromptStarted,
+        ...(routine ? { routine } : {}),
+    };
+}
+async function resolveSessionCreateAgent(dependencies, input) {
+    const trimmedPrompt = input.initialPrompt?.trim();
+    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);
+    const runOptions = input.outputSchema || clientMessageId
+        ? {
+            ...(input.outputSchema ? { outputSchema: input.outputSchema } : {}),
+            ...(clientMessageId ? { messageId: clientMessageId } : {}),
+        }
+        : undefined;
+    return {
+        config: sessionConfig,
+        createOptions: {
+            labels: input.labels,
+            initialPrompt: trimmedPrompt,
+            env: input.env,
+            initialTitle: input.provisionalTitle,
+            // Must reach agentManager.createAgent, or the provider session is built
+            // without `--resume` and the resumed chat hydrates empty.
+            ...(input.resumeSessionId ? { resumeSessionId: input.resumeSessionId } : {}),
+            // 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,
+        },
+        prompt: hasPromptContent ? prompt : undefined,
+        runOptions,
+        setupContinuation,
+        background: true,
+        promptFailure: "throw",
+        promptLogger: dependencies.logger.child({
+            clientMessageId: resolveClientMessageId(input.clientMessageId),
+        }),
+    };
+}
+async function resolveMcpCreateAgent(dependencies, input) {
+    const resolvedProviderModel = resolveRequiredProviderModel(input.provider);
+    const provider = resolvedProviderModel.provider;
+    const parentAgent = input.callerAgentId
+        ? requireParentAgent(dependencies.agentManager, input.callerAgentId)
+        : null;
+    const cwd = parentAgent
+        ? resolveChildAgentCwd({
+            parentCwd: parentAgent.cwd,
+            requestedCwd: input.cwd,
+            lockedCwd: input.callerContext?.lockedCwd,
+            allowCustomCwd: input.callerContext?.allowCustomCwd ?? true,
+        })
+        : expandUserPath(input.cwd ?? process.cwd());
+    const { resolvedCwd, setupContinuation, createdWorkspaceId } = await resolveMcpCwd({
+        dependencies,
+        cwd,
+        worktree: input.worktree,
+        initialPrompt: input.initialPrompt,
+    });
+    // MCP callers resolve workspace ownership before this point. Worktree
+    // creation wins because the new agent lives in the fresh worktree workspace.
+    // Otherwise use the explicit workspace id, then the parent workspace for
+    // direct internal callers. Ownership is never resolved from cwd.
+    const workspaceId = setupContinuation
+        ? createdWorkspaceId
+        : (input.workspaceId ??
+            parentAgent?.workspaceId ??
+            (await ensureWorkspaceForMcpCreate(dependencies, resolvedCwd, input.initialPrompt)));
+    const { modeId: resolvedMode, featureValues: resolvedFeatures } = await dependencies.providerSnapshotManager.resolveCreateConfig({
+        cwd: resolvedCwd,
+        provider,
+        requestedMode: input.mode,
+        featureValues: input.features,
+        parent: parentAgent,
+        unattended: false,
+    });
+    const labels = mergeLabels({
+        callerAgentId: input.callerAgentId,
+        detached: input.detached ?? false,
+        childAgentDefaultLabels: input.callerContext?.childAgentDefaultLabels,
+        labels: input.labels,
+    });
+    const trimmedPrompt = input.initialPrompt.trim();
+    // Whitespace-only is dropped rather than stored: it configures nothing, and
+    // storing it would let an agent satisfy half the durable-agent predicate with
+    // an empty prompt.
+    const trimmedSystemPrompt = input.systemPrompt?.trim();
+    return {
+        config: {
+            provider,
+            cwd: resolvedCwd,
+            modeId: resolvedMode,
+            title: input.title.trim(),
+            model: resolvedProviderModel.model,
+            thinkingOptionId: input.thinking,
+            ...(resolvedFeatures ? { featureValues: resolvedFeatures } : {}),
+            ...(trimmedSystemPrompt ? { systemPrompt: trimmedSystemPrompt } : {}),
+            ...buildDurableDescriptionConfig(input),
+        },
+        createOptions: labels || workspaceId
+            ? {
+                ...(labels ? { labels } : {}),
+                ...(workspaceId ? { workspaceId } : {}),
+            }
+            : undefined,
+        prompt: trimmedPrompt,
+        setupContinuation,
+        background: input.background,
+        promptFailure: "log",
+    };
+}
+async function ensureWorkspaceForMcpCreate(dependencies, cwd, initialPrompt) {
+    if (!dependencies.ensureWorkspaceForCreate) {
+        return undefined;
+    }
+    return dependencies.ensureWorkspaceForCreate(cwd, { prompt: initialPrompt });
+}
+async function sendInitialPrompt(dependencies, resolved, snapshot) {
+    try {
+        const prompt = resolved.prompt;
+        if (prompt === undefined) {
+            return { started: false, liveSnapshot: snapshot };
+        }
+        const liveSnapshot = await startCreatedAgentInitialPrompt({
+            agentManager: dependencies.agentManager,
+            agentId: snapshot.id,
+            snapshot,
+            prompt,
+            runOptions: resolved.runOptions,
+            logger: resolved.promptLogger ?? dependencies.logger,
+        });
+        return { started: true, liveSnapshot };
+    }
+    catch (error) {
+        if (resolved.promptFailure === "throw") {
+            throw error;
+        }
+        dependencies.logger.error({ err: error, agentId: snapshot.id }, "Failed to run initial prompt");
+        return { started: false, liveSnapshot: snapshot };
+    }
+}
+function buildAgentPrompt(text, images, attachments) {
+    const normalized = text.trim();
+    const hasImages = (images?.length ?? 0) > 0;
+    const hasAttachments = (attachments?.length ?? 0) > 0;
+    if (!hasImages && !hasAttachments) {
+        return normalized;
+    }
+    const blocks = [];
+    if (normalized.length > 0) {
+        blocks.push({ type: "text", text: normalized });
+    }
+    for (const image of images ?? []) {
+        blocks.push({ type: "image", data: image.data, mimeType: image.mimeType });
+    }
+    for (const attachment of attachments ?? []) {
+        blocks.push(attachment);
+    }
+    return blocks;
+}
+function requireParentAgent(agentManager, parentAgentId) {
+    const parentAgent = agentManager.getAgent(parentAgentId);
+    if (!parentAgent) {
+        throw new Error(`Parent agent ${parentAgentId} not found`);
+    }
+    return parentAgent;
+}
+function resolveChildAgentCwd(params) {
+    const lockedCwd = params.lockedCwd?.trim();
+    if (lockedCwd) {
+        return expandUserPath(lockedCwd);
+    }
+    const requestedCwd = params.requestedCwd?.trim();
+    if (!requestedCwd || !params.allowCustomCwd) {
+        return params.parentCwd;
+    }
+    return resolvePathFromBase(params.parentCwd, requestedCwd);
+}
+async function resolveMcpCwd(params) {
+    const { dependencies, worktree } = params;
+    if (!worktree) {
+        return { resolvedCwd: params.cwd };
+    }
+    const shouldCreateWorktree = Boolean(worktree.worktreeName || worktree.refName || worktree.action || worktree.githubPrNumber);
+    if (!shouldCreateWorktree) {
+        return { resolvedCwd: params.cwd };
+    }
+    if (worktree.worktreeName &&
+        !worktree.baseBranch &&
+        !worktree.refName &&
+        !worktree.action &&
+        worktree.githubPrNumber === undefined) {
+        throw new Error("baseBranch is required when creating a worktree");
+    }
+    const baseBranch = worktree.baseBranch;
+    const createdWorktree = await createMcpWorktree({
+        input: {
+            cwd: params.cwd,
+            worktreeSlug: worktree.worktreeName,
+            branchName: worktree.branchName,
+            refName: worktree.refName,
+            action: worktree.action,
+            githubPrNumber: worktree.githubPrNumber,
+            firstAgentContext: { prompt: params.initialPrompt },
+            runSetup: false,
+            paseoHome: dependencies.paseoHome,
+            worktreesRoot: dependencies.worktreesRoot,
+        },
+        createPaseoWorktree: dependencies.createPaseoWorktree,
+        resolveDefaultBranch: baseBranch ? async () => baseBranch : undefined,
+        setupContinuation: {
+            kind: "agent",
+            terminalManager: dependencies.terminalManager ?? null,
+            appendTimelineItem: ({ agentId, item }) => appendTimelineItemIfAgentKnown({
+                agentManager: dependencies.agentManager,
+                agentId,
+                item,
+            }),
+            emitLiveTimelineItem: ({ agentId, item }) => emitLiveTimelineItemIfAgentKnown({
+                agentManager: dependencies.agentManager,
+                agentId,
+                item,
+            }),
+            logger: dependencies.logger,
+        },
+    });
+    return {
+        resolvedCwd: createdWorktree.worktree.worktreePath,
+        setupContinuation: createdWorktree.setupContinuation,
+        createdWorkspaceId: createdWorktree.workspace.workspaceId,
+    };
+}
+async function createMcpWorktree(options) {
+    try {
+        if (!options.createPaseoWorktree) {
+            throw new Error("Paseo worktree service is not configured");
+        }
+        return await options.createPaseoWorktree(options.input, {
+            ...(options.resolveDefaultBranch
+                ? { resolveDefaultBranch: options.resolveDefaultBranch }
+                : {}),
+            ...(options.setupContinuation ? { setupContinuation: options.setupContinuation } : {}),
+        });
+    }
+    catch (error) {
+        throw toWorktreeRequestError(error);
+    }
+}
+function mergeLabels(params) {
+    const mergedLabels = {
+        ...(!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/routine.d.ts

@@ -0,0 +1,45 @@
+import type { AgentRoutine } from "@hyperdrive.bot/fleet-protocol/schedule/routine";
+import type { CreateScheduleInput, StoredSchedule } from "@hyperdrive.bot/fleet-protocol/schedule/types";
+/**
+ * Creating a durable agent used to take two calls, and between them the agent
+ * had a system prompt and no schedule, which is exactly the shape of a plain
+ * session. This module is the half of the one-call path that can be decided
+ * BEFORE anything is created.
+ *
+ * Only the schedule store write is left to fail after the agent exists, which
+ * is what makes the rollback in createAgentCommand small enough to be honest.
+ */
+export interface AgentRoutinePlan {
+    /** Ready for `ScheduleService.create` once the agent id is known. */
+    toCreateInput(agentId: string): CreateScheduleInput;
+}
+/** What the caller gets back so it can report the routine it just attached. */
+export interface AttachedAgentRoutine {
+    scheduleId: string;
+    nextRunAt: string | null;
+}
+/**
+ * Validate the routine and the system prompt it depends on, and lower the
+ * cadence, without touching any store.
+ *
+ * `systemPrompt` is required here and not merely encouraged. The pair is what
+ * makes an agent durable: a routine with no persona wakes an agent up every
+ * morning with nothing telling it who it is, which is a worse outcome than
+ * refusing the call, because it looks like it worked. Whitespace counts as
+ * empty, matching the trim every other prompt field in this path applies.
+ */
+export declare function planAgentRoutine(params: {
+    routine: AgentRoutine;
+    systemPrompt: string | undefined;
+    now: Date;
+}): AgentRoutinePlan;
+/** Minimal slice of ScheduleService this path needs, so tests can fake it. */
+export interface AgentRoutineScheduleService {
+    create(input: CreateScheduleInput): Promise<StoredSchedule>;
+}
+export declare function attachAgentRoutine(params: {
+    scheduleService: AgentRoutineScheduleService | undefined;
+    agentId: string;
+    plan: AgentRoutinePlan;
+}): Promise<AttachedAgentRoutine>;
+//# sourceMappingURL=routine.d.ts.map

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

@@ -0,0 +1,53 @@
+import { resolveScheduleCreateCadence } from "../../schedule/create-cadence.js";
+/**
+ * Validate the routine and the system prompt it depends on, and lower the
+ * cadence, without touching any store.
+ *
+ * `systemPrompt` is required here and not merely encouraged. The pair is what
+ * makes an agent durable: a routine with no persona wakes an agent up every
+ * morning with nothing telling it who it is, which is a worse outcome than
+ * refusing the call, because it looks like it worked. Whitespace counts as
+ * empty, matching the trim every other prompt field in this path applies.
+ */
+export function planAgentRoutine(params) {
+    const systemPrompt = params.systemPrompt?.trim();
+    if (!systemPrompt) {
+        throw new Error("A routine requires a non-empty system prompt: an agent that wakes on a schedule with no persona is a trap, not a durable agent.");
+    }
+    const prompt = params.routine.prompt.trim();
+    if (!prompt) {
+        throw new Error("routine.prompt is required");
+    }
+    const { cadence, oneOff } = resolveScheduleCreateCadence({
+        ...(params.routine.at !== undefined ? { at: params.routine.at } : {}),
+        ...(params.routine.every !== undefined ? { every: params.routine.every } : {}),
+        ...(params.routine.cron !== undefined ? { cron: params.routine.cron } : {}),
+        ...(params.routine.timezone !== undefined ? { timezone: params.routine.timezone } : {}),
+    }, params.now);
+    const name = params.routine.name?.trim();
+    return {
+        toCreateInput(agentId) {
+            return {
+                prompt,
+                cadence,
+                target: { type: "agent", agentId },
+                ...(name ? { name } : {}),
+                // An `at` routine lowers to a single run pinned to that instant, the
+                // same way create_schedule handles it. runOnCreate stays false so an
+                // `at` routine does not also fire the moment the agent is born.
+                ...(oneOff ? { maxRuns: 1, runOnCreate: false } : {}),
+            };
+        },
+    };
+}
+export async function attachAgentRoutine(params) {
+    if (!params.scheduleService) {
+        throw new Error("Schedule service is not configured");
+    }
+    // `create`, never `createOrReplace`: the target is an agent id minted seconds
+    // ago, so no existing schedule can match it by name and target. Reusing the
+    // idempotent path would only add a list scan that can never hit.
+    const schedule = await params.scheduleService.create(params.plan.toCreateInput(params.agentId));
+    return { scheduleId: schedule.id, nextRunAt: schedule.nextRunAt };
+}
+//# sourceMappingURL=routine.js.map

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

@@ -0,0 +1,54 @@
+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";
+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;
+    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;
+    killTerminalsForWorkspace: (workspaceId: string) => Promise<void>;
+    logger: pino.Logger;
+}
+export declare class CreateAgentLifecycleDispatch {
+    private readonly dependencies;
+    private readonly autoArchiveAgentIds;
+    constructor(dependencies: CreateAgentLifecycleDispatchDependencies);
+    createWorktreeForRequest(input: {
+        cwd: string;
+        target: CreateAgentWorktreeTarget | undefined;
+        firstAgentContext: FirstAgentContext;
+        hasLegacyGitOptions: boolean;
+    }): Promise<CreatePaseoWorktreeWorkflowResult | null>;
+    registerAutoArchiveIfRequested(input: {
+        autoArchive: boolean | undefined;
+        agentId: string;
+        createdWorktree: CreatePaseoWorktreeWorkflowResult | null;
+    }): void;
+    cleanupCreatedWorktreeAfterFailedAgentCreate(input: {
+        createdWorktree: CreatePaseoWorktreeWorkflowResult | null;
+        createdAgentId: string | null;
+    }): Promise<void>;
+    private createWorktreeForTarget;
+    private registerAutoArchiveOnTerminalState;
+    private autoArchiveAgentOnce;
+    private archiveAutoCreatedWorktree;
+}
+export {};
+//# sourceMappingURL=create-agent-lifecycle-dispatch.d.ts.map

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

@@ -0,0 +1,152 @@
+import { randomUUID } from "node:crypto";
+import { isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
+import { archiveByScope, resolveWorkspaceIdAtPath, } from "../workspace-archive-service.js";
+export class CreateAgentLifecycleDispatch {
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        this.autoArchiveAgentIds = new Set();
+    }
+    async createWorktreeForRequest(input) {
+        if (input.target && input.hasLegacyGitOptions) {
+            throw new Error("create_agent_request worktree cannot be combined with git options");
+        }
+        if (!input.target) {
+            return null;
+        }
+        return this.createWorktreeForTarget(input.cwd, input.target, input.firstAgentContext);
+    }
+    registerAutoArchiveIfRequested(input) {
+        if (input.autoArchive !== true) {
+            return;
+        }
+        this.registerAutoArchiveOnTerminalState(input.agentId, {
+            worktreePath: input.createdWorktree?.worktree.worktreePath ?? null,
+            repoRoot: input.createdWorktree?.repoRoot ?? null,
+        });
+    }
+    async cleanupCreatedWorktreeAfterFailedAgentCreate(input) {
+        const { createdWorktree, createdAgentId } = input;
+        if (!createdWorktree || createdAgentId) {
+            return;
+        }
+        await this.archiveAutoCreatedWorktree({
+            agentId: null,
+            worktreePath: createdWorktree.worktree.worktreePath,
+            repoRoot: createdWorktree.repoRoot,
+        }).catch((archiveError) => {
+            this.dependencies.logger.warn({
+                err: archiveError,
+                worktreePath: createdWorktree.worktree.worktreePath,
+            }, "Failed to clean up worktree after create_agent_request failed");
+        });
+    }
+    async createWorktreeForTarget(cwd, target, firstAgentContext) {
+        const baseInput = {
+            cwd,
+            firstAgentContext,
+            runSetup: false,
+            paseoHome: this.dependencies.paseoHome,
+            worktreesRoot: this.dependencies.worktreesRoot,
+        };
+        switch (target.mode) {
+            case "branch-off":
+                return this.dependencies.createPaseoWorktreeWorkflow({
+                    ...baseInput,
+                    worktreeSlug: target.newBranch,
+                    action: "branch-off",
+                    ...(target.base ? { refName: target.base } : {}),
+                }, target.base ? { resolveDefaultBranch: async () => target.base } : undefined);
+            case "checkout-branch":
+                return this.dependencies.createPaseoWorktreeWorkflow({
+                    ...baseInput,
+                    action: "checkout",
+                    refName: target.branch,
+                });
+            case "checkout-pr":
+                return this.dependencies.createPaseoWorktreeWorkflow({
+                    ...baseInput,
+                    action: "checkout",
+                    githubPrNumber: target.prNumber,
+                });
+            default:
+                throw new Error("Unsupported create_agent_request worktree target");
+        }
+    }
+    registerAutoArchiveOnTerminalState(agentId, options) {
+        const unsubscribe = this.dependencies.agentManager.subscribe((event) => {
+            if (event.type !== "agent_stream") {
+                return;
+            }
+            if (event.event.type !== "turn_completed" &&
+                event.event.type !== "turn_failed" &&
+                event.event.type !== "turn_canceled") {
+                return;
+            }
+            unsubscribe();
+            void this.autoArchiveAgentOnce(agentId, options);
+        }, { agentId, replayState: false });
+    }
+    async autoArchiveAgentOnce(agentId, options) {
+        if (this.autoArchiveAgentIds.has(agentId)) {
+            return;
+        }
+        this.autoArchiveAgentIds.add(agentId);
+        try {
+            if (options.worktreePath) {
+                await this.archiveAutoCreatedWorktree({
+                    agentId,
+                    worktreePath: options.worktreePath,
+                    repoRoot: options.repoRoot,
+                });
+                return;
+            }
+            await this.dependencies.archiveAgentForClose(agentId);
+        }
+        catch (error) {
+            this.dependencies.logger.warn({ err: error, agentId }, "Failed to auto-archive agent");
+        }
+    }
+    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");
+        }
+        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);
+        }
+    }
+}
+//# sourceMappingURL=create-agent-lifecycle-dispatch.js.map