@otto-code/cli 0.7.5 → 0.8.0

package/dist/cli.js

@@ -7,8 +7,13 @@ import { createPermitCommand } from "./commands/permit/index.js";
 import { createProviderCommand } from "./commands/provider/index.js";
 import { createScheduleCommand } from "./commands/schedule/index.js";
 import { createSpeechCommand } from "./commands/speech/index.js";
+import { createScriptCommand } from "./commands/script/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";
+// DISABLED(hub): specifier redirected away from "./commands/hub/index.js".
+import { createHubCommand } from "./commands/hub-disabled.js";
 import { createHooksCommand } from "./commands/hooks.js";
 import { createBrainCommand } from "@otto-code/brain";
 import { startCommand as daemonStartCommand } from "./commands/daemon/start.js";
@@ -26,6 +31,7 @@ import { addArchiveOptions, runArchiveCommand } from "./commands/agent/archive.j
 import { addAttachOptions, runAttachCommand } from "./commands/agent/attach.js";
 import { addImportOptions, runImportCommand } from "./commands/agent/import.js";
 import { withOutput } from "./output/index.js";
+import { runCloneCommand } from "./commands/clone.js";
 import { onboardCommand } from "./commands/onboard.js";
 import { addDaemonHostOption, addJsonAndDaemonHostOptions, addJsonOption, } from "./utils/command-options.js";
 import { resolveCliVersion } from "./version.js";
@@ -53,6 +59,13 @@ export function createCli() {
     addJsonAndDaemonHostOptions(addLsOptions(program.command("ls"))).action(withOutput(runLsCommand));
     addJsonAndDaemonHostOptions(addRunOptions(program.command("run"))).action(withOutput(runRunCommand));
     addJsonAndDaemonHostOptions(addImportOptions(program.command("import"))).action(withOutput(runImportCommand));
+    addJsonAndDaemonHostOptions(program
+        .command("clone")
+        .description("Clone a GitHub repo and register it as a Otto workspace")
+        .argument("<repo>", "GitHub repo in owner/repo format or a full git remote URL")
+        .requiredOption("--dir <path>", "Parent directory to clone into (for example: ~/workspace)"))
+        .addOption(new Option("--protocol <protocol>", "Protocol for owner/repo shorthand repositories").choices(["https", "ssh"]))
+        .action(withOutput(runCloneCommand));
     addDaemonHostOption(addAttachOptions(program.command("attach"))).action(runAttachCommand);
     addDaemonHostOption(addLogsOptions(program.command("logs"))).action(runLogsCommand);
     addJsonAndDaemonHostOptions(addStopOptions(program.command("stop"))).action(withOutput(runStopCommand));
@@ -93,22 +106,29 @@ export function createCli() {
     program.addCommand(createAgentCommand());
     // Daemon commands
     program.addCommand(createDaemonCommand());
+    program.addCommand(createHubCommand());
     // Chat commands
     program.addCommand(createChatCommand());
     // Terminal commands
     program.addCommand(createTerminalCommand());
+    // Workspace script commands
+    program.addCommand(createScriptCommand());
     // Loop commands
     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 });
     // Local AI (otto-brain)
     program.addCommand(createBrainCommand());
     return program;

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

@@ -22,7 +22,7 @@ export type AgentDeleteScope = "active" | "archived" | "both";
  * `--all` / `--cwd` still mean active-only.
  *
  * Both flags at once is contradictory ("only archived" and "also archived"), so
- * it is refused rather than guessed — this command is irreversible.
+ * it is refused rather than guessed - this command is irreversible.
  */
 export declare function resolveAgentDeleteScope(options: {
     archived?: boolean;

package/dist/commands/agent/delete.js

@@ -20,7 +20,7 @@ export const deleteSchema = {
  * `--all` / `--cwd` still mean active-only.
  *
  * Both flags at once is contradictory ("only archived" and "also archived"), so
- * it is refused rather than guessed — this command is irreversible.
+ * it is refused rather than guessed - this command is irreversible.
  */
 export function resolveAgentDeleteScope(options) {
     if (options.archived && options.includeArchived) {
@@ -97,7 +97,7 @@ export async function runDeleteCommand(id, options, _command) {
         const deleteResults = await Promise.all(agents.map(async (agent) => {
             try {
                 if (agent.status === "running") {
-                    await client.cancelAgent(agent.id);
+                    await client.cancelAgent(agent.id).catch(() => { });
                 }
                 await client.deleteAgent(agent.id);
                 return { ok: true, id: agent.id };

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,8 @@ 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 { addOpenOptions, runOpenCommand } from "./open.js";
 import { withOutput } from "../../output/index.js";
 import { addDaemonHostOption, addJsonAndDaemonHostOptions, collectMultiple, } from "../../utils/command-options.js";
 export function createAgentCommand() {
@@ -23,6 +25,7 @@ export function createAgentCommand() {
     addJsonAndDaemonHostOptions(addImportOptions(agent.command("import"))).action(withOutput(runImportCommand));
     addDaemonHostOption(addAttachOptions(agent.command("attach"))).action(runAttachCommand);
     addDaemonHostOption(addLogsOptions(agent.command("logs"))).action(runLogsCommand);
+    addJsonAndDaemonHostOptions(addOpenOptions(agent.command("open"))).action(withOutput(runOpenCommand));
     addJsonAndDaemonHostOptions(addStopOptions(agent.command("stop"))).action(withOutput(runStopCommand));
     addJsonAndDaemonHostOptions(addDeleteOptions(agent.command("delete"))).action(withOutput(runDeleteCommand));
     addJsonAndDaemonHostOptions(addSendOptions(agent.command("send"))).action(withOutput(runSendCommand));
@@ -37,11 +40,16 @@ 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")
+        .description("Update an agent's settings or metadata")
         .argument("<id>", "Agent ID (or prefix)")
         .option("--name <name>", "Update the agent's display name")
+        .option("--thinking <id>", "Update the agent's thinking option ID")
         .option("--label <label>", "Add/set label(s) on the agent (can be used multiple times or comma-separated)", collectMultiple, [])).action(withOutput(runUpdateCommand));
     return agent;
 }

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

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+interface OpenAgentResult {
+    agentId: string;
+    serverId: string;
+    status: "opened";
+}
+export declare function addOpenOptions(command: Command): Command;
+export declare function runOpenCommand(agentIdArg: string, options: CommandOptions, _command: Command): Promise<SingleResult<OpenAgentResult>>;
+export {};
+//# sourceMappingURL=open.d.ts.map

package/dist/commands/agent/open.js

@@ -0,0 +1,61 @@
+import { buildDaemonConnectionCommandError, connectToDaemon } from "../../utils/client.js";
+import { openDesktopWithAgent } from "../open.js";
+const openAgentSchema = {
+    idField: "agentId",
+    columns: [
+        { header: "AGENT ID", field: "agentId" },
+        { header: "SERVER ID", field: "serverId" },
+        { header: "STATUS", field: "status" },
+    ],
+};
+export function addOpenOptions(command) {
+    return command
+        .description("Open an existing agent in Otto Desktop")
+        .argument("<agent-id>", "Existing agent ID")
+        .option("--server <server-id>", "Server ID (defaults to the local daemon)");
+}
+async function resolveServerId(options) {
+    const explicitServerId = typeof options.server === "string" ? options.server.trim() : "";
+    if (explicitServerId) {
+        return explicitServerId;
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (error) {
+        throw buildDaemonConnectionCommandError({ host: options.host, error });
+    }
+    try {
+        const serverId = client.getLastServerInfoMessage()?.serverId.trim();
+        if (!serverId) {
+            const error = {
+                code: "SERVER_ID_UNAVAILABLE",
+                message: "The daemon did not report a server ID.",
+            };
+            throw error;
+        }
+        return serverId;
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+export async function runOpenCommand(agentIdArg, options, _command) {
+    const agentId = agentIdArg.trim();
+    if (!agentId) {
+        const error = {
+            code: "MISSING_AGENT_ID",
+            message: "Agent ID is required.",
+        };
+        throw error;
+    }
+    const serverId = await resolveServerId(options);
+    await openDesktopWithAgent({ serverId, agentId });
+    return {
+        type: "single",
+        data: { agentId, serverId, status: "opened" },
+        schema: openAgentSchema,
+    };
+}
+//# sourceMappingURL=open.js.map

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;
@@ -22,8 +23,15 @@ export interface AgentRunOptions extends CommandOptions {
     thinking?: string;
     mode?: string;
     personality?: string;
+    newWorkspace?: string;
     worktree?: string;
+    worktreeMode?: string;
+    worktreeSlug?: string;
+    newBranch?: string;
     base?: string;
+    branch?: string;
+    prNumber?: string;
+    forge?: string;
     workspace?: string;
     image?: string[];
     cwd?: string;
@@ -41,5 +49,32 @@ export declare function resolveStructuredResponseMessage(options: {
     agentId: string;
     lastMessage: string | null;
 }): Promise<string | null>;
+export declare function validateRunOptions(prompt: string, options: AgentRunOptions, outputSchema: unknown): void;
+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?: {
+    OTTO_AGENT_ID?: string;
+}): string | undefined;
 //# sourceMappingURL=run.d.ts.map

package/dist/commands/agent/run.js

@@ -7,28 +7,41 @@ import { lookup } from "mime-types";
 import { parseDuration } from "../../utils/duration.js";
 import { collectMultiple } from "../../utils/command-options.js";
 import { assertNoConflictingModelInputs, resolveProviderAndModel, } from "../../utils/provider-model.js";
+import { buildWorkspaceSource } from "../workspace/create.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)")
+        // Otto-only: personalities are a fork feature, so this option has no
+        // upstream counterpart. See docs/agent-personalities.md.
         .option("--personality <name>", "Spawn as a host personality (name or id): applies its provider/model/mode and identity/prompt. Explicit --provider/--model/--mode override.")
-        .option("--worktree <name>", "Create agent in a new git worktree")
-        .option("--base <branch>", "Base branch for worktree (default: current branch)")
-        .option("--workspace <id>", "Run in an existing workspace (default: a new workspace is created per run; falls back to $OTTO_WORKSPACE_ID)")
+        .option("--new-workspace <local|worktree>", "Create a separate local or worktree workspace")
+        .addOption(new Option("--worktree <name>", "Legacy workspace isolation alias").hideHelp())
+        .option("--worktree-mode <mode>", "Worktree mode: branch-off, checkout-branch, or checkout-pr")
+        .option("--worktree-slug <slug>", "Managed worktree path slug")
+        .option("--new-branch <name>", "New branch name for branch-off mode")
+        .option("--base <ref>", "Base ref for branch-off mode")
+        .option("--branch <name>", "Existing branch for checkout-branch mode")
+        .option("--pr-number <n>", "Pull request or change request number for checkout-pr mode")
+        .option("--forge <forge>", "Forge for checkout-pr mode")
+        .option("--workspace <id>", "Run in an existing workspace (defaults to the caller workspace when agent-scoped)")
         .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 = {
@@ -41,6 +54,23 @@ export const agentRunSchema = {
         { header: "TITLE", field: "title", width: 20 },
     ],
 };
+function resolveNewWorkspaceKind(options) {
+    return options.newWorkspace ?? (options.worktree ? "worktree" : undefined);
+}
+function buildRunWorkspaceSource(options, cwd) {
+    const newWorkspace = resolveNewWorkspaceKind(options) ?? "local";
+    return buildWorkspaceSource({
+        isolation: newWorkspace,
+        path: cwd,
+        mode: options.worktreeMode,
+        worktreeSlug: options.worktreeSlug ?? options.worktree,
+        newBranch: options.newBranch,
+        base: options.base,
+        branch: options.branch,
+        prNumber: options.prNumber,
+        forge: options.forge,
+    });
+}
 function toRunResult(agent, statusOverride) {
     return {
         agentId: agent.id,
@@ -209,47 +239,92 @@ function structuredRunSchema(output) {
         serialize: () => output,
     };
 }
-function validateRunOptions(prompt, options, outputSchema) {
-    // Before anything opens a socket: a contradictory command line should say so, not report that
-    // the daemon is unreachable. Full provider/model resolution still happens after connecting,
-    // because it needs the host.
-    assertNoConflictingModelInputs(options.provider, options.model);
-    if (!prompt || prompt.trim().length === 0) {
+function validateRunWorkspaceOptions(options) {
+    const newWorkspace = resolveNewWorkspaceKind(options);
+    if (options.newWorkspace &&
+        options.newWorkspace !== "local" &&
+        options.newWorkspace !== "worktree") {
         throw {
-            code: "MISSING_PROMPT",
-            message: "A prompt is required",
-            details: "Usage: otto agent run [options] <prompt>",
+            code: "INVALID_OPTIONS",
+            message: `Unsupported new workspace kind: ${options.newWorkspace}`,
+            details: "Use --new-workspace local or --new-workspace worktree",
+        };
+    }
+    if (options.newWorkspace && options.worktree) {
+        throw {
+            code: "INVALID_OPTIONS",
+            message: "--new-workspace and --worktree cannot be combined",
+            details: "Use --new-workspace worktree and the supported worktree options",
         };
     }
-    if (options.base && !options.worktree) {
+    const hasWorktreeCreationOptions = [
+        options.worktreeMode,
+        options.worktreeSlug,
+        options.newBranch,
+        options.base,
+        options.branch,
+        options.prNumber,
+        options.forge,
+    ].some((value) => value !== undefined);
+    if (hasWorktreeCreationOptions && newWorkspace !== "worktree") {
+        throw {
+            code: "INVALID_OPTIONS",
+            message: "Worktree options require --new-workspace worktree",
+            details: "Usage: otto run --new-workspace worktree [worktree options] <prompt>",
+        };
+    }
+    if (newWorkspace === "worktree") {
+        try {
+            buildRunWorkspaceSource(options, options.cwd ?? process.cwd());
+        }
+        catch (error) {
+            throw {
+                code: "INVALID_OPTIONS",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    if (options.newWorkspace && options.workspace) {
         throw {
             code: "INVALID_OPTIONS",
-            message: "--base can only be used with --worktree",
-            details: "Usage: otto agent run --worktree <name> --base <branch> <prompt>",
+            message: "--new-workspace and --workspace cannot be combined",
+            details: "Select an existing workspace or explicitly create a new one",
         };
     }
+    // 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: "--worktree and --workspace cannot be combined",
-            details: "--workspace runs in an existing workspace; --worktree mints a new one",
+            details: "Use --new-workspace worktree instead of the legacy --worktree flag",
         };
     }
-    if (options.worktree && !options.workspace && process.env.OTTO_WORKSPACE_ID) {
+}
+export function validateRunOptions(prompt, options, outputSchema) {
+    // Before anything opens a socket: a contradictory command line should say so, not report that
+    // the daemon is unreachable. Full provider/model resolution still happens after connecting,
+    // because it needs the host.
+    assertNoConflictingModelInputs(options.provider, options.model);
+    if (!prompt || prompt.trim().length === 0) {
         throw {
-            code: "INVALID_OPTIONS",
-            message: "--worktree cannot be combined with an ambient OTTO_WORKSPACE_ID",
-            details: "OTTO_WORKSPACE_ID selects an existing workspace; --worktree mints a new one. Unset OTTO_WORKSPACE_ID to use --worktree.",
+            code: "MISSING_PROMPT",
+            message: "A prompt is required",
+            details: "Usage: otto agent run [options] <prompt>",
         };
     }
-    if (outputSchema && options.detach) {
+    validateRunWorkspaceOptions(options);
+    if (outputSchema && runsInBackground(options)) {
         throw {
             code: "INVALID_OPTIONS",
-            message: "--output-schema cannot be used with --detach",
+            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;
@@ -338,36 +413,45 @@ 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 `otto run`. Precedence:
 //   1. --workspace <id>            -> run in that existing workspace
-//   2. $OTTO_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
-// $OTTO_WORKSPACE_ID (validateRunOptions), so worktree resolution here never
-// races an existing-workspace selection.
+//   2. $OTTO_AGENT_ID             -> daemon resolves the caller's workspace
+//   3. $OTTO_WORKSPACE_ID         -> exported by workspace terminals
+//   4. --new-workspace <kind>      -> mint a new workspace explicitly
+//   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
-    // OTTO_WORKSPACE_ID are both rejected alongside --worktree upstream.
-    const explicit = options.worktree
-        ? undefined
-        : options.workspace?.trim() || process.env.OTTO_WORKSPACE_ID?.trim();
+    const newWorkspace = resolveNewWorkspaceKind(options);
+    const explicit = newWorkspace ? undefined : options.workspace?.trim();
     if (explicit) {
         console.error(`Using workspace ${explicit}`);
-        return { id: explicit, cwd };
+        return resolveExistingRunWorkspace(client, explicit);
+    }
+    if (!newWorkspace && resolveRunCallerAgentId()) {
+        return { cwd };
+    }
+    const ambientWorkspaceId = newWorkspace ? undefined : process.env.OTTO_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
-        ? await client.createWorkspace({
-            source: {
-                kind: "worktree",
-                cwd,
-                worktreeSlug: options.worktree,
-                baseBranch: options.base,
-            },
-        })
-        : await client.createWorkspace({ source: { kind: "directory", path: cwd } });
+    const source = buildRunWorkspaceSource(options, cwd);
+    const result = await client.createWorkspace({ source });
     if (!result.workspace) {
         throw {
             code: "WORKSPACE_CREATE_FAILED",
@@ -388,6 +472,9 @@ export async function runRunCommand(prompt, options, _command) {
     const resolvedTitle = options.title ?? options.name;
     const client = await connectToDaemonOrThrow(options.host, host);
     try {
+        // --personality reads the host roster, so the brain can only be resolved
+        // once a client exists. validateRunOptions has already rejected a
+        // contradictory --provider/--model pair without needing one.
         const { providerModel: resolvedProviderModel, modeId: resolvedMode, personalityId, } = await resolveRunBrain(client, options);
         // Resolve working directory
         const cwd = options.cwd ?? process.cwd();
@@ -406,6 +493,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;
@@ -415,6 +503,7 @@ export async function runRunCommand(prompt, options, _command) {
                         provider: resolvedProviderModel.provider,
                         cwd: runCwd,
                         workspaceId,
+                        callerAgentId,
                         title: resolvedTitle,
                         modeId: resolvedMode,
                         model: resolvedProviderModel.model,
@@ -470,6 +559,7 @@ export async function runRunCommand(prompt, options, _command) {
             provider: resolvedProviderModel.provider,
             cwd: runCwd,
             workspaceId,
+            callerAgentId,
             title: resolvedTitle,
             modeId: resolvedMode,
             model: resolvedProviderModel.model,
@@ -480,8 +570,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;
@@ -512,4 +602,7 @@ export async function runRunCommand(prompt, options, _command) {
         throw error;
     }
 }
+export function resolveRunCallerAgentId(env = process.env) {
+    return env.OTTO_AGENT_ID?.trim() || undefined;
+}
 //# sourceMappingURL=run.js.map

package/dist/commands/agent/send.js

@@ -153,7 +153,7 @@ export async function runSendCommand(agentIdArg, prompt, options, _command) {
             images,
             ...(options.queue ? { delivery: "queue" } : {}),
         });
-        // A queued message has no run to wait for yet — it starts when the current
+        // A queued message has no run to wait for yet - it starts when the current
         // turn ends, so report it and return rather than blocking on --wait.
         if (dispatch.queued) {
             await client.close();