<ParamField path="--model" type="string">

Model override; uses the selected allowed model for the job.

</ParamField>

<ParamField path="--clear-model" type="boolean">

On `cron edit`, removes the per-job model override so the job follows normal cron model-selection precedence (a stored cron-session override if set, otherwise the agent/default model). Cannot be combined with `--model`.

</ParamField>

<ParamField path="--thinking" type="string">

Thinking level override.

</ParamField>

- If the model is allowed, that exact provider/model reaches the isolated agent run.

- If it is not allowed or cannot be resolved, cron fails the run with an explicit validation error.

- API `cron.update` payload patches can set `model: null` to clear a stored job model override.

- `openclaw cron edit <job-id> --clear-model` clears that override from the CLI (same effect as the `model: null` patch) and cannot be combined with `--model`.

- Configured fallback chains still apply because cron `--model` is a job primary, not a session `/model` override.

- Payload `fallbacks` replaces configured fallbacks for that job; `fallbacks: []` disables fallback and makes the run strict.

- A plain `--model` with no explicit or configured fallback list does not fall through to the agent primary as a silent extra retry target.

## Models

`cron add|edit --model <ref>` selects an allowed model for the job.

`cron add|edit --model <ref>` selects an allowed model for the job. `cron edit <job-id> --clear-model` removes the per-job model override so the job follows normal cron model-selection precedence (a stored cron-session override if present, otherwise the agent/default model); it cannot be combined with `--model`.

<Warning>

If the model is not allowed or cannot be resolved, cron fails the run with an explicit validation error instead of falling back to the job's agent or default model selection.

},

);

});

it("clears the model override with --clear-model (CLI parity with cron.update model:null)", async () => {

const program = createCronProgram();

await program.parseAsync(["edit", "job-1", "--clear-model"], { from: "user" });

expect(callGatewayFromCli).toHaveBeenCalledWith(

"cron.update",

expect.objectContaining({ clearModel: true }),

{

id: "job-1",

patch: {

payload: {

kind: "agentTurn",

model: null,

},

},

},

);

});

it("documents the --clear-model flag alongside the sibling --clear-tools", () => {

const editCommand = createCronProgram().commands.find((command) => command.name() === "edit");

const help = editCommand?.helpInformation() ?? "";

expect(help).toContain("--clear-model");

expect(help).toContain("--clear-tools");

});

});

"Thinking level for agent jobs (off|minimal|low|medium|high|xhigh)",

)

.option("--model <model>", "Model override for agent jobs")

.option(

"--clear-model",

"Remove the per-job model override (restore normal cron model precedence)",

false,

)

.option("--timeout-seconds <n>", "Timeout seconds for agent or command jobs")

.option("--no-output-timeout-seconds <n>", "No-output timeout seconds for command jobs")

.option("--output-max-bytes <n>", "Maximum captured stdout/stderr bytes for command jobs")

);

}

const model = normalizeOptionalString(opts.model);

if (model && opts.clearModel) {

throw new Error("Use --model or --clear-model, not both");

}

const thinking = normalizeOptionalString(opts.thinking);

const toolsAllow = parseCronToolsAllow(opts.tools);

const rawTimeoutSeconds =

const hasAgentTurnPayloadField =

typeof opts.message === "string" ||

Boolean(model) ||

Boolean(opts.clearModel) ||

Boolean(thinking) ||

(hasTimeoutSeconds &&

!hasCommandSpecificPayloadField &&

} else if (hasAgentTurnPatch) {

const payload: Record<string, unknown> = { kind: "agentTurn" };

assignIf(payload, "message", String(opts.message), typeof opts.message === "string");

assignIf(payload, "model", model, Boolean(model));

if (opts.clearModel) {

payload.model = null;

} else {

assignIf(payload, "model", model, Boolean(model));

}

assignIf(payload, "thinking", thinking, Boolean(thinking));

assignIf(payload, "timeoutSeconds", timeoutSeconds, hasTimeoutSeconds);

assignIf(