@camerontaylor/paseo-cli 0.8.0-fork.1

package/dist/commands/workspace/create.js

@@ -0,0 +1,114 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { toWorkspaceRow, workspaceSchema } from "./shared.js";
+function assertOptionsAbsent(values, message) {
+    if (values.some((value) => value !== undefined)) {
+        throw new Error(message);
+    }
+}
+function buildLocalWorkspaceSource(options, path) {
+    assertOptionsAbsent([
+        options.mode,
+        options.worktreeSlug,
+        options.newBranch,
+        options.base,
+        options.branch,
+        options.prNumber,
+        options.forge,
+    ], "Worktree options require --isolation worktree");
+    return {
+        kind: "directory",
+        path,
+        ...(options.project ? { projectId: options.project } : {}),
+    };
+}
+function buildBranchOffSource(options, source) {
+    assertOptionsAbsent([options.branch, options.prNumber, options.forge], "--branch, --pr-number, and --forge require a checkout mode");
+    return {
+        ...source,
+        action: "branch-off",
+        ...(options.newBranch ? { branchName: options.newBranch } : {}),
+        ...(options.base ? { baseBranch: options.base } : {}),
+    };
+}
+function buildBranchCheckoutSource(options, source) {
+    if (!options.branch) {
+        throw new Error("--branch is required for --mode checkout-branch");
+    }
+    assertOptionsAbsent([options.newBranch, options.base, options.prNumber, options.forge], "--new-branch, --base, --pr-number, and --forge are not valid for --mode checkout-branch");
+    return { ...source, action: "checkout", refName: options.branch };
+}
+function buildPullRequestCheckoutSource(options, source) {
+    if (options.prNumber === undefined || options.prNumber === "") {
+        throw new Error("--pr-number is required for --mode checkout-pr");
+    }
+    const prNumber = Number(options.prNumber);
+    if (!Number.isInteger(prNumber) || prNumber <= 0) {
+        throw new Error("--pr-number must be a positive integer");
+    }
+    assertOptionsAbsent([options.newBranch, options.base, options.branch], "--new-branch, --base, and --branch are not valid for --mode checkout-pr");
+    return {
+        ...source,
+        action: "checkout",
+        checkoutSource: {
+            kind: "change_request",
+            ...(options.forge ? { forge: options.forge } : {}),
+            number: prNumber,
+        },
+    };
+}
+function buildWorktreeWorkspaceSource(options, path) {
+    const source = {
+        kind: "worktree",
+        ...(path ? { cwd: path } : {}),
+        ...(options.project ? { projectId: options.project } : {}),
+        ...(options.worktreeSlug ? { worktreeSlug: options.worktreeSlug } : {}),
+    };
+    switch (options.mode ?? "branch-off") {
+        case "branch-off":
+            return buildBranchOffSource(options, source);
+        case "checkout-branch":
+            return buildBranchCheckoutSource(options, source);
+        case "checkout-pr":
+            return buildPullRequestCheckoutSource(options, source);
+        default:
+            throw new Error(`Unsupported worktree mode: ${String(options.mode)}`);
+    }
+}
+export function buildWorkspaceSource(options) {
+    if (options.isolation === "local") {
+        return buildLocalWorkspaceSource(options, options.path ?? process.cwd());
+    }
+    if (options.isolation === "worktree") {
+        const sourcePath = options.path ?? (options.project ? undefined : process.cwd());
+        return buildWorktreeWorkspaceSource(options, sourcePath);
+    }
+    throw new Error(`Unsupported workspace isolation: ${String(options.isolation)}`);
+}
+export async function runCreateCommand(options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+        };
+    });
+    try {
+        const payload = await client.createWorkspace({
+            source: buildWorkspaceSource(options),
+            ...(options.title ? { title: options.title } : {}),
+        });
+        if (!payload.workspace) {
+            throw new Error(payload.error ?? "Workspace creation failed");
+        }
+        return { type: "single", data: toWorkspaceRow(payload.workspace), schema: workspaceSchema };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "WORKSPACE_CREATE_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/workspace/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createWorkspaceCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/workspace/index.js

@@ -0,0 +1,45 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { runArchiveCommand } from "./archive.js";
+import { runCreateCommand } from "./create.js";
+import { runLsCommand } from "./ls.js";
+import { runRenameCommand } from "./rename.js";
+import { runSetupCommand } from "./setup.js";
+export function createWorkspaceCommand() {
+    const workspace = new Command("workspace").description("Manage workspaces");
+    addJsonAndDaemonHostOptions(workspace
+        .command("setup")
+        .description("Allow and run setup for a workspace")
+        .argument("<workspace-id>", "Workspace id")).action(withOutput(runSetupCommand));
+    addJsonAndDaemonHostOptions(workspace
+        .command("create")
+        .description("Create a workspace")
+        .requiredOption("--isolation <local|worktree>", "Workspace isolation")
+        .option("--path <path>", "Local directory or source checkout (default: current)")
+        .option("--project <id>", "Existing project id")
+        .option("--title <title>", "Workspace title")
+        .option("--mode <mode>", "Worktree mode: branch-off, checkout-branch, or checkout-pr (default: branch-off)")
+        .option("--worktree-slug <slug>", "Managed worktree path slug")
+        .option("--new-branch <name>", "New branch name (--mode branch-off)")
+        .option("--base <ref>", "Base ref (--mode branch-off)")
+        .option("--branch <name>", "Existing branch (--mode checkout-branch)")
+        .option("--pr-number <n>", "Pull request or change request number (--mode checkout-pr)")
+        .option("--forge <forge>", "Forge for --mode checkout-pr (default: source checkout)")).action(withOutput(runCreateCommand));
+    addJsonAndDaemonHostOptions(workspace.command("ls").description("List active workspaces")).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(workspace
+        .command("rename")
+        .description("Set a workspace's user-visible title")
+        .argument("<workspace-id>", "Workspace id")
+        .argument("[title]", "New workspace title")
+        .option("--reset", "Clear the title and revert to the branch or directory name")
+        // Commander 12 accepts excess positionals by default, which would rename to
+        // the first word of an unquoted multi-word title and silently drop the rest.
+        .allowExcessArguments(false)).action(withOutput(runRenameCommand));
+    addJsonAndDaemonHostOptions(workspace
+        .command("archive")
+        .description("Archive a workspace and everything it owns")
+        .argument("<workspace-id>", "Workspace id")).action(withOutput(runArchiveCommand));
+    return workspace;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/workspace/ls.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from "commander";
+import type { ListResult } from "../../output/index.js";
+import { type WorkspaceRow } from "./shared.js";
+export declare function runLsCommand(options: {
+    host?: string;
+}, _command: Command): Promise<ListResult<WorkspaceRow>>;
+//# sourceMappingURL=ls.d.ts.map

package/dist/commands/workspace/ls.js

@@ -0,0 +1,28 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { toWorkspaceRow, workspaceSchema } from "./shared.js";
+export async function runLsCommand(options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+        };
+    });
+    try {
+        const workspaces = [];
+        let cursor;
+        do {
+            const payload = await client.fetchWorkspaces({
+                page: { limit: 200, ...(cursor ? { cursor } : {}) },
+            });
+            workspaces.push(...payload.entries.map(toWorkspaceRow));
+            cursor = payload.pageInfo.nextCursor ?? undefined;
+        } while (cursor);
+        return { type: "list", data: workspaces, schema: workspaceSchema };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/commands/workspace/rename.d.ts

@@ -0,0 +1,22 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+interface WorkspaceRenameResult {
+    workspaceId: string;
+    /** Raw title override; null once it has been reset to the derived name. */
+    title: string | null;
+}
+export interface WorkspaceRenameOptions {
+    host?: string;
+    reset?: boolean;
+}
+/**
+ * Resolve the title to send to the daemon. Null clears the override and
+ * reverts the workspace to its branch- or directory-derived name.
+ */
+export declare function resolveWorkspaceTitle(input: {
+    title?: string;
+    reset?: boolean;
+}): string | null;
+export declare function runRenameCommand(workspaceId: string, titleArg: string | undefined, options: WorkspaceRenameOptions, _command: Command): Promise<SingleResult<WorkspaceRenameResult>>;
+export {};
+//# sourceMappingURL=rename.d.ts.map

package/dist/commands/workspace/rename.js

@@ -0,0 +1,61 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+const workspaceRenameSchema = {
+    idField: "workspaceId",
+    columns: [
+        { header: "WORKSPACE ID", field: "workspaceId", width: 20 },
+        { header: "TITLE", field: "title", width: 30 },
+    ],
+};
+/**
+ * Resolve the title to send to the daemon. Null clears the override and
+ * reverts the workspace to its branch- or directory-derived name.
+ */
+export function resolveWorkspaceTitle(input) {
+    const title = input.title?.trim() ?? "";
+    if (input.reset) {
+        if (input.title !== undefined) {
+            throw {
+                code: "INVALID_OPTIONS",
+                message: "--reset cannot be combined with a title",
+                details: "Pass a title to rename the workspace, or --reset to revert to the derived name",
+            };
+        }
+        return null;
+    }
+    if (title.length === 0) {
+        throw {
+            code: "MISSING_TITLE",
+            message: "Title cannot be empty",
+            details: "Usage: paseo workspace rename <workspace-id> <title> | --reset",
+        };
+    }
+    return title;
+}
+export async function runRenameCommand(workspaceId, titleArg, options, _command) {
+    const title = resolveWorkspaceTitle({ title: titleArg, reset: options.reset });
+    const host = getDaemonHost({ host: options.host });
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: paseo daemon start",
+        };
+    });
+    try {
+        const applied = await client.setWorkspaceTitle(workspaceId, title);
+        return {
+            type: "single",
+            data: { workspaceId, title: applied.title },
+            schema: workspaceRenameSchema,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "WORKSPACE_RENAME_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=rename.js.map

package/dist/commands/workspace/setup.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+interface WorkspaceSetupResult {
+    workspaceId: string;
+    status: "started" | "already_allowed";
+}
+export declare function runSetupCommand(workspaceId: string, options: {
+    host?: string;
+}, _command: Command): Promise<SingleResult<WorkspaceSetupResult>>;
+export {};
+//# sourceMappingURL=setup.d.ts.map

package/dist/commands/workspace/setup.js

@@ -0,0 +1,41 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+const workspaceSetupSchema = {
+    idField: "workspaceId",
+    columns: [
+        { header: "WORKSPACE ID", field: "workspaceId", width: 20 },
+        { header: "STATUS", field: "status", width: 18 },
+    ],
+};
+export async function runSetupCommand(workspaceId, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    const client = await connectToDaemon({ host: options.host }).catch((error) => {
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    });
+    try {
+        // COMPAT(workspaceSetupRun): added in v0.7.3, remove gate after 2027-09-02.
+        if (!client.getLastServerInfoMessage()?.features?.workspaceSetupRun) {
+            throw { code: "DAEMON_UPDATE_REQUIRED", message: "Update the host to run workspace setup." };
+        }
+        const payload = await client.runWorkspaceSetup(workspaceId);
+        if (payload.error)
+            throw new Error(payload.error);
+        return {
+            type: "single",
+            data: { workspaceId, status: payload.started ? "started" : "already_allowed" },
+            schema: workspaceSetupSchema,
+        };
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error)
+            throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "WORKSPACE_SETUP_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=setup.js.map

package/dist/commands/workspace/shared.d.ts

@@ -0,0 +1,12 @@
+import type { WorkspaceDescriptorPayload } from "@camerontaylor/paseo-protocol/messages";
+import type { OutputSchema } from "../../output/index.js";
+export interface WorkspaceRow {
+    workspaceId: string;
+    project: string;
+    name: string;
+    isolation: "local" | "worktree";
+    cwd: string;
+}
+export declare const workspaceSchema: OutputSchema<WorkspaceRow>;
+export declare function toWorkspaceRow(workspace: WorkspaceDescriptorPayload): WorkspaceRow;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/workspace/shared.js

@@ -0,0 +1,20 @@
+export const workspaceSchema = {
+    idField: "workspaceId",
+    columns: [
+        { header: "WORKSPACE ID", field: "workspaceId", width: 20 },
+        { header: "PROJECT", field: "project", width: 20 },
+        { header: "NAME", field: "name", width: 22 },
+        { header: "ISOLATION", field: "isolation", width: 10 },
+        { header: "CWD", field: "cwd", width: 42 },
+    ],
+};
+export function toWorkspaceRow(workspace) {
+    return {
+        workspaceId: workspace.id,
+        project: workspace.projectDisplayName,
+        name: workspace.name,
+        isolation: workspace.workspaceKind === "worktree" ? "worktree" : "local",
+        cwd: workspace.workspaceDirectory,
+    };
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/worktree/archive.d.ts

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import { connectToDaemon } from "../../utils/client.js";
+import type { CommandOptions, SingleResult, OutputSchema } from "../../output/index.js";
+/** Result type for worktree archive command */
+export interface WorktreeArchiveResult {
+    name: string;
+    status: "archived";
+    removedAgents: string[];
+}
+/** Schema for archive command output */
+export declare const archiveSchema: OutputSchema<WorktreeArchiveResult>;
+export interface WorktreeArchiveOptions extends CommandOptions {
+    host?: string;
+}
+export type WorktreeArchiveCommandResult = SingleResult<WorktreeArchiveResult>;
+export declare function runArchiveCommand(nameArg: string, options: WorktreeArchiveOptions, _command: Command): Promise<WorktreeArchiveCommandResult>;
+export declare function runArchiveCommandWithDeps(nameArg: string, options: WorktreeArchiveOptions, deps: {
+    connectToDaemon: typeof connectToDaemon;
+}): Promise<WorktreeArchiveCommandResult>;
+//# sourceMappingURL=archive.d.ts.map

package/dist/commands/worktree/archive.js

@@ -0,0 +1,104 @@
+import path from "path";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+/** Schema for archive command output */
+export const archiveSchema = {
+    idField: "name",
+    columns: [
+        { header: "NAME", field: "name" },
+        { header: "STATUS", field: "status" },
+        {
+            header: "REMOVED AGENTS",
+            field: (item) => (item.removedAgents.length > 0 ? item.removedAgents.join(", ") : "-"),
+        },
+    ],
+};
+export async function runArchiveCommand(nameArg, options, _command) {
+    return runArchiveCommandWithDeps(nameArg, options, { connectToDaemon });
+}
+export async function runArchiveCommandWithDeps(nameArg, options, deps) {
+    const host = getDaemonHost({ host: options.host });
+    // Validate arguments
+    if (!nameArg || nameArg.trim().length === 0) {
+        const error = {
+            code: "MISSING_WORKTREE_NAME",
+            message: "Worktree name is required",
+            details: "Usage: paseo worktree archive <name>",
+        };
+        throw error;
+    }
+    let client;
+    try {
+        client = await deps.connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: paseo daemon start",
+        };
+        throw error;
+    }
+    try {
+        // Get the list of worktrees first to resolve the name
+        const listResponse = await client.getPaseoWorktreeList({});
+        if (listResponse.error) {
+            const error = {
+                code: "WORKTREE_LIST_FAILED",
+                message: `Failed to list worktrees: ${listResponse.error.message}`,
+            };
+            throw error;
+        }
+        // Find the worktree by name or branch
+        const worktree = listResponse.worktrees.find((wt) => {
+            const name = path.basename(wt.worktreePath);
+            return name === nameArg || wt.branchName === nameArg;
+        });
+        if (!worktree) {
+            const error = {
+                code: "WORKTREE_NOT_FOUND",
+                message: `Worktree not found: ${nameArg}`,
+                details: 'Use "paseo worktree ls" to list available worktrees',
+            };
+            throw error;
+        }
+        // Archive the worktree. scope:"worktree" archives every active workspace on
+        // the directory and then removes the directory (Paseo-owned gated).
+        const response = await client.archivePaseoWorktree({
+            worktreePath: worktree.worktreePath,
+            scope: "worktree",
+        });
+        await client.close();
+        if (response.error) {
+            const error = {
+                code: "WORKTREE_ARCHIVE_FAILED",
+                message: `Failed to archive worktree: ${response.error.message}`,
+            };
+            throw error;
+        }
+        const worktreeName = path.basename(worktree.worktreePath) || nameArg;
+        return {
+            type: "single",
+            data: {
+                name: worktreeName,
+                status: "archived",
+                removedAgents: response.removedAgents ?? [],
+            },
+            schema: archiveSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandError as-is
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "WORKTREE_ARCHIVE_FAILED",
+            message: `Failed to archive worktree: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=archive.js.map

package/dist/commands/worktree/create-input.d.ts

@@ -0,0 +1,15 @@
+import type { DaemonClient } from "@camerontaylor/paseo-client/internal/daemon-client";
+import type { CommandOptions } from "../../output/index.js";
+export interface WorktreeCreateOptions extends CommandOptions {
+    host?: string;
+    cwd?: string;
+    mode?: string;
+    newBranch?: string;
+    base?: string;
+    branch?: string;
+    prNumber?: string;
+}
+type CreatePaseoWorktreeRequest = Parameters<DaemonClient["createPaseoWorktree"]>[0];
+export declare function buildCreateWorktreeRequest(options: WorktreeCreateOptions, cwd: string): CreatePaseoWorktreeRequest;
+export {};
+//# sourceMappingURL=create-input.d.ts.map

package/dist/commands/worktree/create-input.js

@@ -0,0 +1,56 @@
+const VALID_MODES = ["branch-off", "checkout-branch", "checkout-pr"];
+export function buildCreateWorktreeRequest(options, cwd) {
+    const mode = options.mode;
+    if (!mode) {
+        throw cmdError("MISSING_MODE", "--mode is required", `Expected one of: ${VALID_MODES.join(", ")}`);
+    }
+    switch (mode) {
+        case "branch-off":
+            return buildBranchOffRequest(options, cwd);
+        case "checkout-branch":
+            return buildCheckoutBranchRequest(options, cwd);
+        case "checkout-pr":
+            return buildCheckoutPrRequest(options, cwd);
+        default:
+            throw cmdError("INVALID_MODE", `Invalid --mode: ${mode}`, `Expected one of: ${VALID_MODES.join(", ")}`);
+    }
+}
+function buildBranchOffRequest(options, cwd) {
+    if (!options.newBranch) {
+        throw cmdError("MISSING_NEW_BRANCH", "--new-branch is required for --mode branch-off");
+    }
+    return {
+        cwd,
+        worktreeSlug: options.newBranch,
+        action: "branch-off",
+        ...(options.base ? { refName: options.base } : {}),
+    };
+}
+function buildCheckoutBranchRequest(options, cwd) {
+    if (!options.branch) {
+        throw cmdError("MISSING_BRANCH", "--branch is required for --mode checkout-branch");
+    }
+    return {
+        cwd,
+        action: "checkout",
+        refName: options.branch,
+    };
+}
+function buildCheckoutPrRequest(options, cwd) {
+    if (options.prNumber === undefined || options.prNumber === "") {
+        throw cmdError("MISSING_PR_NUMBER", "--pr-number is required for --mode checkout-pr");
+    }
+    const prNumber = Number(options.prNumber);
+    if (!Number.isInteger(prNumber) || prNumber <= 0) {
+        throw cmdError("INVALID_PR_NUMBER", `Invalid --pr-number: ${options.prNumber}`, "Expected a positive integer");
+    }
+    return {
+        cwd,
+        action: "checkout",
+        githubPrNumber: prNumber,
+    };
+}
+function cmdError(code, message, details) {
+    return details ? { code, message, details } : { code, message };
+}
+//# sourceMappingURL=create-input.js.map

package/dist/commands/worktree/create.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+import type { OutputSchema, SingleResult } from "../../output/index.js";
+import { type WorktreeCreateOptions } from "./create-input.js";
+export interface WorktreeCreateResult {
+    name: string;
+    branchName: string;
+    worktreePath: string;
+}
+export declare const createSchema: OutputSchema<WorktreeCreateResult>;
+export declare function runCreateCommand(options: WorktreeCreateOptions, _command: Command): Promise<SingleResult<WorktreeCreateResult>>;
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/worktree/create.js

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { buildCreateWorktreeRequest } from "./create-input.js";
+export const createSchema = {
+    idField: "worktreePath",
+    columns: [
+        { header: "NAME", field: "name", width: 24 },
+        { header: "BRANCH", field: "branchName", width: 28 },
+        { header: "PATH", field: "worktreePath", width: 50 },
+    ],
+};
+function cmdError(code, message, details) {
+    return details ? { code, message, details } : { code, message };
+}
+export async function runCreateCommand(options, _command) {
+    const cwd = options.cwd ?? process.cwd();
+    const request = buildCreateWorktreeRequest(options, cwd);
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw cmdError("DAEMON_NOT_RUNNING", `Cannot connect to daemon at ${host}: ${message}`, "Start the daemon with: paseo daemon start");
+    }
+    try {
+        const response = await client.createPaseoWorktree(request);
+        const workspace = response.workspace;
+        if (!workspace || response.error) {
+            throw cmdError("WORKTREE_CREATE_FAILED", `Failed to create worktree: ${response.error ?? "no workspace returned"}`);
+        }
+        if (!workspace.workspaceDirectory) {
+            throw cmdError("WORKTREE_CREATE_FAILED", "Failed to create worktree: workspace directory missing from daemon response");
+        }
+        const worktreePath = workspace.workspaceDirectory;
+        return {
+            type: "single",
+            data: {
+                name: path.basename(worktreePath),
+                branchName: workspace.name,
+                worktreePath,
+            },
+            schema: createSchema,
+        };
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw cmdError("WORKTREE_CREATE_FAILED", `Failed to create worktree: ${message}`);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/worktree/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createWorktreeCommand(): Command;
+//# sourceMappingURL=index.d.ts.map