@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/migrations/backfill-workspace-id.migration.d.ts

@@ -0,0 +1,9 @@
+import type { Logger } from "pino";
+import type { AgentStorage } from "../agent/agent-storage.js";
+import type { WorkspaceRegistry } from "../workspace-registry.js";
+export declare function backfillWorkspaceIdForLegacyAgents(options: {
+    agentStorage: AgentStorage;
+    workspaceRegistry: WorkspaceRegistry;
+    logger: Logger;
+}): Promise<number>;
+//# sourceMappingURL=backfill-workspace-id.migration.d.ts.map

package/dist/server/server/migrations/backfill-workspace-id.migration.js

@@ -0,0 +1,64 @@
+// COMPAT(workspaceIdBackfill): one-time legacy backfill, delete after 2026-12-16
+// once floor >= the release that always stamps workspaceId at create time.
+//
+// This is the ONLY place in the codebase that maps a cwd to a workspaceId.
+// Every other code path treats a record's `workspaceId` field as authoritative
+// ownership. Legacy agent records persisted before workspaceId stamping have no
+// owner, so this migration stamps each one with the workspace that owned its
+// directory at the time it was written. It runs once at startup and writes the
+// id back to storage, after which all runtime code can assume the field exists.
+import { homedir } from "node:os";
+import { resolve, sep } from "node:path";
+// Picks the workspace that owned `cwd` for a legacy, unstamped agent record.
+// Prefers an exact-cwd workspace (oldest wins) and otherwise attributes to the
+// deepest enclosing workspace directory, never letting the home directory own
+// descendants. Live records only consider live workspaces; archived records can
+// resolve to archived workspaces so History/restore retains legacy ownership.
+// Used only by the one-time backfill below.
+function resolveLegacyWorkspaceOwner(cwd, workspaces, options) {
+    const normalizedCwd = resolve(cwd);
+    const userHome = resolve(homedir());
+    const candidateWorkspaces = Array.from(workspaces).filter((workspace) => options?.includeArchived === true || !workspace.archivedAt);
+    const exactMatches = candidateWorkspaces.filter((workspace) => resolve(workspace.cwd) === normalizedCwd);
+    if (exactMatches.length > 0) {
+        return oldestWorkspace(exactMatches).workspaceId;
+    }
+    const prefixMatches = candidateWorkspaces.filter((workspace) => {
+        const workspaceCwd = resolve(workspace.cwd);
+        if (workspaceCwd === userHome) {
+            return false;
+        }
+        return normalizedCwd === workspaceCwd || normalizedCwd.startsWith(`${workspaceCwd}${sep}`);
+    });
+    if (prefixMatches.length === 0) {
+        return null;
+    }
+    const deepestPrefixLength = Math.max(...prefixMatches.map((workspace) => resolve(workspace.cwd).length));
+    return oldestWorkspace(prefixMatches.filter((workspace) => resolve(workspace.cwd).length === deepestPrefixLength)).workspaceId;
+}
+function oldestWorkspace(workspaces) {
+    return workspaces.reduce((oldest, candidate) => candidate.createdAt < oldest.createdAt ? candidate : oldest);
+}
+export async function backfillWorkspaceIdForLegacyAgents(options) {
+    const workspaceRecords = await options.workspaceRegistry.list();
+    const records = await options.agentStorage.list();
+    let migrated = 0;
+    for (const record of records) {
+        if (record.workspaceId) {
+            continue;
+        }
+        const workspaceId = resolveLegacyWorkspaceOwner(record.cwd, workspaceRecords, {
+            includeArchived: record.archivedAt != null,
+        });
+        if (!workspaceId) {
+            continue;
+        }
+        await options.agentStorage.upsert({ ...record, workspaceId });
+        migrated += 1;
+    }
+    if (migrated > 0) {
+        options.logger.info({ migrated }, "Backfilled workspaceId for legacy agent records");
+    }
+    return migrated;
+}
+//# sourceMappingURL=backfill-workspace-id.migration.js.map

package/dist/server/server/monitoring/telemetry.d.ts

@@ -0,0 +1,13 @@
+import type { Logger } from "pino";
+export interface TransportSpawnedEvent {
+    transport: "pty" | "sdk";
+    provider: string;
+    version: string;
+}
+/**
+ * Story 4.4 — Emit a structured pino log entry tagged `event: "agent.transport.spawned"`
+ * so Datadog log-based metrics can count transport adoption (pty vs sdk) after the
+ * 2026-06-15 Anthropic billing-pool split. Never throws; on failure the call is a no-op.
+ */
+export declare function trackTransportSpawned(event: TransportSpawnedEvent, logger?: Logger): void;
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/server/server/monitoring/telemetry.js

@@ -0,0 +1,21 @@
+/**
+ * Story 4.4 — Emit a structured pino log entry tagged `event: "agent.transport.spawned"`
+ * so Datadog log-based metrics can count transport adoption (pty vs sdk) after the
+ * 2026-06-15 Anthropic billing-pool split. Never throws; on failure the call is a no-op.
+ */
+export function trackTransportSpawned(event, logger) {
+    if (!logger)
+        return;
+    try {
+        logger.info({
+            event: "agent.transport.spawned",
+            transport: event.transport,
+            provider: event.provider,
+            version: event.version,
+        }, "agent.transport.spawned");
+    }
+    catch {
+        // Telemetry must never crash the session.
+    }
+}
+//# sourceMappingURL=telemetry.js.map

package/dist/server/server/package-version.d.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+interface ResolvePackageVersionParams {
+    moduleUrl?: string;
+    packageName: string;
+}
+export declare const packageJsonSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PackageJson = z.infer<typeof packageJsonSchema>;
+export declare class PackageVersionResolutionError extends Error {
+    constructor(params: {
+        moduleUrl: string;
+        packageName: string;
+    });
+}
+export declare function resolvePackageVersion(params: ResolvePackageVersionParams): string;
+export {};
+//# sourceMappingURL=package-version.d.ts.map

package/dist/server/server/package-version.js

@@ -0,0 +1,60 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+export const packageJsonSchema = z.object({
+    name: z.string().optional(),
+    version: z.string().optional(),
+});
+function parsePackageJson(raw) {
+    const result = packageJsonSchema.safeParse(raw);
+    return result.success ? result.data : null;
+}
+export class PackageVersionResolutionError extends Error {
+    constructor(params) {
+        super(`Unable to resolve ${params.packageName} version from module URL ${params.moduleUrl}.`);
+        this.name = "PackageVersionResolutionError";
+    }
+}
+function readMatchingPackageVersion(packageJsonPath, packageName, moduleUrl) {
+    let packageJson;
+    try {
+        const parsed = parsePackageJson(JSON.parse(readFileSync(packageJsonPath, "utf8")));
+        if (!parsed)
+            return null;
+        packageJson = parsed;
+    }
+    catch {
+        return null;
+    }
+    if (packageJson.name !== packageName) {
+        return null;
+    }
+    if (typeof packageJson.version === "string" && packageJson.version.trim().length > 0) {
+        return packageJson.version.trim();
+    }
+    throw new PackageVersionResolutionError({ moduleUrl, packageName });
+}
+export function resolvePackageVersion(params) {
+    const moduleUrl = params.moduleUrl ?? import.meta.url;
+    let currentDir = path.dirname(fileURLToPath(moduleUrl));
+    while (true) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            const version = readMatchingPackageVersion(packageJsonPath, params.packageName, moduleUrl);
+            if (version !== null) {
+                return version;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    throw new PackageVersionResolutionError({
+        moduleUrl,
+        packageName: params.packageName,
+    });
+}
+//# sourceMappingURL=package-version.js.map

package/dist/server/server/pagination/cursor.d.ts

@@ -0,0 +1,16 @@
+export interface CursorSortEntry<K extends string> {
+    key: K;
+    direction: "asc" | "desc";
+}
+export type CursorSortValue = string | number | null;
+export interface DecodedCursor<K extends string> {
+    sort: CursorSortEntry<K>[];
+    values: Record<string, CursorSortValue>;
+    id: string;
+}
+export declare class CursorError extends Error {
+    constructor(message: string);
+}
+export declare function encodeCursor<E, K extends string>(entry: E, sort: readonly CursorSortEntry<K>[], getId: (entry: E) => string, getValue: (entry: E, key: K) => CursorSortValue): string;
+export declare function decodeCursor<K extends string>(cursor: string, sort: readonly CursorSortEntry<K>[], validKeys: readonly K[], label: string): DecodedCursor<K>;
+//# sourceMappingURL=cursor.d.ts.map

package/dist/server/server/pagination/cursor.js

@@ -0,0 +1,62 @@
+export class CursorError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CursorError";
+    }
+}
+export function encodeCursor(entry, sort, getId, getValue) {
+    const values = {};
+    for (const spec of sort) {
+        values[spec.key] = getValue(entry, spec.key);
+    }
+    return Buffer.from(JSON.stringify({ sort, values, id: getId(entry) }), "utf8").toString("base64url");
+}
+export function decodeCursor(cursor, sort, validKeys, label) {
+    const invalid = new CursorError(`Invalid ${label} cursor`);
+    let parsed;
+    try {
+        parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    }
+    catch {
+        throw invalid;
+    }
+    if (!parsed || typeof parsed !== "object") {
+        throw invalid;
+    }
+    const payload = parsed;
+    if (!Array.isArray(payload.sort) || typeof payload.id !== "string") {
+        throw invalid;
+    }
+    if (!payload.values || typeof payload.values !== "object") {
+        throw invalid;
+    }
+    const cursorSort = parseCursorSort(payload.sort, validKeys, label);
+    if (cursorSort.length !== sort.length ||
+        cursorSort.some((entry, index) => entry.key !== sort[index]?.key || entry.direction !== sort[index]?.direction)) {
+        throw new CursorError(`${label} cursor does not match current sort`);
+    }
+    return {
+        sort: cursorSort,
+        values: payload.values,
+        id: payload.id,
+    };
+}
+function parseCursorSort(raw, validKeys, label) {
+    const result = [];
+    for (const item of raw) {
+        if (!item || typeof item !== "object") {
+            throw new CursorError(`Invalid ${label} cursor`);
+        }
+        const { key, direction } = item;
+        if (typeof key !== "string" || typeof direction !== "string") {
+            throw new CursorError(`Invalid ${label} cursor`);
+        }
+        if (!validKeys.includes(key) ||
+            (direction !== "asc" && direction !== "desc")) {
+            throw new CursorError(`Invalid ${label} cursor`);
+        }
+        result.push({ key: key, direction });
+    }
+    return result;
+}
+//# sourceMappingURL=cursor.js.map

package/dist/server/server/pagination/sortable-pager.d.ts

@@ -0,0 +1,24 @@
+import { CursorError, type CursorSortValue, type DecodedCursor } from "./cursor.js";
+export interface SortSpec<K extends string> {
+    key: K;
+    direction: "asc" | "desc";
+}
+export interface SortablePagerConfig<TItem, K extends string> {
+    validKeys: readonly K[];
+    defaultSort: readonly SortSpec<K>[];
+    label: string;
+    getId: (item: TItem) => string;
+    getSortValue: (item: TItem, key: K) => CursorSortValue;
+}
+export declare class SortablePager<TItem, K extends string> {
+    private readonly config;
+    constructor(config: SortablePagerConfig<TItem, K>);
+    normalizeSort(sort: readonly SortSpec<K>[] | undefined): SortSpec<K>[];
+    compare(left: TItem, right: TItem, sort: readonly SortSpec<K>[]): number;
+    compareWithCursor(item: TItem, cursor: DecodedCursor<K>, sort: readonly SortSpec<K>[]): number;
+    encode(item: TItem, sort: readonly SortSpec<K>[]): string;
+    decode(token: string, sort: readonly SortSpec<K>[]): DecodedCursor<K>;
+}
+export { CursorError };
+export declare function compareValues(left: CursorSortValue, right: CursorSortValue): number;
+//# sourceMappingURL=sortable-pager.d.ts.map

package/dist/server/server/pagination/sortable-pager.js

@@ -0,0 +1,68 @@
+import { CursorError, decodeCursor, encodeCursor, } from "./cursor.js";
+export class SortablePager {
+    constructor(config) {
+        this.config = config;
+    }
+    normalizeSort(sort) {
+        if (!sort || sort.length === 0) {
+            return [...this.config.defaultSort];
+        }
+        const deduped = [];
+        const seen = new Set();
+        for (const entry of sort) {
+            if (seen.has(entry.key)) {
+                continue;
+            }
+            seen.add(entry.key);
+            deduped.push(entry);
+        }
+        return deduped.length > 0 ? deduped : [...this.config.defaultSort];
+    }
+    compare(left, right, sort) {
+        for (const spec of sort) {
+            const leftValue = this.config.getSortValue(left, spec.key);
+            const rightValue = this.config.getSortValue(right, spec.key);
+            const base = compareValues(leftValue, rightValue);
+            if (base === 0) {
+                continue;
+            }
+            return spec.direction === "asc" ? base : -base;
+        }
+        return this.config.getId(left).localeCompare(this.config.getId(right));
+    }
+    compareWithCursor(item, cursor, sort) {
+        for (const spec of sort) {
+            const leftValue = this.config.getSortValue(item, spec.key);
+            const rightValue = cursor.values[spec.key] ?? null;
+            const base = compareValues(leftValue, rightValue);
+            if (base === 0) {
+                continue;
+            }
+            return spec.direction === "asc" ? base : -base;
+        }
+        return this.config.getId(item).localeCompare(cursor.id);
+    }
+    encode(item, sort) {
+        return encodeCursor(item, sort, this.config.getId, this.config.getSortValue);
+    }
+    decode(token, sort) {
+        return decodeCursor(token, sort, this.config.validKeys, this.config.label);
+    }
+}
+export { CursorError };
+export function compareValues(left, right) {
+    if (left === right) {
+        return 0;
+    }
+    if (left === null) {
+        return -1;
+    }
+    if (right === null) {
+        return 1;
+    }
+    if (typeof left === "number" && typeof right === "number") {
+        return left < right ? -1 : 1;
+    }
+    return String(left).localeCompare(String(right));
+}
+//# sourceMappingURL=sortable-pager.js.map

package/dist/server/server/pairing-offer.d.ts

@@ -0,0 +1,18 @@
+import type { Logger } from "pino";
+export interface LocalPairingOffer {
+    relayEnabled: boolean;
+    url: string | null;
+    qr: string | null;
+}
+export declare function generateLocalPairingOffer(args: {
+    paseoHome: string;
+    relayEnabled?: boolean;
+    relayEndpoint?: string;
+    relayPublicEndpoint?: string;
+    relayUseTls?: boolean;
+    relayPublicUseTls?: boolean;
+    appBaseUrl?: string;
+    includeQr?: boolean;
+    logger?: Logger;
+}): Promise<LocalPairingOffer>;
+//# sourceMappingURL=pairing-offer.d.ts.map

package/dist/server/server/pairing-offer.js

@@ -0,0 +1,47 @@
+import { createConnectionOfferV2, encodeOfferToFragmentUrl } from "./connection-offer.js";
+import { loadOrCreateDaemonKeyPair } from "./daemon-keypair.js";
+import { renderPairingQr } from "./pairing-qr.js";
+import { getOrCreateServerId } from "./server-id.js";
+export async function generateLocalPairingOffer(args) {
+    const relayEnabled = args.relayEnabled ?? true;
+    if (!relayEnabled) {
+        return {
+            relayEnabled: false,
+            url: null,
+            qr: null,
+        };
+    }
+    const relayEndpoint = args.relayEndpoint ?? "relay.paseo.sh:443";
+    const relayPublicEndpoint = args.relayPublicEndpoint ?? relayEndpoint;
+    const relayUseTls = args.relayUseTls ?? relayEndpoint === "relay.paseo.sh:443";
+    const relayPublicUseTls = args.relayPublicUseTls ?? relayUseTls;
+    const appBaseUrl = args.appBaseUrl ?? "https://app.paseo.sh";
+    const serverId = getOrCreateServerId(args.paseoHome, { logger: args.logger });
+    const daemonKeyPair = await loadOrCreateDaemonKeyPair(args.paseoHome, args.logger);
+    const offer = await createConnectionOfferV2({
+        serverId,
+        daemonPublicKeyB64: daemonKeyPair.publicKeyB64,
+        relay: { endpoint: relayPublicEndpoint, useTls: relayPublicUseTls },
+    });
+    const url = encodeOfferToFragmentUrl({ offer, appBaseUrl });
+    if (args.includeQr === false) {
+        return {
+            relayEnabled: true,
+            url,
+            qr: null,
+        };
+    }
+    let qr = null;
+    try {
+        qr = await renderPairingQr(url);
+    }
+    catch (error) {
+        args.logger?.debug({ error }, "Failed to render pairing QR");
+    }
+    return {
+        relayEnabled: true,
+        url,
+        qr,
+    };
+}
+//# sourceMappingURL=pairing-offer.js.map

package/dist/server/server/pairing-qr.d.ts

@@ -0,0 +1,7 @@
+import type { Logger } from "pino";
+export declare function renderPairingQr(url: string): Promise<string>;
+export declare function printPairingQrIfEnabled(args: {
+    url: string;
+    logger?: Logger;
+}): Promise<void>;
+//# sourceMappingURL=pairing-qr.d.ts.map

package/dist/server/server/pairing-qr.js

@@ -0,0 +1,45 @@
+import * as QRCode from "qrcode";
+function parseBooleanEnv(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "y", "on"].includes(normalized))
+        return true;
+    if (["0", "false", "no", "n", "off"].includes(normalized))
+        return false;
+    return undefined;
+}
+function shouldPrintPairingQr() {
+    const env = parseBooleanEnv(process.env.PASEO_PAIRING_QR);
+    if (env !== undefined)
+        return env;
+    return process.stdout.isTTY ?? false;
+}
+export async function renderPairingQr(url) {
+    const terminalOptions = {
+        type: "terminal",
+        small: true,
+    };
+    const utf8Options = {
+        type: "utf8",
+    };
+    try {
+        return await QRCode.toString(url, terminalOptions);
+    }
+    catch {
+        return await QRCode.toString(url, utf8Options);
+    }
+}
+export async function printPairingQrIfEnabled(args) {
+    if (!shouldPrintPairingQr())
+        return;
+    const qr = await renderPairingQr(args.url);
+    const out = `\nScan to pair:\n${qr}\n${args.url}\n`;
+    try {
+        process.stdout.write(out);
+    }
+    catch (error) {
+        args.logger?.debug({ error }, "Failed to print pairing QR");
+    }
+}
+//# sourceMappingURL=pairing-qr.js.map

package/dist/server/server/paseo-env.d.ts

@@ -0,0 +1,13 @@
+export type PaseoNodeEnv = "development" | "production" | "test";
+export type ProcessEnvRecord = Record<string, string | undefined>;
+export type ExternalProcessEnv = NodeJS.ProcessEnv & Record<string, string>;
+export declare function createPaseoInternalEnv(baseEnv: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function createExternalProcessEnv(baseEnv: ProcessEnvRecord, ...overlays: ProcessEnvRecord[]): ExternalProcessEnv;
+export declare function createExternalCommandProcessEnv(_command: string, baseEnv: ProcessEnvRecord, ...overlays: ProcessEnvRecord[]): ExternalProcessEnv;
+export declare function buildSelfNodeCommand(args: string[], envOverlay?: ProcessEnvRecord): {
+    command: string;
+    args: string[];
+    env: ExternalProcessEnv;
+};
+export declare function resolvePaseoNodeEnv(env: NodeJS.ProcessEnv): PaseoNodeEnv | undefined;
+//# sourceMappingURL=paseo-env.d.ts.map

package/dist/server/server/paseo-env.js

@@ -0,0 +1,53 @@
+const PASEO_NODE_ENV = "PASEO_NODE_ENV";
+const ELECTRON_RUN_AS_NODE = "ELECTRON_RUN_AS_NODE";
+const RUNTIME_CONTROL_ENV_KEYS = [
+    PASEO_NODE_ENV,
+    "PASEO_DESKTOP_MANAGED",
+    "PASEO_SUPERVISED",
+    ELECTRON_RUN_AS_NODE,
+    "ELECTRON_NO_ATTACH_CONSOLE",
+];
+function buildInternalProcessEnv(baseEnv) {
+    return { ...baseEnv };
+}
+function buildExternalProcessEnv(baseEnv, overlays) {
+    const sanitized = Object.assign({}, baseEnv, ...overlays);
+    for (const key of RUNTIME_CONTROL_ENV_KEYS) {
+        delete sanitized[key];
+    }
+    for (const [key, value] of Object.entries(sanitized)) {
+        if (value === undefined) {
+            delete sanitized[key];
+        }
+    }
+    return sanitized;
+}
+export function createPaseoInternalEnv(baseEnv) {
+    return buildInternalProcessEnv(baseEnv);
+}
+export function createExternalProcessEnv(baseEnv, ...overlays) {
+    return buildExternalProcessEnv(baseEnv, overlays);
+}
+export function createExternalCommandProcessEnv(_command, baseEnv, ...overlays) {
+    // Deprecated command parameter: retained while callers migrate to createExternalProcessEnv.
+    return buildExternalProcessEnv(baseEnv, overlays);
+}
+export function buildSelfNodeCommand(args, envOverlay) {
+    const env = buildExternalProcessEnv(process.env, []);
+    Object.assign(env, { [ELECTRON_RUN_AS_NODE]: "1" }, envOverlay);
+    for (const [key, value] of Object.entries(env)) {
+        if (value === undefined) {
+            delete env[key];
+        }
+    }
+    return {
+        command: process.execPath,
+        args,
+        env,
+    };
+}
+export function resolvePaseoNodeEnv(env) {
+    const value = env[PASEO_NODE_ENV];
+    return value === "development" || value === "production" || value === "test" ? value : undefined;
+}
+//# sourceMappingURL=paseo-env.js.map

package/dist/server/server/paseo-home.d.ts

@@ -0,0 +1,2 @@
+export declare function resolvePaseoHome(env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=paseo-home.d.ts.map

package/dist/server/server/paseo-home.js

@@ -0,0 +1,19 @@
+import os from "node:os";
+import path from "node:path";
+import { ensurePrivateDirectory } from "./private-files.js";
+function expandHomeDir(input) {
+    if (input.startsWith("~/")) {
+        return path.join(os.homedir(), input.slice(2));
+    }
+    if (input === "~") {
+        return os.homedir();
+    }
+    return input;
+}
+export function resolvePaseoHome(env = process.env) {
+    const raw = env.PASEO_HOME ?? "~/.paseo";
+    const resolved = path.resolve(expandHomeDir(raw));
+    ensurePrivateDirectory(resolved);
+    return resolved;
+}
+//# sourceMappingURL=paseo-home.js.map

package/dist/server/server/paseo-worktree-service.d.ts

@@ -0,0 +1,52 @@
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+import { type PersistedWorkspaceRecord, type ProjectRegistry, type WorkspaceRegistry } from "./workspace-registry.js";
+import { type CreateWorktreeCoreDeps, type CreateWorktreeCoreInput } from "./worktree-core.js";
+import { type WorktreeConfig } from "../utils/worktree.js";
+import { getCurrentBranch, localBranchExists, renameCurrentBranch } from "../utils/checkout-git.js";
+import type { WorktreeCreationIntent } from "./resolve-worktree-creation-intent.js";
+import type { FirstAgentContext } from "@hyperdrive.bot/fleet-protocol/messages";
+export interface CreatePaseoWorktreeInput extends CreateWorktreeCoreInput {
+    projectId?: string;
+}
+export interface CreatePaseoWorktreeResult {
+    worktree: WorktreeConfig;
+    intent: WorktreeCreationIntent;
+    workspace: PersistedWorkspaceRecord;
+    repoRoot: string;
+    created: boolean;
+}
+export type CreatePaseoWorktreeFn = (input: CreatePaseoWorktreeInput, options?: {
+    resolveDefaultBranch?: (repoRoot: string) => Promise<string>;
+}) => Promise<CreatePaseoWorktreeResult>;
+export interface AttemptFirstAgentBranchAutoNameResult {
+    attempted: boolean;
+    renamed: boolean;
+    branchName: string | null;
+}
+export interface CreatePaseoWorktreeDeps extends CreateWorktreeCoreDeps {
+    projectRegistry: Pick<ProjectRegistry, "get" | "upsert">;
+    workspaceRegistry: Pick<WorkspaceRegistry, "get" | "list" | "upsert">;
+    workspaceGitService: WorkspaceGitService;
+}
+export declare function createPaseoWorktree(input: CreatePaseoWorktreeInput, deps: CreatePaseoWorktreeDeps): Promise<CreatePaseoWorktreeResult>;
+export declare function attemptFirstAgentBranchAutoName(options: {
+    cwd: string;
+    firstAgentContext: FirstAgentContext | undefined;
+    generateBranchNameFromContext: (input: {
+        cwd: string;
+        firstAgentContext: FirstAgentContext;
+    }) => Promise<string | null>;
+    getCurrentBranch?: typeof getCurrentBranch;
+    renameCurrentBranch?: typeof renameCurrentBranch;
+    localBranchExists?: typeof localBranchExists;
+}): Promise<AttemptFirstAgentBranchAutoNameResult>;
+export interface CreateLocalCheckoutWorkspaceDeps {
+    projectRegistry: Pick<ProjectRegistry, "get" | "list" | "upsert">;
+    workspaceRegistry: Pick<WorkspaceRegistry, "list" | "upsert">;
+    workspaceGitService: Pick<WorkspaceGitService, "getCheckout">;
+}
+export declare function createLocalCheckoutWorkspace(options: {
+    cwd: string;
+    title?: string | null;
+}, deps: CreateLocalCheckoutWorkspaceDeps): Promise<PersistedWorkspaceRecord>;
+//# sourceMappingURL=paseo-worktree-service.d.ts.map