@otto-code/cli 0.7.4 → 0.7.6

package/dist/commands/hub/device-authorization.js

@@ -0,0 +1,87 @@
+import { spawn } from "node:child_process";
+import { platform } from "node:os";
+import { CloudDeviceAuthorizationClient, } from "./cloud-device-authorization.js";
+export class SystemBrowser {
+    constructor(options = {}) {
+        this.hostPlatform = options.hostPlatform ?? platform();
+        this.launch = options.launch ?? launchDetached;
+    }
+    async open(url) {
+        if (this.hostPlatform === "win32") {
+            await this.launch("rundll32.exe", ["url.dll,FileProtocolHandler", url]);
+            return;
+        }
+        await this.launch(this.hostPlatform === "darwin" ? "open" : "xdg-open", [url]);
+    }
+}
+export class DeviceAuthorizationWorkflow {
+    constructor(options) {
+        this.options = options;
+    }
+    async authorize(hubUrl, displayName) {
+        const authorization = await this.options.cloud.start(hubUrl, displayName);
+        this.options.reporter.instructions(authorization.verificationUri, authorization.userCode);
+        if (this.options.openBrowser !== false) {
+            await this.options.browser.open(authorization.verificationUriComplete).catch(() => undefined);
+        }
+        let interval = authorization.interval;
+        const expiresAt = Date.parse(authorization.expiresAt);
+        while (true) {
+            const remaining = expiresAt - this.options.waiter.now();
+            if (remaining <= 0)
+                throw new Error("Daemon registration expired");
+            await this.options.waiter.wait(Math.min(interval * 1000, remaining));
+            if (this.options.waiter.now() >= expiresAt)
+                throw new Error("Daemon registration expired");
+            const pollLifetime = expiresAt - this.options.waiter.now();
+            if (pollLifetime <= 0)
+                throw new Error("Daemon registration expired");
+            const outcome = await this.options.cloud.poll(hubUrl, authorization.deviceCode, pollLifetime);
+            if (this.options.waiter.now() >= expiresAt)
+                throw new Error("Daemon registration expired");
+            if (outcome.status === "retry_later")
+                continue;
+            interval = outcome.interval;
+            if (outcome.status === "approved")
+                return outcome.enrollmentToken;
+            if (outcome.status === "denied")
+                throw new Error("Daemon registration was denied");
+            if (outcome.status === "expired")
+                throw new Error("Daemon registration expired");
+            if (outcome.status === "enrolled") {
+                throw new Error("Daemon registration was already used");
+            }
+        }
+    }
+}
+export function createDeviceAuthorizationWorkflow() {
+    return new DeviceAuthorizationWorkflow({
+        cloud: new CloudDeviceAuthorizationClient(),
+        waiter: {
+            wait: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+            now: Date.now,
+        },
+        browser: new SystemBrowser(),
+        reporter: {
+            instructions(verificationUri, userCode) {
+                process.stderr.write(`Open ${verificationUri} and enter code ${userCode}\n`);
+            },
+        },
+        openBrowser: process.stderr.isTTY === true,
+    });
+}
+async function launchDetached(command, args) {
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            detached: true,
+            shell: false,
+            stdio: "ignore",
+        });
+        child.once("spawn", () => {
+            child.unref();
+            resolve();
+        });
+        child.once("error", reject);
+    });
+}
+//# sourceMappingURL=device-authorization.js.map

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

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+interface HubCommandClient {
+    connectHub(url: string, token: string): Promise<{
+        status: HubStatus;
+    }>;
+    getHubStatus(): Promise<{
+        status: HubStatus;
+    }>;
+    disconnectHub(force: boolean): Promise<{
+        status: HubStatus;
+        warning?: string;
+    }>;
+    close(): Promise<void>;
+}
+interface HubStatus {
+    state: string;
+    daemonId: string | null;
+    hubOrigin: string | null;
+    scopes: string[];
+    connectedAt: string | null;
+    lastError: string | null;
+}
+interface HubCommandEnvironment {
+    connect(host: string | undefined): Promise<HubCommandClient>;
+    authorize(url: string, displayName: string): Promise<string>;
+    displayName(): string;
+}
+export declare function createHubCommand(environment?: HubCommandEnvironment): Command;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/hub/index.js

@@ -0,0 +1,85 @@
+import { Command } from "commander";
+import { hostname } from "node:os";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { connectToDaemon } from "../../utils/client.js";
+import { createDeviceAuthorizationWorkflow } from "./device-authorization.js";
+const productionEnvironment = {
+    connect: (host) => connectToDaemon({ host }),
+    authorize: (url, displayName) => createDeviceAuthorizationWorkflow().authorize(url, displayName),
+    displayName: hostname,
+};
+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(environment, host, action) {
+    const client = await environment.connect(host);
+    try {
+        return await action(client);
+    }
+    finally {
+        await client.close().catch(() => undefined);
+    }
+}
+export function createHubCommand(environment = productionEnvironment) {
+    const hub = new Command("hub").description("Manage this daemon's Otto Hub relationship");
+    addJsonAndDaemonHostOptions(hub.command("connect").argument("<url>").option("--token <token>")).action(withOutput(async (...args) => {
+        const url = args[0];
+        const options = args.at(-2);
+        return withClient(environment, options.host, async (client) => {
+            if (options.token !== undefined) {
+                return result((await client.connectHub(url, options.token)).status);
+            }
+            const existing = (await client.getHubStatus()).status;
+            if (existing.state !== "not_connected" && existing.state !== "revoked") {
+                throw new Error("This daemon already has a Hub relationship");
+            }
+            const token = await environment.authorize(url, suggestedDisplayName(environment.displayName()));
+            return result((await client.connectHub(url, token)).status);
+        });
+    }));
+    addJsonAndDaemonHostOptions(hub.command("status")).action(withOutput(async (...args) => {
+        const options = args.at(-2);
+        return withClient(environment, 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(environment, options.host, async (client) => {
+            const response = await client.disconnectHub(options.force ?? false);
+            return result(response.status, response.warning);
+        });
+    }));
+    return hub;
+}
+function suggestedDisplayName(value) {
+    return value.trim().slice(0, 100) || "Otto daemon";
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/hub-disabled.d.ts

@@ -0,0 +1,22 @@
+/**
+ * DISABLED(hub): CLI half of the Hub switch.
+ *
+ * `packages/server/src/server/hub-disabled.ts` carries the full rationale. The
+ * short version: Hub is a documented permanent exclusion that landed anyway in
+ * the Paseo v0.2.5 merge, and we turn it off by redirecting import specifiers
+ * rather than deleting wiring, so upstream's edits to the call sites keep
+ * auto-merging.
+ *
+ * `cli.ts` still calls `createHubCommand()` on a byte-identical line. It just
+ * resolves here instead of `./commands/hub/index.js`, which keeps that whole
+ * subtree, and the daemon client calls it makes, out of the CLI's module graph.
+ *
+ * The command stays registered, carries "(disabled in this build)" in its own
+ * description, and answers every invocation with one honest sentence. That
+ * beats removing it outright: `otto hub connect` explains itself instead of
+ * dying on "unknown command". Hiding it from `--help` would need an option on
+ * `addCommand`, and that call site is deliberately left untouched.
+ */
+import { Command } from "commander";
+export declare function createHubCommand(_environment?: unknown): Command;
+//# sourceMappingURL=hub-disabled.d.ts.map

package/dist/commands/hub-disabled.js

@@ -0,0 +1,34 @@
+/**
+ * DISABLED(hub): CLI half of the Hub switch.
+ *
+ * `packages/server/src/server/hub-disabled.ts` carries the full rationale. The
+ * short version: Hub is a documented permanent exclusion that landed anyway in
+ * the Paseo v0.2.5 merge, and we turn it off by redirecting import specifiers
+ * rather than deleting wiring, so upstream's edits to the call sites keep
+ * auto-merging.
+ *
+ * `cli.ts` still calls `createHubCommand()` on a byte-identical line. It just
+ * resolves here instead of `./commands/hub/index.js`, which keeps that whole
+ * subtree, and the daemon client calls it makes, out of the CLI's module graph.
+ *
+ * The command stays registered, carries "(disabled in this build)" in its own
+ * description, and answers every invocation with one honest sentence. That
+ * beats removing it outright: `otto hub connect` explains itself instead of
+ * dying on "unknown command". Hiding it from `--help` would need an option on
+ * `addCommand`, and that call site is deliberately left untouched.
+ */
+import { Command } from "commander";
+const HUB_DISABLED_MESSAGE = "Otto Hub is disabled in this build. See docs/upstream-merges.md.";
+export function createHubCommand(_environment) {
+    return new Command("hub")
+        .description("Manage this daemon's Otto Hub relationship (disabled in this build)")
+        .addHelpText("after", `\n${HUB_DISABLED_MESSAGE}`)
+        .allowUnknownOption()
+        .allowExcessArguments()
+        .argument("[command...]", "Hub subcommand")
+        .action(() => {
+        process.stderr.write(`${HUB_DISABLED_MESSAGE}\n`);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=hub-disabled.js.map

package/dist/commands/onboard.js

@@ -5,6 +5,7 @@ import path from "node:path";
 import { generateLocalPairingOffer, loadConfig, loadPersistedConfig, } from "@otto-code/server";
 import { resolveLocalOttoHome, resolveLocalDaemonState, resolveTcpHostFromListen, startLocalDaemonDetached, tailDaemonLog, } from "./daemon/local-daemon.js";
 import { tryConnectToDaemon } from "../utils/client.js";
+import { formatPairingInstructions } from "../output/pairing.js";
 const DEFAULT_READY_TIMEOUT_MS = 10 * 60 * 1000;
 const READY_PROBE_TIMEOUT_MS = 1200;
 class OnboardCancelledError extends Error {
@@ -406,8 +407,11 @@ export async function runOnboard(options) {
         }
         return;
     }
-    renderNote(pairing.qr ?? "QR is unavailable in this terminal. Use the pairing link below.", "Scan to pair");
-    renderNote(pairing.url, "Pairing link");
+    process.stdout.write(formatPairingInstructions({
+        url: pairing.url,
+        qr: pairing.qr,
+        columns: process.stdout.columns,
+    }));
     printNextSteps(pairing.url, ottoHome, richUi);
     if (richUi) {
         outro("Otto is ready!");

package/dist/commands/open.d.ts

@@ -1,2 +1,4 @@
+import { type AgentDeepLinkTarget } from "@otto-code/protocol/agent-deep-link";
 export declare function openDesktopWithProject(projectPath: string): Promise<void>;
+export declare function openDesktopWithAgent(target: AgentDeepLinkTarget): Promise<void>;
 //# sourceMappingURL=open.d.ts.map

package/dist/commands/open.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
 import { spawnProcess } from "@otto-code/server";
+import { buildAgentDeepLink } from "@otto-code/protocol/agent-deep-link";
 function findDesktopApp() {
     if (process.platform === "darwin") {
         const candidates = ["/Applications/Otto.app", path.join(homedir(), "Applications", "Otto.app")];
@@ -52,25 +53,26 @@ function spawnDetached(command, args) {
         env: cleanEnvForDesktopLaunch(),
     }).unref();
 }
+function launchDesktop(args) {
+    if (process.env.OTTO_DESKTOP_CLI === "1") {
+        throw new Error("Cannot open Otto Desktop while running in desktop CLI passthrough mode.");
+    }
+    const desktopApp = findDesktopApp();
+    if (!desktopApp) {
+        throw new Error("Otto desktop app not found. Install it from https://github.com/Draek2077/otto-code/releases");
+    }
+    if (process.platform === "darwin") {
+        // -n forces a new instance even if the app is already running. The new
+        // instance relays its argv to the existing one through Electron's
+        // single-instance lock. -g keeps the terminal in the foreground.
+        spawnDetached("open", ["-n", "-g", "-a", desktopApp, "--args", ...args]);
+        return;
+    }
+    spawnDetached(desktopApp, args);
+}
 export async function openDesktopWithProject(projectPath) {
     try {
-        if (process.env.OTTO_DESKTOP_CLI === "1") {
-            throw new Error("Cannot open a desktop project while running in desktop CLI passthrough mode.");
-        }
-        const desktopApp = findDesktopApp();
-        if (!desktopApp) {
-            throw new Error("Otto desktop app not found. Install it from https://github.com/Draek2077/otto-code/releases");
-        }
-        if (process.platform === "darwin") {
-            // -n forces a new instance even if the app is already running.
-            // The new instance hits requestSingleInstanceLock(), fails, and relays
-            // the argv to the first instance via the second-instance event.
-            // -g keeps the terminal in the foreground (better CLI UX).
-            // Without -n, macOS just activates the existing window and drops --args.
-            spawnDetached("open", ["-n", "-g", "-a", desktopApp, "--args", projectPath]);
-            return;
-        }
-        spawnDetached(desktopApp, [projectPath]);
+        launchDesktop([projectPath]);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -78,4 +80,7 @@ export async function openDesktopWithProject(projectPath) {
         process.exitCode = 1;
     }
 }
+export async function openDesktopWithAgent(target) {
+    launchDesktop([buildAgentDeepLink(target)]);
+}
 //# sourceMappingURL=open.js.map

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

@@ -9,6 +9,7 @@ export interface ScheduleCreateOptions extends ScheduleCommandOptions {
     target?: string;
     provider?: string;
     mode?: string;
+    thinking?: string;
     cwd?: string;
     maxRuns?: string;
     expiresIn?: string;

package/dist/commands/schedule/create.js

@@ -12,6 +12,7 @@ export async function runCreateCommand(prompt, options, command) {
         target: options.target,
         provider: options.provider,
         mode: options.mode,
+        thinking: options.thinking,
         cwd: options.cwd,
         host: options.host,
         maxRuns: options.maxRuns,

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,16 @@ 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("--thinking <id>", "Thinking option ID for new-agent runs")
         .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 +48,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;
@@ -20,6 +21,7 @@ export declare function parseScheduleCreateInput(options: {
     target?: string;
     provider?: string;
     mode?: string;
+    thinking?: string;
     cwd?: string;
     host?: string;
     maxRuns?: string;
@@ -43,6 +45,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 "@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