@getpaseo/cli 0.2.0-beta.1 → 0.2.0-beta.2

package/dist/cli.js

@@ -9,6 +9,9 @@ import { createScheduleCommand } from "./commands/schedule/index.js";
 import { createSpeechCommand } from "./commands/speech/index.js";
 import { createTerminalCommand } from "./commands/terminal/index.js";
 import { createWorktreeCommand } from "./commands/worktree/index.js";
+import { createWorkspaceCommand } from "./commands/workspace/index.js";
+import { createHeartbeatCommand } from "./commands/heartbeat/index.js";
+import { createHubCommand } from "./commands/hub/index.js";
 import { createHooksCommand } from "./commands/hooks.js";
 import { startCommand as daemonStartCommand } from "./commands/daemon/start.js";
 import { runStatusCommand as runDaemonStatusCommand } from "./commands/daemon/status.js";
@@ -100,6 +103,7 @@ export function createCli() {
     program.addCommand(createAgentCommand());
     // Daemon commands
     program.addCommand(createDaemonCommand());
+    program.addCommand(createHubCommand());
     // Chat commands
     program.addCommand(createChatCommand());
     // Terminal commands
@@ -108,14 +112,18 @@ export function createCli() {
     program.addCommand(createLoopCommand());
     // Schedule commands
     program.addCommand(createScheduleCommand());
+    program.addCommand(createHeartbeatCommand());
     // Permission commands
     program.addCommand(createPermitCommand());
     // Provider commands
     program.addCommand(createProviderCommand());
     // Speech model commands
     program.addCommand(createSpeechCommand());
-    // Worktree commands
-    program.addCommand(createWorktreeCommand());
+    // Workspace commands
+    program.addCommand(createWorkspaceCommand());
+    // COMPAT(worktreeCli): legacy command alias added before workspace was the product unit.
+    // Added in v0.2.0; remove after 2027-01-17.
+    program.addCommand(createWorktreeCommand(), { hidden: true });
     return program;
 }
 //# sourceMappingURL=cli.js.map

package/dist/commands/agent/detach.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+interface AgentDetachResult {
+    agentId: string;
+    status: "detached";
+}
+export declare function runDetachCommand(agentIdArg: string, options: CommandOptions, _command: Command): Promise<SingleResult<AgentDetachResult>>;
+export {};
+//# sourceMappingURL=detach.d.ts.map

package/dist/commands/agent/detach.js

@@ -0,0 +1,38 @@
+import { connectToDaemon, getDaemonHost, resolveAgentId } from "../../utils/client.js";
+const detachSchema = {
+    idField: "agentId",
+    columns: [
+        { header: "AGENT ID", field: "agentId" },
+        { header: "STATUS", field: "status" },
+    ],
+};
+export async function runDetachCommand(agentIdArg, 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}`,
+        };
+    }
+    try {
+        const payload = await client.fetchAgents({ filter: { includeArchived: true } });
+        const agentId = resolveAgentId(agentIdArg, payload.entries.map((entry) => entry.agent));
+        if (!agentId) {
+            throw {
+                code: "AGENT_NOT_FOUND",
+                message: `Agent not found: ${agentIdArg}`,
+            };
+        }
+        await client.detachAgent(agentId);
+        return { type: "single", data: { agentId, status: "detached" }, schema: detachSchema };
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+//# sourceMappingURL=detach.js.map

package/dist/commands/agent/index.js

@@ -13,6 +13,7 @@ import { addAttachOptions, runAttachCommand } from "./attach.js";
 import { addReloadOptions, runReloadCommand } from "./reload.js";
 import { addImportOptions, runImportCommand } from "./import.js";
 import { runUpdateCommand } from "./update.js";
+import { runDetachCommand } from "./detach.js";
 import { withOutput } from "../../output/index.js";
 import { addDaemonHostOption, addJsonAndDaemonHostOptions, collectMultiple, } from "../../utils/command-options.js";
 export function createAgentCommand() {
@@ -37,6 +38,10 @@ export function createAgentCommand() {
         .option("--list", "List available modes for this agent")).action(withOutput(runModeCommand));
     addJsonAndDaemonHostOptions(addArchiveOptions(agent.command("archive"))).action(withOutput(runArchiveCommand));
     addJsonAndDaemonHostOptions(addReloadOptions(agent.command("reload"))).action(withOutput(runReloadCommand));
+    addJsonAndDaemonHostOptions(agent
+        .command("detach")
+        .description("Make a subagent independent without stopping or moving it")
+        .argument("<id>", "Agent ID, prefix, or name")).action(withOutput(runDetachCommand));
     addJsonAndDaemonHostOptions(agent
         .command("update")
         .description("Update an agent's metadata")

package/dist/commands/agent/run.d.ts

@@ -14,6 +14,7 @@ export interface AgentRunResult {
 /** Schema for agent run output */
 export declare const agentRunSchema: OutputSchema<AgentRunResult>;
 export interface AgentRunOptions extends CommandOptions {
+    background?: boolean;
     detach?: boolean;
     title?: string;
     name?: string;
@@ -21,6 +22,7 @@ export interface AgentRunOptions extends CommandOptions {
     model?: string;
     thinking?: string;
     mode?: string;
+    isolation?: string;
     worktree?: string;
     base?: string;
     workspace?: string;
@@ -40,5 +42,31 @@ export declare function resolveStructuredResponseMessage(options: {
     agentId: string;
     lastMessage: string | null;
 }): Promise<string | null>;
+interface RunWorkspace {
+    id?: string;
+    cwd: string;
+}
+export interface RunWorkspaceLookupClient {
+    fetchWorkspaces(options: {
+        filter: {
+            query: string;
+        };
+        page: {
+            limit: number;
+        };
+    }): Promise<{
+        entries: Array<{
+            id: string;
+            workspaceDirectory: string;
+        }>;
+        pageInfo: {
+            nextCursor: string | null;
+        };
+    }>;
+}
+export declare function resolveExistingRunWorkspace(client: RunWorkspaceLookupClient, workspaceId: string): Promise<RunWorkspace>;
 export declare function runRunCommand(prompt: string, options: AgentRunOptions, _command: Command): Promise<SingleResult<AgentRunResult>>;
+export declare function resolveRunCallerAgentId(env?: {
+    PASEO_AGENT_ID?: string;
+}): string | undefined;
 //# sourceMappingURL=run.d.ts.map

package/dist/commands/agent/run.js

@@ -9,25 +9,29 @@ import { collectMultiple } from "../../utils/command-options.js";
 import { resolveProviderAndModel } from "../../utils/provider-model.js";
 export { resolveProviderAndModel } from "../../utils/provider-model.js";
 export function addRunOptions(cmd) {
-    return cmd
+    return (cmd
         .description("Create and start an agent with a task")
         .argument("<prompt>", "The task/prompt for the agent")
-        .option("-d, --detach", "Run in background (detached)")
+        .option("-d, --background", "Run in background")
+        // COMPAT(detachRunFlag): --detach used to mean background execution, not
+        // ownership transfer. Added in v0.2.0; remove after 2027-01-17.
+        .addOption(new Option("--detach", "Legacy alias for --background").hideHelp())
         .option("--title <title>", "Assign a title to the agent")
         .addOption(new Option("--name <name>", "Hidden alias for --title").hideHelp())
         .option("--provider <provider>", "Agent provider, or provider/model (e.g. codex or codex/gpt-5.4)")
         .option("--model <model>", "Model to use (e.g., claude-sonnet-4-20250514, claude-3-5-haiku-20241022)")
         .option("--thinking <id>", "Thinking option ID to use for this run")
         .option("--mode <mode>", "Provider-specific mode (e.g., plan, default, bypass)")
-        .option("--worktree <name>", "Create agent in a new git worktree")
-        .option("--base <branch>", "Base branch for worktree (default: current branch)")
+        .option("--isolation <local|worktree>", "Create a new workspace with this isolation")
+        .addOption(new Option("--worktree <name>", "Legacy workspace isolation alias").hideHelp())
+        .option("--base <branch>", "Base branch for an isolated workspace")
         .option("--workspace <id>", "Run in an existing workspace (default: a new workspace is created per run; falls back to $PASEO_WORKSPACE_ID)")
         .option("--image <path>", "Attach image(s) to the initial prompt (can be used multiple times)", collectMultiple, [])
         .option("--cwd <path>", "Working directory (default: current)")
         .option("--env <key=value>", "Set environment variable(s) for the agent process (can be used multiple times)", collectMultiple, [])
         .option("--label <key=value>", "Add label(s) to the agent (can be used multiple times)", collectMultiple, [])
         .option("--wait-timeout <duration>", "Maximum time to wait for agent to finish (e.g., 30s, 5m, 1h). Default: no limit")
-        .option("--output-schema <schema>", "Output JSON matching the provided schema file path or inline JSON schema");
+        .option("--output-schema <schema>", "Output JSON matching the provided schema file path or inline JSON schema"));
 }
 /** Schema for agent run output */
 export const agentRunSchema = {
@@ -172,35 +176,48 @@ function validateRunOptions(prompt, options, outputSchema) {
             details: "Usage: paseo agent run [options] <prompt>",
         };
     }
-    if (options.base && !options.worktree) {
+    const createsIsolatedWorkspace = options.isolation === "worktree" || Boolean(options.worktree);
+    if (options.isolation && options.isolation !== "local" && options.isolation !== "worktree") {
         throw {
             code: "INVALID_OPTIONS",
-            message: "--base can only be used with --worktree",
-            details: "Usage: paseo agent run --worktree <name> --base <branch> <prompt>",
+            message: `Unsupported workspace isolation: ${options.isolation}`,
+            details: "Use --isolation local or --isolation worktree",
         };
     }
-    if (options.worktree && options.workspace) {
+    if (options.base && !createsIsolatedWorkspace) {
         throw {
             code: "INVALID_OPTIONS",
-            message: "--worktree and --workspace cannot be combined",
-            details: "--workspace runs in an existing workspace; --worktree mints a new one",
+            message: "--base can only be used with --isolation worktree",
+            details: "Usage: paseo agent run --isolation worktree --base <branch> <prompt>",
         };
     }
-    if (options.worktree && !options.workspace && process.env.PASEO_WORKSPACE_ID) {
+    if (options.isolation && options.workspace) {
         throw {
             code: "INVALID_OPTIONS",
-            message: "--worktree cannot be combined with an ambient PASEO_WORKSPACE_ID",
-            details: "PASEO_WORKSPACE_ID selects an existing workspace; --worktree mints a new one. Unset PASEO_WORKSPACE_ID to use --worktree.",
+            message: "--isolation and --workspace cannot be combined",
+            details: "Select an existing workspace or create a new one with an isolation choice",
         };
     }
-    if (outputSchema && options.detach) {
+    // COMPAT(worktreeRunFlag): --worktree implies a new worktree-isolated workspace.
+    // Added in v0.2.0; remove after 2027-01-17.
+    if (options.worktree && options.workspace) {
         throw {
             code: "INVALID_OPTIONS",
-            message: "--output-schema cannot be used with --detach",
+            message: "--worktree and --workspace cannot be combined",
+            details: "Use --isolation worktree instead of the legacy --worktree flag",
+        };
+    }
+    if (outputSchema && runsInBackground(options)) {
+        throw {
+            code: "INVALID_OPTIONS",
+            message: "--output-schema cannot be used with --background",
             details: "Structured output requires waiting for the agent to finish",
         };
     }
 }
+function runsInBackground(options) {
+    return Boolean(options.background || options.detach);
+}
 function parseWaitTimeoutOption(waitTimeout) {
     if (!waitTimeout)
         return 0;
@@ -289,27 +306,46 @@ async function connectToDaemonOrThrow(hostOption, host) {
         };
     }
 }
+export async function resolveExistingRunWorkspace(client, workspaceId) {
+    const result = await client.fetchWorkspaces({
+        filter: { query: workspaceId },
+        page: { limit: 200 },
+    });
+    const workspace = result.entries.find((entry) => entry.id === workspaceId);
+    if (workspace) {
+        return { id: workspace.id, cwd: workspace.workspaceDirectory };
+    }
+    throw {
+        code: "WORKSPACE_NOT_FOUND",
+        message: `Workspace not found: ${workspaceId}`,
+    };
+}
 // Workspace policy for `paseo run`. Precedence:
 //   1. --workspace <id>            -> run in that existing workspace
-//   2. $PASEO_WORKSPACE_ID         -> exported by workspace terminals
-//   3. --worktree <name>           -> mint a new worktree-backed workspace
-//   4. bare run                    -> mint a new local-backed workspace for cwd
-// --worktree is rejected alongside both --workspace and an ambient
-// $PASEO_WORKSPACE_ID (validateRunOptions), so worktree resolution here never
-// races an existing-workspace selection.
+//   2. $PASEO_AGENT_ID             -> daemon resolves the caller's workspace
+//   3. $PASEO_WORKSPACE_ID         -> exported by workspace terminals
+//   4. --isolation <kind>          -> mint a new workspace with explicit isolation
+//   5. bare run                    -> mint a new local-backed workspace for cwd
 async function resolveRunWorkspace(client, options, cwd) {
-    // An explicit --worktree mints its own workspace; --workspace and an ambient
-    // PASEO_WORKSPACE_ID are both rejected alongside --worktree upstream.
-    const explicit = options.worktree
-        ? undefined
-        : options.workspace?.trim() || process.env.PASEO_WORKSPACE_ID?.trim();
+    const requestedIsolation = options.isolation ?? (options.worktree ? "worktree" : undefined);
+    const explicit = requestedIsolation ? undefined : options.workspace?.trim();
     if (explicit) {
         console.error(`Using workspace ${explicit}`);
-        return { id: explicit, cwd };
+        return resolveExistingRunWorkspace(client, explicit);
+    }
+    if (!requestedIsolation && resolveRunCallerAgentId()) {
+        return { cwd };
+    }
+    const ambientWorkspaceId = requestedIsolation
+        ? undefined
+        : process.env.PASEO_WORKSPACE_ID?.trim();
+    if (ambientWorkspaceId) {
+        console.error(`Using workspace ${ambientWorkspaceId}`);
+        return resolveExistingRunWorkspace(client, ambientWorkspaceId);
     }
     // TODO: thread the run `prompt` as firstAgentContext so workspace-level
     // title/branch generation picks up the task description (U8/U6 deferred).
-    const result = options.worktree
+    const result = requestedIsolation === "worktree"
         ? await client.createWorkspace({
             source: {
                 kind: "worktree",
@@ -357,6 +393,7 @@ export async function runRunCommand(prompt, options, _command) {
         const requestEnv = Object.keys(env).length > 0 ? env : undefined;
         const workspace = await resolveRunWorkspace(client, options, cwd);
         const workspaceId = workspace.id;
+        const callerAgentId = resolveRunCallerAgentId();
         const runCwd = workspace.cwd;
         if (outputSchema) {
             let structuredAgent = null;
@@ -366,6 +403,7 @@ export async function runRunCommand(prompt, options, _command) {
                         provider: resolvedProviderModel.provider,
                         cwd: runCwd,
                         workspaceId,
+                        callerAgentId,
                         title: resolvedTitle,
                         modeId: options.mode,
                         model: resolvedProviderModel.model,
@@ -420,6 +458,7 @@ export async function runRunCommand(prompt, options, _command) {
             provider: resolvedProviderModel.provider,
             cwd: runCwd,
             workspaceId,
+            callerAgentId,
             title: resolvedTitle,
             modeId: options.mode,
             model: resolvedProviderModel.model,
@@ -429,8 +468,8 @@ export async function runRunCommand(prompt, options, _command) {
             env: requestEnv,
             labels: Object.keys(labels).length > 0 ? labels : undefined,
         });
-        // Default run behavior is foreground: wait for completion unless --detach is set.
-        if (!options.detach) {
+        // Default run behavior is foreground: wait for completion unless background execution is set.
+        if (!runsInBackground(options)) {
             const state = await client.waitForFinish(agent.id, waitTimeoutMs);
             await client.close();
             const finalAgent = state.final ?? agent;
@@ -461,4 +500,7 @@ export async function runRunCommand(prompt, options, _command) {
         throw error;
     }
 }
+export function resolveRunCallerAgentId(env = process.env) {
+    return env.PASEO_AGENT_ID?.trim() || undefined;
+}
 //# sourceMappingURL=run.js.map

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

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

package/dist/commands/heartbeat/index.js

@@ -0,0 +1,139 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { parseDuration } from "../../utils/duration.js";
+import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "../schedule/shared.js";
+import { scheduleSchema } from "../schedule/schema.js";
+const heartbeatDeleteSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id" },
+        { header: "STATUS", field: "status" },
+    ],
+};
+function requireCallerAgentId() {
+    const agentId = process.env.PASEO_AGENT_ID?.trim();
+    if (!agentId) {
+        throw new Error("Heartbeat commands must run inside a Paseo agent");
+    }
+    return agentId;
+}
+async function requireOwnedHeartbeat(client, id, agentId) {
+    const payload = await client.scheduleInspect({ id });
+    if (payload.error || !payload.schedule) {
+        throw new Error(payload.error ?? `Heartbeat not found: ${id}`);
+    }
+    if (payload.schedule.target.type !== "agent" || payload.schedule.target.agentId !== agentId) {
+        throw new Error(`Heartbeat ${id} does not belong to agent ${agentId}`);
+    }
+}
+async function runCreateHeartbeat(prompt, options, _command) {
+    const agentId = requireCallerAgentId();
+    const cron = options.cron?.trim();
+    if (!cron) {
+        throw new Error("--cron is required");
+    }
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        const maxRuns = options.maxRuns ? Number.parseInt(options.maxRuns, 10) : undefined;
+        if (maxRuns !== undefined && (!Number.isSafeInteger(maxRuns) || maxRuns <= 0)) {
+            throw new Error("--max-runs must be a positive integer");
+        }
+        const payload = await client.scheduleCreate({
+            prompt: prompt.trim(),
+            cadence: {
+                type: "cron",
+                expression: cron,
+                ...(options.timezone?.trim() ? { timezone: options.timezone.trim() } : {}),
+            },
+            target: { type: "agent", agentId },
+            ...(options.name?.trim() ? { name: options.name.trim() } : {}),
+            ...(maxRuns ? { maxRuns } : {}),
+            ...(options.expiresIn
+                ? { expiresAt: new Date(Date.now() + parseDuration(options.expiresIn)).toISOString() }
+                : {}),
+        });
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? "Heartbeat creation failed");
+        }
+        return { type: "single", data: toScheduleRow(payload.schedule), schema: scheduleSchema };
+    }
+    catch (error) {
+        throw toScheduleCommandError("HEARTBEAT_CREATE_FAILED", "create heartbeat", error);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+async function runUpdateHeartbeat(id, options, _command) {
+    const agentId = requireCallerAgentId();
+    const cron = options.cron?.trim();
+    if (!cron) {
+        throw new Error("--cron is required");
+    }
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        await requireOwnedHeartbeat(client, id, agentId);
+        const payload = await client.scheduleUpdate({
+            id,
+            cadence: {
+                type: "cron",
+                expression: cron,
+                ...(options.timezone?.trim() ? { timezone: options.timezone.trim() } : {}),
+            },
+        });
+        if (payload.error || !payload.schedule) {
+            throw new Error(payload.error ?? `Heartbeat update failed: ${id}`);
+        }
+        return { type: "single", data: toScheduleRow(payload.schedule), schema: scheduleSchema };
+    }
+    catch (error) {
+        throw toScheduleCommandError("HEARTBEAT_UPDATE_FAILED", "update heartbeat", error);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+async function runDeleteHeartbeat(id, options, _command) {
+    const agentId = requireCallerAgentId();
+    const { client } = await connectScheduleClient(options.host);
+    try {
+        await requireOwnedHeartbeat(client, id, agentId);
+        const payload = await client.scheduleDelete({ id });
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        return {
+            type: "single",
+            data: { id: payload.scheduleId, status: "deleted" },
+            schema: heartbeatDeleteSchema,
+        };
+    }
+    catch (error) {
+        throw toScheduleCommandError("HEARTBEAT_DELETE_FAILED", "delete heartbeat", error);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+export function createHeartbeatCommand() {
+    const heartbeat = new Command("heartbeat").description("Manage this agent's heartbeats");
+    addJsonAndDaemonHostOptions(heartbeat
+        .command("create")
+        .description("Create a recurring prompt for this agent")
+        .argument("<prompt>", "Prompt to send")
+        .requiredOption("--cron <expr>", "Five-field cron cadence")
+        .option("--timezone <iana>", "IANA time zone")
+        .option("--name <name>", "Heartbeat name")
+        .option("--max-runs <n>", "Maximum number of runs")
+        .option("--expires-in <duration>", "Time to live")).action(withOutput(runCreateHeartbeat));
+    addJsonAndDaemonHostOptions(heartbeat
+        .command("update")
+        .description("Change a heartbeat cron cadence")
+        .argument("<id>", "Heartbeat ID")
+        .requiredOption("--cron <expr>", "Five-field cron cadence")
+        .option("--timezone <iana>", "IANA time zone")).action(withOutput(runUpdateHeartbeat));
+    addJsonAndDaemonHostOptions(heartbeat.command("delete").description("Delete a heartbeat").argument("<id>", "Heartbeat ID")).action(withOutput(runDeleteHeartbeat));
+    return heartbeat;
+}
+//# sourceMappingURL=index.js.map

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

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

package/dist/commands/hub/index.js

@@ -0,0 +1,65 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { connectToDaemon } from "../../utils/client.js";
+const schema = {
+    idField: "state",
+    columns: [
+        { header: "STATE", field: "state" },
+        { header: "HUB", field: "hub" },
+        { header: "DAEMON", field: "daemonId" },
+        { header: "SCOPES", field: "scopes" },
+        { header: "CONNECTED", field: "connectedAt" },
+        { header: "ERROR", field: "error" },
+        { header: "WARNING", field: "warning" },
+    ],
+};
+function result(status, warning) {
+    return {
+        type: "list",
+        data: [
+            {
+                state: status.state,
+                daemonId: status.daemonId,
+                hub: status.hubOrigin,
+                scopes: status.scopes.join(", "),
+                connectedAt: status.connectedAt,
+                error: status.lastError,
+                warning,
+            },
+        ],
+        schema,
+    };
+}
+async function withClient(host, action) {
+    const client = await connectToDaemon({ host });
+    try {
+        return await action(client);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+export function createHubCommand() {
+    const hub = new Command("hub").description("Manage this daemon's Paseo Hub relationship");
+    addJsonAndDaemonHostOptions(hub.command("connect").argument("<url>").requiredOption("--token <token>")).action(withOutput(async (...args) => {
+        const url = args[0];
+        const options = args.at(-2);
+        return withClient(options.host, async (client) => result((await client.connectHub(url, options.token)).status));
+    }));
+    addJsonAndDaemonHostOptions(hub.command("status")).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return withClient(options.host, async (client) => result((await client.getHubStatus()).status));
+    }));
+    addJsonAndDaemonHostOptions(hub
+        .command("disconnect")
+        .option("--force", "Remove local authority even if the Hub is offline")).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return withClient(options.host, async (client) => {
+            const response = await client.disconnectHub(options.force ?? false);
+            return result(response.status, response.warning);
+        });
+    }));
+    return hub;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/schedule/index.js

@@ -1,4 +1,4 @@
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { withOutput } from "../../output/index.js";
 import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
 import { runCreateCommand } from "./create.js";
@@ -16,16 +16,15 @@ export function createScheduleCommand() {
         .command("create")
         .description("Create a schedule")
         .argument("<prompt>", "Prompt to run on the schedule")
-        .option("--every <duration>", "Fixed interval cadence (for example: 5m, 1h)")
+        .option("--every <duration>", "Cron-compatible cadence preset (for example: 5m, 1h)")
         .option("--cron <expr>", "Cron cadence expression")
         .option("--timezone <iana>", "IANA time zone for cron cadence (default: UTC)")
         .option("--name <name>", "Optional schedule name")
-        .option("--target <self|new-agent|agent-id>", "Run target")
+        .addOption(new Option("--target <target>", "Legacy schedule target").hideHelp())
         .option("--provider <provider>", "Agent provider, or provider/model (e.g. codex or codex/gpt-5.4)")
         .option("--mode <mode>", "Provider-specific mode (e.g. claude bypassPermissions, opencode build)")
         .option("--cwd <path>", "Working directory (default: current; required with --host)")
-        .option("--run-now", "Fire one immediate run on creation (only with --cron)")
-        .option("--no-run-now", "Wait the full interval before the first run (only with --every)")
+        .option("--run-now", "Fire one immediate run on creation")
         .option("--max-runs <n>", "Maximum number of runs")
         .option("--expires-in <duration>", "Time to live for the schedule")).action(withOutput(runCreateCommand));
     addJsonAndDaemonHostOptions(schedule.command("ls").description("List schedules")).action(withOutput(runLsCommand));
@@ -48,7 +47,7 @@ export function createScheduleCommand() {
         .command("update")
         .description("Update an existing schedule in place")
         .argument("<id>", "Schedule ID")
-        .option("--every <duration>", "Switch to fixed interval cadence (for example: 5m, 1h)")
+        .option("--every <duration>", "Cron-compatible cadence preset (for example: 5m, 1h)")
         .option("--cron <expr>", "Switch to cron cadence expression")
         .option("--timezone <iana>", "IANA time zone for cron cadence (requires --cron)")
         .option("--name <name>", "Rename the schedule (empty string clears the name)")

package/dist/commands/schedule/inspect.js

@@ -7,6 +7,9 @@ export async function runInspectCommand(id, options, _command) {
         if (payload.error || !payload.schedule) {
             throw new Error(payload.error ?? `Schedule not found: ${id}`);
         }
+        if (payload.schedule.target.type !== "new-agent") {
+            throw new Error(`Schedule not found: ${id}`);
+        }
         const rows = createScheduleInspectRows(payload.schedule);
         return {
             type: "list",

package/dist/commands/schedule/logs.js

@@ -1,8 +1,9 @@
 import { scheduleLogSchema, toScheduleLogRow } from "./schema.js";
-import { connectScheduleClient, toScheduleCommandError, } from "./shared.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, } from "./shared.js";
 export async function runLogsCommand(id, options, _command) {
     const { client } = await connectScheduleClient(options.host);
     try {
+        await requireNewAgentSchedule(client, id);
         const payload = await client.scheduleLogs({ id });
         if (payload.error) {
             throw new Error(payload.error);

package/dist/commands/schedule/ls.js

@@ -9,7 +9,9 @@ export async function runLsCommand(options, _command) {
         }
         return {
             type: "list",
-            data: payload.schedules.map(toScheduleRow),
+            data: payload.schedules
+                .filter((schedule) => schedule.target.type === "new-agent")
+                .map(toScheduleRow),
             schema: scheduleSchema,
         };
     }

package/dist/commands/schedule/pause.js

@@ -1,8 +1,9 @@
 import { scheduleSchema } from "./schema.js";
-import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
 export async function runPauseCommand(id, options, _command) {
     const { client } = await connectScheduleClient(options.host);
     try {
+        await requireNewAgentSchedule(client, id);
         const payload = await client.schedulePause({ id });
         if (payload.error || !payload.schedule) {
             throw new Error(payload.error ?? `Failed to pause schedule: ${id}`);

package/dist/commands/schedule/resume.js

@@ -1,8 +1,9 @@
 import { scheduleSchema } from "./schema.js";
-import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
 export async function runResumeCommand(id, options, _command) {
     const { client } = await connectScheduleClient(options.host);
     try {
+        await requireNewAgentSchedule(client, id);
         const payload = await client.scheduleResume({ id });
         if (payload.error || !payload.schedule) {
             throw new Error(payload.error ?? `Failed to resume schedule: ${id}`);

package/dist/commands/schedule/run-once.js

@@ -1,8 +1,9 @@
 import { scheduleSchema } from "./schema.js";
-import { connectScheduleClient, toScheduleCommandError, toScheduleRow, } from "./shared.js";
+import { connectScheduleClient, requireNewAgentSchedule, toScheduleCommandError, toScheduleRow, } from "./shared.js";
 export async function runRunOnceCommand(id, options, _command) {
     const { client } = await connectScheduleClient(options.host);
     try {
+        await requireNewAgentSchedule(client, id);
         const payload = await client.scheduleRunOnce({ id });
         if (payload.error || !payload.schedule) {
             throw new Error(payload.error ?? `Failed to run schedule once: ${id}`);

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

@@ -8,6 +8,7 @@ export declare function connectScheduleClient(host: string | undefined): Promise
     host: string;
 }>;
 export declare function toScheduleCommandError(code: string, action: string, error: unknown): CommandError;
+export declare function requireNewAgentSchedule(client: ScheduleDaemonClient, id: string): Promise<void>;
 export declare function formatCadence(cadence: ScheduleCadence): string;
 export declare function formatTarget(target: ScheduleTarget | ScheduleListItem["target"]): string;
 export declare function formatDurationMs(durationMs: number): string;
@@ -43,6 +44,7 @@ export interface ScheduleUpdateOptionsInput {
     clearExpires?: boolean;
 }
 export declare function parseScheduleUpdateInput(options: ScheduleUpdateOptionsInput): UpdateScheduleInput;
+export declare function compileEveryPresetToCron(value: string): string;
 export interface ScheduleRow {
     id: string;
     name: string | null;

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 "@getpaseo/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.PASEO_AGENT_ID?.trim();
     if (!targetValue) {
-        if (currentAgentId && !hasExplicitNewAgentOption) {
-            return { type: "self", agentId: currentAgentId };
-        }
         return createNewAgentTarget();
     }
     if (targetValue === "new-agent") {
@@ -84,6 +87,9 @@ function resolveScheduleTarget(args) {
         };
     }
     if (targetValue === "self") {
+        // COMPAT(scheduleSelfTarget): heartbeat creation moved to `paseo heartbeat create`.
+        // Added in v0.2.0; remove after 2027-01-17.
+        const currentAgentId = process.env.PASEO_AGENT_ID?.trim();
         if (!currentAgentId) {
             throw {
                 code: "INVALID_TARGET",
@@ -153,22 +159,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 +212,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 +223,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/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

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

@@ -0,0 +1,12 @@
+import type { WorkspaceDescriptorPayload } from "@getpaseo/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/utils/duration.d.ts

@@ -1,6 +1,6 @@
 /**
  * Parse duration string to milliseconds.
- * Supports formats like: 5m, 30s, 1h, 2h30m, 90, etc.
+ * Supports formats like: 5m, 30s, 1h, 2h30m, 1d, 90, etc.
  * If no unit is specified, assumes seconds.
  */
 export declare function parseDuration(input: string): number;

package/dist/utils/duration.js

@@ -1,6 +1,6 @@
 /**
  * Parse duration string to milliseconds.
- * Supports formats like: 5m, 30s, 1h, 2h30m, 90, etc.
+ * Supports formats like: 5m, 30s, 1h, 2h30m, 1d, 90, etc.
  * If no unit is specified, assumes seconds.
  */
 export function parseDuration(input) {
@@ -9,13 +9,14 @@ export function parseDuration(input) {
     if (/^\d+$/.test(trimmed)) {
         return parseInt(trimmed, 10) * 1000;
     }
+    if (!/^(?:\d+[smhd])+$/.test(trimmed)) {
+        throw new Error(`Invalid duration format: ${input}. Use formats like: 5m, 30s, 1h, 2h30m, 1d`);
+    }
     // Parse duration with units
     let totalMs = 0;
-    const regex = /(\d+)([smh])/g;
+    const regex = /(\d+)([smhd])/g;
     let match;
-    let hasMatch = false;
     while ((match = regex.exec(trimmed)) !== null) {
-        hasMatch = true;
         const value = parseInt(match[1], 10);
         const unit = match[2];
         switch (unit) {
@@ -28,11 +29,11 @@ export function parseDuration(input) {
             case "h":
                 totalMs += value * 60 * 60 * 1000;
                 break;
+            case "d":
+                totalMs += value * 24 * 60 * 60 * 1000;
+                break;
         }
     }
-    if (!hasMatch) {
-        throw new Error(`Invalid duration format: ${input}. Use formats like: 5m, 30s, 1h, 2h30m`);
-    }
     return totalMs;
 }
 //# sourceMappingURL=duration.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/cli",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.0-beta.2",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@getpaseo/client": "0.2.0-beta.1",
-    "@getpaseo/protocol": "0.2.0-beta.1",
-    "@getpaseo/server": "0.2.0-beta.1",
+    "@getpaseo/client": "0.2.0-beta.2",
+    "@getpaseo/protocol": "0.2.0-beta.2",
+    "@getpaseo/server": "0.2.0-beta.2",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",