@hyperdrive.bot/paseo-cli 0.2.6

package/dist/commands/terminal/shared.js

@@ -0,0 +1,61 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export async function connectTerminalClient(host) {
+    const daemonHost = getDaemonHost({ host });
+    try {
+        const client = await connectToDaemon({ host });
+        return { client, daemonHost };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${daemonHost}: ${message}`,
+            details: "Start the daemon with: paseo daemon start",
+        };
+        throw error;
+    }
+}
+export function toTerminalCommandError(code, action, err) {
+    if (err && typeof err === "object" && "code" in err && "message" in err) {
+        return err;
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    const rpcCode = typeof err === "object" && err !== null && "code" in err && typeof err.code === "string"
+        ? err.code
+        : undefined;
+    return {
+        code: rpcCode ?? code,
+        message: `Failed to ${action}: ${message}`,
+    };
+}
+export async function resolveTerminalId(client, idOrName) {
+    const payload = await client.listTerminals();
+    return resolveTerminalIdentifier(idOrName, payload.terminals);
+}
+function resolveTerminalIdentifier(idOrName, terminals) {
+    if (!idOrName || terminals.length === 0) {
+        return null;
+    }
+    const query = idOrName.toLowerCase();
+    const exactMatch = terminals.find((terminal) => terminal.id === idOrName);
+    if (exactMatch) {
+        return exactMatch.id;
+    }
+    const prefixMatches = terminals.filter((terminal) => terminal.id.toLowerCase().startsWith(query));
+    if (prefixMatches.length === 1 && prefixMatches[0]) {
+        return prefixMatches[0].id;
+    }
+    if (prefixMatches.length > 1) {
+        return null;
+    }
+    const nameMatches = terminals.filter((terminal) => terminal.name?.toLowerCase() === query);
+    if (nameMatches.length === 1 && nameMatches[0]) {
+        return nameMatches[0].id;
+    }
+    const partialNameMatches = terminals.filter((terminal) => terminal.name?.toLowerCase().includes(query));
+    if (partialNameMatches.length === 1 && partialNameMatches[0]) {
+        return partialNameMatches[0].id;
+    }
+    return null;
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/workflow/get.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "commander";
+import type { CommandOptions, ListResult } from "../../output/index.js";
+interface DetailRow {
+    key: string;
+    value: string;
+}
+export interface WorkflowGetOptions extends CommandOptions {
+}
+export declare function addWorkflowGetOptions(command: Command): Command;
+export type WorkflowGetResult = ListResult<DetailRow>;
+export declare function runWorkflowGetCommand(id: string, options: WorkflowGetOptions, _command: Command): Promise<WorkflowGetResult>;
+export {};
+//# sourceMappingURL=get.d.ts.map

package/dist/commands/workflow/get.js

@@ -0,0 +1,75 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { buildWorkflowStatusUrl } from "./start.js";
+export function addWorkflowGetOptions(command) {
+    return command.description("Show a single workflow snapshot").argument("<id>", "Workflow ID");
+}
+function createDetailSchema(workflow) {
+    return {
+        idField: "key",
+        columns: [
+            { header: "KEY", field: "key", width: 18 },
+            { header: "VALUE", field: "value", width: 70 },
+        ],
+        serialize: () => workflow,
+    };
+}
+function toRows(workflow, statusUrl) {
+    return [
+        { key: "Id", value: workflow.id },
+        { key: "Title", value: workflow.title ?? "null" },
+        { key: "Status", value: workflow.status },
+        { key: "Cwd", value: workflow.cwd },
+        {
+            key: "Stories",
+            value: `${workflow.completedStoryCount}/${workflow.totalStoryCount ?? workflow.childAgentIds.length}`,
+        },
+        {
+            key: "Phases",
+            value: workflow.phases.length === 0
+                ? "[]"
+                : workflow.phases.map((p) => `${p.title}=${p.status}`).join(" | "),
+        },
+        {
+            key: "ChildAgents",
+            value: workflow.childAgentIds.length === 0 ? "[]" : workflow.childAgentIds.join(" "),
+        },
+        { key: "CreatedAt", value: workflow.createdAt },
+        { key: "UpdatedAt", value: workflow.updatedAt },
+        { key: "StatusUrl", value: statusUrl || "(ipc — no http origin)" },
+    ];
+}
+export async function runWorkflowGetCommand(id, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        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 workflow = await client.getWorkflow(id);
+        await client.close();
+        if (!workflow) {
+            throw new Error(`Workflow not found: ${id}`);
+        }
+        return {
+            type: "list",
+            data: toRows(workflow, buildWorkflowStatusUrl(host, workflow.id)),
+            schema: createDetailSchema(workflow),
+        };
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        throw {
+            code: "WORKFLOW_GET_FAILED",
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+//# sourceMappingURL=get.js.map

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

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+/**
+ * `paseo workflow` — the thin client for daemon-owned workflows (Epic 3, Story
+ * 3.3). It builds nothing: `start` hands a pre-built task-graph to the daemon via
+ * the `workflow.start` RPC, so the run lives in the always-on daemon and survives
+ * this CLI process exiting (G3/G8). `get`/`status` read the same `workflow.*`
+ * surfaces every other client uses.
+ */
+export declare function createWorkflowCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/workflow/index.js

@@ -0,0 +1,21 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { addWorkflowStartOptions, runWorkflowStartCommand } from "./start.js";
+import { addWorkflowGetOptions, runWorkflowGetCommand } from "./get.js";
+import { addWorkflowStatusOptions, runWorkflowStatusCommand } from "./status.js";
+/**
+ * `paseo workflow` — the thin client for daemon-owned workflows (Epic 3, Story
+ * 3.3). It builds nothing: `start` hands a pre-built task-graph to the daemon via
+ * the `workflow.start` RPC, so the run lives in the always-on daemon and survives
+ * this CLI process exiting (G3/G8). `get`/`status` read the same `workflow.*`
+ * surfaces every other client uses.
+ */
+export function createWorkflowCommand() {
+    const workflow = new Command("workflow").description("Launch and inspect daemon-owned workflows (thin client)");
+    addJsonAndDaemonHostOptions(addWorkflowStartOptions(workflow.command("start"))).action(withOutput(runWorkflowStartCommand));
+    addJsonAndDaemonHostOptions(addWorkflowGetOptions(workflow.command("get"))).action(withOutput(runWorkflowGetCommand));
+    addJsonAndDaemonHostOptions(addWorkflowStatusOptions(workflow.command("status"))).action(withOutput(runWorkflowStatusCommand));
+    return workflow;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/workflow/start.d.ts

@@ -0,0 +1,26 @@
+import { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+interface StartRow {
+    workflowId: string;
+    status: string;
+    childAgentIds: string[];
+    statusUrl: string;
+}
+export interface WorkflowStartOptions extends CommandOptions {
+    provider?: string;
+    model?: string;
+    cwd?: string;
+    title?: string;
+    detach?: boolean;
+}
+export declare function addWorkflowStartOptions(command: Command): Command;
+/**
+ * Build the `GET /api/workflows/:id` status URL from the resolved daemon host.
+ * Plain `host:port` and `tcp://host:port` map to an HTTP base; IPC/unix sockets
+ * have no HTTP origin, so we return an empty string and the caller omits it.
+ */
+export declare function buildWorkflowStatusUrl(host: string, workflowId: string): string;
+export type WorkflowStartResult = SingleResult<StartRow>;
+export declare function runWorkflowStartCommand(graphPath: string, options: WorkflowStartOptions, _command: Command): Promise<WorkflowStartResult>;
+export {};
+//# sourceMappingURL=start.d.ts.map

package/dist/commands/workflow/start.js

@@ -0,0 +1,105 @@
+import { readFileSync } from "node:fs";
+import { WorkflowTaskGraphSchema } from "@hyperdrive.bot/paseo-protocol/messages";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+const startSchema = {
+    idField: "workflowId",
+    columns: [
+        { header: "WORKFLOW ID", field: "workflowId", width: 38 },
+        { header: "STATUS", field: "status", width: 10 },
+        {
+            header: "CHILDREN",
+            field: (row) => String(row.childAgentIds.length),
+            width: 10,
+        },
+        { header: "STATUS URL", field: "statusUrl", width: 50 },
+    ],
+};
+export function addWorkflowStartOptions(command) {
+    return command
+        .description("Launch a pre-built task-graph into the daemon (thin client)")
+        .argument("<graph>", "Path to a task-graph JSON file")
+        .option("--provider <provider>", "Agent provider each child runs (default: claude)")
+        .option("--model <model>", "Optional provider model each child is spawned with")
+        .option("--cwd <dir>", "Working directory all child agents inherit (default: cwd)")
+        .option("--title <title>", "Optional workflow display title")
+        .option("--detach", "Return immediately with the workflow id + status URL (the run keeps advancing in the daemon)");
+}
+/**
+ * Build the `GET /api/workflows/:id` status URL from the resolved daemon host.
+ * Plain `host:port` and `tcp://host:port` map to an HTTP base; IPC/unix sockets
+ * have no HTTP origin, so we return an empty string and the caller omits it.
+ */
+export function buildWorkflowStatusUrl(host, workflowId) {
+    const trimmed = host.trim();
+    if (trimmed.startsWith("unix://") || trimmed.startsWith("pipe://")) {
+        return "";
+    }
+    let authority = trimmed;
+    if (authority.startsWith("tcp://")) {
+        authority = authority.slice("tcp://".length);
+    }
+    // Drop any query string (e.g. ?ssl=true&password=…) — not part of the origin.
+    authority = authority.split("?")[0] ?? authority;
+    if (!authority) {
+        return "";
+    }
+    const scheme = trimmed.includes("ssl=true") ? "https" : "http";
+    return `${scheme}://${authority}/api/workflows/${workflowId}`;
+}
+export async function runWorkflowStartCommand(graphPath, options, _command) {
+    // Parse + validate the task-graph file client-side for a clean error message;
+    // the daemon re-validates against the same schema at the parse boundary.
+    let graph;
+    try {
+        const raw = readFileSync(graphPath, "utf-8");
+        graph = WorkflowTaskGraphSchema.parse(JSON.parse(raw));
+    }
+    catch (error) {
+        throw {
+            code: "WORKFLOW_GRAPH_INVALID",
+            message: `Could not read/parse task graph at ${graphPath}: ${error instanceof Error ? error.message : String(error)}`,
+            details: "Expected a JSON file matching the daemon's task-graph shape.",
+        };
+    }
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        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 started = await client.startWorkflow({
+            graph,
+            provider: options.provider ?? "claude",
+            cwd: options.cwd ?? process.cwd(),
+            ...(options.model ? { model: options.model } : {}),
+            ...(options.title ? { title: options.title } : {}),
+        });
+        await client.close();
+        return {
+            type: "single",
+            data: {
+                workflowId: started.workflowId,
+                status: started.status,
+                childAgentIds: started.childAgentIds,
+                statusUrl: buildWorkflowStatusUrl(host, started.workflowId),
+            },
+            schema: startSchema,
+        };
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        throw {
+            code: "WORKFLOW_START_FAILED",
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+//# sourceMappingURL=start.js.map

package/dist/commands/workflow/status.d.ts

@@ -0,0 +1,17 @@
+import { Command } from "commander";
+import type { CommandOptions, ListResult } from "../../output/index.js";
+interface WorkflowListRow {
+    id: string;
+    title: string;
+    status: string;
+    stories: string;
+    cwd: string;
+    updated: string;
+}
+export interface WorkflowStatusOptions extends CommandOptions {
+}
+export declare function addWorkflowStatusOptions(command: Command): Command;
+export type WorkflowStatusResult = ListResult<WorkflowListRow>;
+export declare function runWorkflowStatusCommand(options: WorkflowStatusOptions, _command: Command): Promise<WorkflowStatusResult>;
+export {};
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/workflow/status.js

@@ -0,0 +1,57 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+const statusSchema = {
+    idField: "id",
+    columns: [
+        { header: "WORKFLOW ID", field: "id", width: 38 },
+        { header: "TITLE", field: "title", width: 24 },
+        { header: "STATUS", field: "status", width: 10 },
+        { header: "STORIES", field: "stories", width: 8 },
+        { header: "CWD", field: "cwd", width: 36 },
+        { header: "UPDATED", field: "updated", width: 24 },
+    ],
+};
+export function addWorkflowStatusOptions(command) {
+    return command.description("List every known workflow and its live status");
+}
+function toRow(workflow) {
+    return {
+        id: workflow.id,
+        title: workflow.title ?? "-",
+        status: workflow.status,
+        stories: `${workflow.completedStoryCount}/${workflow.totalStoryCount ?? workflow.childAgentIds.length}`,
+        cwd: workflow.cwd,
+        updated: workflow.updatedAt,
+    };
+}
+export async function runWorkflowStatusCommand(options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    let client;
+    try {
+        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 workflows = await client.listWorkflows();
+        await client.close();
+        return {
+            type: "list",
+            data: workflows.map(toRow),
+            schema: statusSchema,
+        };
+    }
+    catch (error) {
+        await client.close().catch(() => { });
+        throw {
+            code: "WORKFLOW_STATUS_FAILED",
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+//# sourceMappingURL=status.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 "@hyperdrive.bot/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