@otto-code/cli 0.7.5 → 0.8.0

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

@@ -0,0 +1,92 @@
+import { z } from "zod";
+const START_TIMEOUT_MS = 15000;
+const activationUrlSchema = z.url({ protocol: /^https?$/u });
+const authorizationSchema = z.object({
+    deviceCode: z.string().min(32),
+    userCode: z.string().min(1),
+    verificationUri: activationUrlSchema,
+    verificationUriComplete: activationUrlSchema,
+    expiresAt: z.string().datetime(),
+    interval: z.number().int().min(5),
+});
+const pollSchema = z.discriminatedUnion("status", [
+    z.object({ status: z.literal("pending"), interval: z.number().int().min(5) }),
+    z.object({ status: z.literal("slow_down"), interval: z.number().int().min(5) }),
+    z.object({
+        status: z.literal("approved"),
+        interval: z.number().int().min(5),
+        enrollmentToken: z.string().min(32),
+    }),
+    z.object({ status: z.literal("denied"), interval: z.number().int().min(5) }),
+    z.object({ status: z.literal("expired"), interval: z.number().int().min(5) }),
+    z.object({ status: z.literal("enrolled"), interval: z.number().int().min(5) }),
+    z.object({ status: z.literal("retry_later") }),
+]);
+export class CloudDeviceAuthorizationClient {
+    constructor(startTimeoutMilliseconds = START_TIMEOUT_MS) {
+        this.startTimeoutMilliseconds = startTimeoutMilliseconds;
+    }
+    async start(hubUrl, displayName) {
+        const signal = AbortSignal.timeout(this.startTimeoutMilliseconds);
+        try {
+            const response = await fetch(endpoint(hubUrl, "/api/device-authorizations/"), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ displayName }),
+                signal,
+            });
+            if (!response.ok)
+                throw new Error(`Cloud registration failed (${response.status})`);
+            return authorizationSchema.parse(await response.json());
+        }
+        catch (error) {
+            if (signal.aborted) {
+                throw new Error("Cloud registration start timed out", { cause: error });
+            }
+            throw error;
+        }
+    }
+    async poll(hubUrl, deviceCode, timeoutMilliseconds) {
+        const signal = AbortSignal.timeout(timeoutMilliseconds);
+        let response;
+        try {
+            response = await fetch(endpoint(hubUrl, "/api/device-authorizations/poll"), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ deviceCode }),
+                signal,
+            });
+        }
+        catch {
+            return { status: "retry_later" };
+        }
+        if ([408, 425, 429].includes(response.status) || response.status >= 500) {
+            return { status: "retry_later" };
+        }
+        if (!response.ok)
+            throw new Error(`Cloud registration poll failed (${response.status})`);
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch (error) {
+            if (signal.aborted || error instanceof TypeError)
+                return { status: "retry_later" };
+            throw error;
+        }
+        return pollSchema.parse(body);
+    }
+}
+function endpoint(hubUrl, pathname) {
+    const url = new URL(hubUrl);
+    if (!["http:", "https:"].includes(url.protocol) ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash) {
+        throw new Error("Hub URL must be an HTTP or HTTPS origin without credentials or a query");
+    }
+    url.pathname = `${url.pathname.replace(/\/$/u, "")}${pathname}`;
+    return url.toString();
+}
+//# sourceMappingURL=cloud-device-authorization.js.map

package/dist/commands/hub/device-authorization.d.ts

@@ -0,0 +1,37 @@
+import { type CloudDeviceAuthorization } from "./cloud-device-authorization.js";
+export interface AuthorizationWaiter {
+    wait(milliseconds: number): Promise<void>;
+    now(): number;
+}
+export interface BrowserOpener {
+    open(url: string): Promise<void>;
+}
+type BrowserLaunch = (command: string, args: string[]) => Promise<void>;
+interface SystemBrowserOptions {
+    hostPlatform?: NodeJS.Platform;
+    launch?: BrowserLaunch;
+}
+export declare class SystemBrowser implements BrowserOpener {
+    private readonly hostPlatform;
+    private readonly launch;
+    constructor(options?: SystemBrowserOptions);
+    open(url: string): Promise<void>;
+}
+export interface AuthorizationReporter {
+    instructions(verificationUri: string, userCode: string): void;
+}
+interface DeviceAuthorizationWorkflowOptions {
+    cloud: CloudDeviceAuthorization;
+    waiter: AuthorizationWaiter;
+    browser: BrowserOpener;
+    reporter: AuthorizationReporter;
+    openBrowser?: boolean;
+}
+export declare class DeviceAuthorizationWorkflow {
+    private readonly options;
+    constructor(options: DeviceAuthorizationWorkflowOptions);
+    authorize(hubUrl: string, displayName: string): Promise<string>;
+}
+export declare function createDeviceAuthorizationWorkflow(): DeviceAuthorizationWorkflow;
+export {};
+//# sourceMappingURL=device-authorization.d.ts.map

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/provider/ls.js

@@ -1,6 +1,6 @@
 import { AGENT_PROVIDER_DEFINITIONS } from "@otto-code/protocol/provider-manifest";
 import { tryConnectToDaemon } from "../../utils/client.js";
-/** Derive provider list from the manifest — single source of truth */
+/** Derive provider list from the manifest - single source of truth */
 const PROVIDERS = AGENT_PROVIDER_DEFINITIONS.map((def) => ({
     provider: def.id,
     label: def.label,

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;