@otto-code/cli 0.7.5 → 0.8.0

package/dist/commands/schedule/shared.js

@@ -1,6 +1,7 @@
 import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
 import { parseDuration } from "../../utils/duration.js";
 import { resolveProviderAndModel } from "../../utils/provider-model.js";
+import { everyMsToFiveFieldCron } from "@otto-code/protocol/schedule/cadence";
 export async function connectScheduleClient(host) {
     const resolvedHost = getDaemonHost({ host });
     try {
@@ -28,6 +29,12 @@ export function toScheduleCommandError(code, action, error) {
         message: `Failed to ${action}: ${message}`,
     };
 }
+export async function requireNewAgentSchedule(client, id) {
+    const payload = await client.scheduleInspect({ id });
+    if (payload.error || !payload.schedule || payload.schedule.target.type !== "new-agent") {
+        throw new Error(payload.error ?? `Schedule not found: ${id}`);
+    }
+}
 export function formatCadence(cadence) {
     if (cadence.type === "cron") {
         const timezoneSuffix = cadence.timezone ? ` (${cadence.timezone})` : "";
@@ -66,11 +73,7 @@ export function formatDurationMs(durationMs) {
 }
 function resolveScheduleTarget(args) {
     const { targetValue, hasExplicitNewAgentOption, createNewAgentTarget } = args;
-    const currentAgentId = process.env.OTTO_AGENT_ID?.trim();
     if (!targetValue) {
-        if (currentAgentId && !hasExplicitNewAgentOption) {
-            return { type: "self", agentId: currentAgentId };
-        }
         return createNewAgentTarget();
     }
     if (targetValue === "new-agent") {
@@ -79,11 +82,14 @@ function resolveScheduleTarget(args) {
     if (hasExplicitNewAgentOption) {
         throw {
             code: "INVALID_TARGET",
-            message: "--provider/--mode can only be used with a new-agent target",
+            message: "--provider/--mode/--thinking can only be used with a new-agent target",
             details: "Use --target new-agent or omit --target to create a new agent schedule",
         };
     }
     if (targetValue === "self") {
+        // COMPAT(scheduleSelfTarget): heartbeat creation moved to `otto heartbeat create`.
+        // Added in v0.2.0; remove after 2027-01-17.
+        const currentAgentId = process.env.OTTO_AGENT_ID?.trim();
         if (!currentAgentId) {
             throw {
                 code: "INVALID_TARGET",
@@ -119,7 +125,14 @@ export function parseScheduleCreateInput(options) {
     const runOnCreate = resolveRunOnCreate(options.runNow, cadence.type);
     const targetValue = options.target?.trim();
     const modeId = options.mode?.trim();
-    const hasExplicitNewAgentOption = options.provider !== undefined || options.mode !== undefined;
+    const thinkingOptionId = options.thinking?.trim();
+    if (options.thinking !== undefined && !thinkingOptionId) {
+        throw {
+            code: "INVALID_THINKING_OPTION",
+            message: "--thinking cannot be empty",
+        };
+    }
+    const hasExplicitNewAgentOption = options.provider !== undefined || options.mode !== undefined || options.thinking !== undefined;
     const createNewAgentTarget = () => {
         const resolvedProviderModel = resolveProviderAndModel({
             provider: options.provider,
@@ -131,6 +144,7 @@ export function parseScheduleCreateInput(options) {
                 cwd: cwdInput ?? process.cwd(),
                 ...(resolvedProviderModel.model ? { model: resolvedProviderModel.model } : {}),
                 ...(modeId ? { modeId } : {}),
+                ...(thinkingOptionId ? { thinkingOptionId } : {}),
             },
         };
     };
@@ -153,22 +167,8 @@ export function parseScheduleCreateInput(options) {
         ...(expiresAt ? { expiresAt } : {}),
     };
 }
-function resolveRunOnCreate(runNow, cadenceType) {
-    if (runNow === true && cadenceType === "every") {
-        throw {
-            code: "REDUNDANT_RUN_NOW",
-            message: "--run-now is redundant with --every (interval schedules already fire on creation)",
-            details: "Drop --run-now, or use --no-run-now to wait the full interval before the first run",
-        };
-    }
-    if (runNow === false && cadenceType === "cron") {
-        throw {
-            code: "REDUNDANT_NO_RUN_NOW",
-            message: "--no-run-now is redundant with --cron (cron schedules never fire on creation)",
-            details: "Drop --no-run-now, or use --run-now to fire one immediate run on creation",
-        };
-    }
-    return runNow ?? cadenceType === "every";
+function resolveRunOnCreate(runNow, _cadenceType) {
+    return runNow ?? false;
 }
 export function parseScheduleUpdateInput(options) {
     const id = options.id.trim();
@@ -220,7 +220,7 @@ function parseCadenceFromFlags(every, cron, timezone) {
         };
     }
     if (every !== undefined) {
-        return { type: "every", everyMs: parseDuration(every) };
+        return { type: "cron", expression: compileEveryPresetToCron(every) };
     }
     if (cron !== undefined) {
         return {
@@ -231,6 +231,18 @@ function parseCadenceFromFlags(every, cron, timezone) {
     }
     return undefined;
 }
+export function compileEveryPresetToCron(value) {
+    const durationMs = parseDuration(value);
+    const cron = everyMsToFiveFieldCron(durationMs);
+    if (cron) {
+        return cron;
+    }
+    throw {
+        code: "UNREPRESENTABLE_CADENCE",
+        message: `${value} cannot be represented faithfully by five-field cron`,
+        details: "Use --cron for calendar schedules",
+    };
+}
 function parseTimeZoneFlag(timeZone) {
     if (timeZone === undefined) {
         return undefined;

package/dist/commands/schedule/update.js

@@ -1,5 +1,5 @@
 import { createScheduleInspectRows, createScheduleInspectSchema, } from "./schema.js";
-import { connectScheduleClient, parseScheduleUpdateInput, toScheduleCommandError, } from "./shared.js";
+import { connectScheduleClient, parseScheduleUpdateInput, requireNewAgentSchedule, toScheduleCommandError, } from "./shared.js";
 export async function runUpdateCommand(id, options, _command) {
     const input = parseScheduleUpdateInput({
         id,
@@ -19,6 +19,7 @@ export async function runUpdateCommand(id, options, _command) {
     });
     const { client } = await connectScheduleClient(options.host);
     try {
+        await requireNewAgentSchedule(client, id);
         const payload = await client.scheduleUpdate(input);
         if (payload.error || !payload.schedule) {
             throw new Error(payload.error ?? `Failed to update schedule: ${id}`);

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

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

package/dist/commands/script/index.js

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { runLsCommand } from "./ls.js";
+import { runStartCommand } from "./start.js";
+import { runStopCommand } from "./stop.js";
+function addWorkspaceSelectionOptions(command) {
+    return command
+        .option("--cwd <path>", "Workspace directory (default: current directory)")
+        .option("--workspace <workspace-id>", "Workspace ID (required when a directory has multiple workspaces)");
+}
+export function createScriptCommand() {
+    const script = new Command("script").description("Manage configured workspace scripts");
+    addJsonAndDaemonHostOptions(addWorkspaceSelectionOptions(script.command("ls").description("List configured workspace scripts"))).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(addWorkspaceSelectionOptions(script.command("start").description("Start a configured workspace script").argument("<name>"))).action(withOutput(runStartCommand));
+    addJsonAndDaemonHostOptions(addWorkspaceSelectionOptions(script.command("stop").description("Stop a running workspace script").argument("<name>"))).action(withOutput(runStopCommand));
+    return script;
+}
+//# sourceMappingURL=index.js.map

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

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

package/dist/commands/script/ls.js

@@ -0,0 +1,20 @@
+import { connectWorkspaceScriptClient, resolveWorkspaceScriptWorkspaceId, toWorkspaceScriptCommandError, } from "./shared.js";
+import { workspaceScriptSchema } from "./schema.js";
+export async function runLsCommand(options, _command) {
+    const client = await connectWorkspaceScriptClient(options.host);
+    try {
+        const workspaceId = await resolveWorkspaceScriptWorkspaceId(client, options);
+        const payload = await client.listWorkspaceScripts(workspaceId);
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return { type: "list", data: payload.scripts ?? [], schema: workspaceScriptSchema };
+    }
+    catch (error) {
+        throw toWorkspaceScriptCommandError("WORKSPACE_SCRIPT_LIST_FAILED", "list workspace scripts", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=ls.js.map

package/dist/commands/script/schema.d.ts

@@ -0,0 +1,5 @@
+import type { WorkspaceScriptPayload } from "@otto-code/protocol/messages";
+import type { OutputSchema } from "../../output/index.js";
+export type WorkspaceScriptRow = WorkspaceScriptPayload;
+export declare const workspaceScriptSchema: OutputSchema<WorkspaceScriptRow>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/commands/script/schema.js

@@ -0,0 +1,13 @@
+export const workspaceScriptSchema = {
+    idField: "scriptName",
+    columns: [
+        { header: "NAME", field: "scriptName", width: 20 },
+        { header: "TYPE", field: "type", width: 9 },
+        { header: "LIFECYCLE", field: "lifecycle", width: 10 },
+        { header: "HEALTH", field: (script) => script.health ?? "-", width: 10 },
+        { header: "PORT", field: (script) => script.port ?? "-", width: 7 },
+        { header: "PROXY URL", field: (script) => script.proxyUrl ?? "-", width: 42 },
+        { header: "TERMINAL", field: (script) => script.terminalId ?? "-", width: 12 },
+    ],
+};
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1,11 @@
+import type { DaemonClient } from "@otto-code/client/internal/daemon-client";
+import type { CommandError, CommandOptions } from "../../output/index.js";
+export interface WorkspaceScriptCommandOptions extends CommandOptions {
+    host?: string;
+    cwd?: string;
+    workspace?: string;
+}
+export declare function connectWorkspaceScriptClient(host?: string): Promise<DaemonClient>;
+export declare function resolveWorkspaceScriptWorkspaceId(client: DaemonClient, options: WorkspaceScriptCommandOptions): Promise<string>;
+export declare function toWorkspaceScriptCommandError(code: string, action: string, error: unknown): CommandError;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/script/shared.js

@@ -0,0 +1,59 @@
+import { resolve } from "node:path";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export async function connectWorkspaceScriptClient(host) {
+    const daemonHost = getDaemonHost({ host });
+    try {
+        const client = await connectToDaemon({ host });
+        // COMPAT(workspaceScriptManagement): added in v0.1.105, remove gate after 2027-01-10.
+        if (!client.getLastServerInfoMessage()?.features?.workspaceScriptManagement) {
+            await client.close().catch(() => { });
+            throw {
+                code: "DAEMON_UPDATE_REQUIRED",
+                message: "Update the host to use workspace script management.",
+            };
+        }
+        return client;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && "message" in error) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${daemonHost}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+    }
+}
+export async function resolveWorkspaceScriptWorkspaceId(client, options) {
+    if (options.workspace) {
+        return options.workspace;
+    }
+    const cwd = resolve(options.cwd ?? process.cwd());
+    const payload = await client.fetchWorkspaces({ page: { limit: 200 } });
+    const matches = payload.entries.filter((workspace) => resolve(workspace.workspaceDirectory) === cwd);
+    if (matches.length === 1) {
+        return matches[0].id;
+    }
+    if (matches.length > 1) {
+        throw {
+            code: "WORKSPACE_AMBIGUOUS",
+            message: `Multiple workspaces use ${cwd}`,
+            details: "Pass --workspace <workspace-id> to select one.",
+        };
+    }
+    throw {
+        code: "WORKSPACE_NOT_FOUND",
+        message: `No Otto workspace found for ${cwd}`,
+        details: "Open the directory in Otto first, or pass --workspace <workspace-id>.",
+    };
+}
+export function toWorkspaceScriptCommandError(code, action, error) {
+    if (error && typeof error === "object" && "code" in error && "message" in error) {
+        return error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return { code, message: `Failed to ${action}: ${message}` };
+}
+//# sourceMappingURL=shared.js.map

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

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type WorkspaceScriptCommandOptions } from "./shared.js";
+import { type WorkspaceScriptRow } from "./schema.js";
+export declare function runStartCommand(scriptName: string, options: WorkspaceScriptCommandOptions, _command: Command): Promise<SingleResult<WorkspaceScriptRow>>;
+//# sourceMappingURL=start.d.ts.map

package/dist/commands/script/start.js

@@ -0,0 +1,23 @@
+import { connectWorkspaceScriptClient, resolveWorkspaceScriptWorkspaceId, toWorkspaceScriptCommandError, } from "./shared.js";
+import { workspaceScriptSchema } from "./schema.js";
+export async function runStartCommand(scriptName, options, _command) {
+    const client = await connectWorkspaceScriptClient(options.host);
+    try {
+        const workspaceId = await resolveWorkspaceScriptWorkspaceId(client, options);
+        const payload = await client.startWorkspaceScriptWithStatus(workspaceId, scriptName);
+        if (payload.error || !payload.script) {
+            throw {
+                code: "WORKSPACE_SCRIPT_START_FAILED",
+                message: payload.error ?? `Script '${scriptName}' did not return status metadata`,
+            };
+        }
+        return { type: "single", data: payload.script, schema: workspaceScriptSchema };
+    }
+    catch (error) {
+        throw toWorkspaceScriptCommandError("WORKSPACE_SCRIPT_START_FAILED", "start workspace script", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=start.js.map

package/dist/commands/script/stop.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type WorkspaceScriptCommandOptions } from "./shared.js";
+import { type WorkspaceScriptRow } from "./schema.js";
+export declare function runStopCommand(scriptName: string, options: WorkspaceScriptCommandOptions, _command: Command): Promise<SingleResult<WorkspaceScriptRow>>;
+//# sourceMappingURL=stop.d.ts.map

package/dist/commands/script/stop.js

@@ -0,0 +1,23 @@
+import { connectWorkspaceScriptClient, resolveWorkspaceScriptWorkspaceId, toWorkspaceScriptCommandError, } from "./shared.js";
+import { workspaceScriptSchema } from "./schema.js";
+export async function runStopCommand(scriptName, options, _command) {
+    const client = await connectWorkspaceScriptClient(options.host);
+    try {
+        const workspaceId = await resolveWorkspaceScriptWorkspaceId(client, options);
+        const payload = await client.stopWorkspaceScript(workspaceId, scriptName);
+        if (payload.error || !payload.script) {
+            throw {
+                code: "WORKSPACE_SCRIPT_STOP_FAILED",
+                message: payload.error ?? `Script '${scriptName}' did not return status metadata`,
+            };
+        }
+        return { type: "single", data: payload.script, schema: workspaceScriptSchema };
+    }
+    catch (error) {
+        throw toWorkspaceScriptCommandError("WORKSPACE_SCRIPT_STOP_FAILED", "stop workspace script", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=stop.js.map

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

@@ -0,0 +1,12 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+interface WorkspaceArchiveResult {
+    workspaceId: string;
+    status: "archived";
+    archivedAt: string;
+}
+export declare function runArchiveCommand(workspaceId: string, options: {
+    host?: string;
+}, _command: Command): Promise<SingleResult<WorkspaceArchiveResult>>;
+export {};
+//# sourceMappingURL=archive.d.ts.map

package/dist/commands/workspace/archive.js

@@ -0,0 +1,41 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+const workspaceArchiveSchema = {
+    idField: "workspaceId",
+    columns: [
+        { header: "WORKSPACE ID", field: "workspaceId", width: 20 },
+        { header: "STATUS", field: "status", width: 10 },
+        { header: "ARCHIVED AT", field: "archivedAt", width: 26 },
+    ],
+};
+export async function runArchiveCommand(workspaceId, 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.archiveWorkspace(workspaceId);
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        if (!payload.archivedAt) {
+            throw new Error("Workspace archive did not return an archive timestamp");
+        }
+        return {
+            type: "single",
+            data: { workspaceId, status: "archived", archivedAt: payload.archivedAt },
+            schema: workspaceArchiveSchema,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw { code: "WORKSPACE_ARCHIVE_FAILED", message };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=archive.js.map

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

@@ -0,0 +1,49 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+import { type WorkspaceRow } from "./shared.js";
+export interface WorkspaceCreateOptions extends CommandOptions {
+    isolation?: string;
+    path?: string;
+    project?: string;
+    title?: string;
+    mode?: string;
+    worktreeSlug?: string;
+    newBranch?: string;
+    base?: string;
+    branch?: string;
+    prNumber?: string;
+    forge?: string;
+}
+export declare function buildWorkspaceSource(options: WorkspaceCreateOptions): {
+    projectId?: string | undefined;
+    kind: "directory";
+    path: string;
+} | {
+    baseBranch?: string | undefined;
+    branchName?: string | undefined;
+    action: "branch-off";
+    kind: "worktree";
+    cwd?: string;
+    projectId?: string;
+    worktreeSlug?: string;
+} | {
+    action: "checkout";
+    refName: string;
+    kind: "worktree";
+    cwd?: string;
+    projectId?: string;
+    worktreeSlug?: string;
+} | {
+    action: "checkout";
+    checkoutSource: {
+        number: number;
+        forge?: string | undefined;
+        kind: "change_request";
+    };
+    kind: "worktree";
+    cwd?: string;
+    projectId?: string;
+    worktreeSlug?: string;
+};
+export declare function runCreateCommand(options: WorkspaceCreateOptions, _command: Command): Promise<SingleResult<WorkspaceRow>>;
+//# sourceMappingURL=create.d.ts.map

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,30 @@
+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";
+export function createWorkspaceCommand() {
+    const workspace = new Command("workspace").description("Manage workspaces");
+    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("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