A self-improving RLM agent for coding workflows and long-running autonomous tasks.
Rust
feat(coding-agent): accept autonomous budget flags from the /autonomous command (#2206)
Seth Karten27daf22125a1
diff --git a/packages/coding-agent/.changes/autonomous-slash-command-budget.md b/packages/coding-agent/.changes/autonomous-slash-command-budget.mdnew file mode 100644index 0000000000..cf479bc4ed--- /dev/null+++ b/packages/coding-agent/.changes/autonomous-slash-command-budget.md@@ -0,0 +1 @@+- `/autonomous on` now accepts the same budget flags as the `--autonomous-*` CLI options (`--max-continuations`, `--max-turns`, `--max-tokens`, `--timeout-ms`, `--gate`, `--gate-retries`, `--gate-timeout-ms`), so interactive runs use a user-defined budget instead of always stopping after the default three continuations. The CLI spellings work as aliases and quoted gate commands are supported. Numeric values accept `,`/`_` digit separators, and the four budget limits accept `unlimited` to remove that cap. Named budget flags define the whole budget: unnamed limits become unlimited, so `/autonomous on --max-tokens 100,000` is bounded only by that token budget (plus gates); with no budget flags, the configured or default limits still apply. The status text now reports the time budget, configured gates, unlimited limits, and comma-grouped numbers.diff --git a/packages/coding-agent/docs/long-running-agents.md b/packages/coding-agent/docs/long-running-agents.mdindex db12b639b6..edd115f0fd 100644--- a/packages/coding-agent/docs/long-running-agents.md+++ b/packages/coding-agent/docs/long-running-agents.md@@ -200,10 +200,13 @@ Goal state records token usage, elapsed time, continuation count, and an optionaAutonomous mode is a bounded host policy for runs where no human input is expected. Prime Agent adds follow-up continuations until configured quality gates pass or a continuation, turn, token, or wall-clock limit is reached.-Enable it in an interactive session:+Enable it in an interactive session. `/autonomous on` accepts the same budget+options as the CLI, so an interactive run can define its own budget instead of+stopping at the default three continuations:```text-/autonomous on+/autonomous on --max-continuations 10 --max-turns 40 --max-tokens 500000+/autonomous on --gate "npm run check" --gate-retries 2/autonomous status/autonomous off```@@ -218,6 +221,18 @@ prime-agent \"Implement and verify the requested change"```+The slash-command flags (`--max-continuations`, `--max-turns`, `--max-tokens`,+`--timeout-ms`, `--gate`, `--gate-retries`, `--gate-timeout-ms`) accept both+`--flag <value>` and `--flag=<value>`, and the full CLI spellings such as+`--autonomous-max-continuations` work as aliases. Numeric values may use `,`+or `_` as digit separators (`--max-tokens 100,000,000,000`). The four budget+limits also accept `unlimited` to remove that cap; without gates, an unlimited+run only stops on an error or a manual abort, so pair unlimited budgets with a+quality gate. Named budget flags define the whole budget: any limit you do+not name becomes unlimited, so `/autonomous on --max-tokens 100,000` runs+until that token budget is spent. With no budget flags at all, the configured+or default limits still apply. Repeating `--gate` appends another gate.+Autonomous mode supports limits for continuations, assistant turns, tokens, and wall-clock duration. Gate commands run before the session may finish; a failed gate returns its bounded output to the agent for another attempt. Prime Agent avoids rerunning the same failed gate when the workspace has not changed.Goals and autonomous mode are complementary but different:diff --git a/packages/coding-agent/docs/usage.md b/packages/coding-agent/docs/usage.mdindex c8d3ad0e79..e9eb8b97a4 100644--- a/packages/coding-agent/docs/usage.md+++ b/packages/coding-agent/docs/usage.md@@ -259,6 +259,8 @@ prime-agent --no-extensions -e ./my-extension.tsAutonomous mode is a host policy for unattended work. It starts disabled. `--autonomous` enables it, and supplying any `--autonomous-*` sub-option also enables it. The host starts each enabled run with fresh continuation, turn, token, and elapsed-time counters.+Interactive sessions set the same budget from the `/autonomous` slash command: `/autonomous on` accepts every budget option above using the flag name without the `--autonomous-` prefix (`--max-continuations`, `--max-turns`, `--max-tokens`, `--timeout-ms`, `--gate`, `--gate-retries`, `--gate-timeout-ms`), plus the full CLI spellings as aliases. For example, `/autonomous on --max-continuations 10 --gate "npm run check"` enables a ten-continuation run instead of the default three. Values follow the same positive-integer rules, may use `--flag=<value>` or `--flag <value>`, and accept `,` or `_` as digit separators, so `--max-tokens 100,000,000,000` and `--max-tokens 100_000_000_000` both work. The four budget limits also accept `unlimited` to remove that cap. Named budget flags define the whole budget: any limit you do not name becomes unlimited, so only the flags you pass (plus gates) decide when the run stops — for example, `/autonomous on --max-tokens 100,000` runs until that token budget is spent. With no budget flags at all, the configured or default limits still apply. A run with every budget limit unlimited and no gates has no automatic stopping point, so pair it with a gate or an explicit large budget.+| Option | Behavior, units, and default ||--------|------------------------------|| `--autonomous` | Enable autonomous continuations. With no gates, the host keeps requesting work until a limit prevents another continuation. |diff --git a/packages/coding-agent/src/core/agent-session.ts b/packages/coding-agent/src/core/agent-session.tsindex a21ad98d7c..431c108378 100644--- a/packages/coding-agent/src/core/agent-session.ts+++ b/packages/coding-agent/src/core/agent-session.ts@@ -87,9 +87,12 @@ import {addAutonomousUsage,autonomousStatus,createAutonomousRuntimeState,+ isUnlimitedAutonomousLimit,nextAutonomousContinuation,refreshAutonomousQualityGates,setAutonomousEnabled,+ setAutonomousLimits,+ UNLIMITED_AUTONOMOUS_LIMIT,} from "./autonomous.js";import { type BashResult, executeBashWithOperations } from "./bash-executor.js";import {@@ -195,7 +198,7 @@ import {} from "./messages.js";import type { ModelRegistry } from "./model-registry.js";import { throwIfPromptAdmissionCancelled } from "./prompt-admission.js";-import { expandPromptTemplate, type PromptTemplate } from "./prompt-templates.js";+import { expandPromptTemplate, type PromptTemplate, parseCommandArgs } from "./prompt-templates.js";import {isAgentLifecycleFailure,isFauxProviderQueueExhausted,@@ -919,7 +922,7 @@ type GoalSlashCommand =| { kind: "resume" }| { kind: "start"; objective: string; tokenBudget?: number };-type AutonomousSlashCommand = { kind: "status" } | { kind: "on" } | { kind: "off" };+type AutonomousSlashCommand = { kind: "status" } | { kind: "on"; config?: AgentAutonomousConfig } | { kind: "off" };import type { RlmMaxDepthSource, RlmMaxDepthStatus, SetRlmMaxDepthResult } from "./rlm-max-depth.js";@@ -1034,6 +1037,111 @@ function parseGoalBudgetValue(value: string): number {return budget;}+const AUTONOMOUS_STATUS_NUMBER_FORMAT = new Intl.NumberFormat("en-US");++const AUTONOMOUS_BUDGET_USAGE =+ "Usage: /autonomous [status|off] or /autonomous on [--max-continuations <n|unlimited>] [--max-turns <n|unlimited>] [--max-tokens <n|unlimited>] [--timeout-ms <n|unlimited>] [--gate <command>] [--gate-retries <n>] [--gate-timeout-ms <n>]";++// `/autonomous` budget flags mirror the `--autonomous-*` CLI options. The CLI+// spelling (`--autonomous-max-continuations`) is accepted as an alias so the+// exact CLI budget flags also work from the slash command.+const AUTONOMOUS_BUDGET_FLAGS: ReadonlySet<string> = new Set([+ "max-continuations",+ "max-turns",+ "max-tokens",+ "timeout-ms",+ "gate",+ "gate-retries",+ "gate-timeout-ms",+]);++function parseAutonomousBudgetInt(flag: string, value: string, allowUnlimited = false): number {+ if (allowUnlimited && value.toLowerCase() === "unlimited") {+ return UNLIMITED_AUTONOMOUS_LIMIT;+ }+ // Commas and underscores are accepted as digit separators (100,000,000).+ const digits = value.replace(/[,_]/g, "");+ if (!/^[1-9]\d*$/.test(digits)) {+ throw new Error(+ `--${flag} must be a positive integer${allowUnlimited ? ' or "unlimited"' : ""}. ${AUTONOMOUS_BUDGET_USAGE}`,+ );+ }+ return Number(digits);+}++function parseAutonomousBudgetOptions(tokens: string[]): AgentAutonomousConfig {+ const config: AgentAutonomousConfig = {};+ const gateCommands: string[] = [];+ for (let i = 0; i < tokens.length; i++) {+ const token = tokens[i]!;+ if (!token.startsWith("--")) {+ throw new Error(`Unexpected autonomous argument: ${token}. ${AUTONOMOUS_BUDGET_USAGE}`);+ }+ const equalsIndex = token.indexOf("=");+ const rawFlag = equalsIndex === -1 ? token : token.slice(0, equalsIndex);+ const inlineValue = equalsIndex === -1 ? undefined : token.slice(equalsIndex + 1);+ const flag = rawFlag.startsWith("--autonomous-") ? rawFlag.slice("--autonomous-".length) : rawFlag.slice(2);+ if (!AUTONOMOUS_BUDGET_FLAGS.has(flag)) {+ throw new Error(`Unknown autonomous budget flag: ${rawFlag}. ${AUTONOMOUS_BUDGET_USAGE}`);+ }+ let value = inlineValue;+ if (value === undefined) {+ const next = tokens[i + 1];+ if (next === undefined || next.startsWith("--")) {+ throw new Error(`Missing value for ${rawFlag}. ${AUTONOMOUS_BUDGET_USAGE}`);+ }+ value = next;+ i++;+ }+ if (value === "") {+ throw new Error(`Missing value for ${rawFlag}. ${AUTONOMOUS_BUDGET_USAGE}`);+ }+ switch (flag) {+ case "gate":+ gateCommands.push(value);+ break;+ case "gate-retries":+ config.gates = config.gates ?? {};+ config.gates.maxRetries = parseAutonomousBudgetInt(flag, value);+ break;+ case "gate-timeout-ms":+ config.gates = config.gates ?? {};+ config.gates.timeoutMs = parseAutonomousBudgetInt(flag, value);+ break;+ case "max-continuations":+ config.maxContinuations = parseAutonomousBudgetInt(flag, value, true);+ break;+ case "max-turns":+ config.maxTurns = parseAutonomousBudgetInt(flag, value, true);+ break;+ case "max-tokens":+ config.maxTokens = parseAutonomousBudgetInt(flag, value, true);+ break;+ case "timeout-ms":+ config.timeoutMs = parseAutonomousBudgetInt(flag, value, true);+ break;+ }+ }+ if (gateCommands.length > 0) {+ config.gates = { ...config.gates, commands: gateCommands };+ }+ // Named budget flags define the whole budget: any limit the user did not+ // name stops cutting the run short. With no budget flags at all, the+ // configured or default limits still apply.+ if (+ config.maxContinuations !== undefined ||+ config.maxTurns !== undefined ||+ config.maxTokens !== undefined ||+ config.timeoutMs !== undefined+ ) {+ config.maxContinuations ??= UNLIMITED_AUTONOMOUS_LIMIT;+ config.maxTurns ??= UNLIMITED_AUTONOMOUS_LIMIT;+ config.maxTokens ??= UNLIMITED_AUTONOMOUS_LIMIT;+ config.timeoutMs ??= UNLIMITED_AUTONOMOUS_LIMIT;+ }+ return config;+}+export function compactRlmText(text: string, maxLength = 160): string {const compact = text.replace(/\s+/g, " ").trim();if (compact.length <= maxLength) {@@ -2090,23 +2198,38 @@ export class AgentSession {private _parseAutonomousSlashCommand(text: string): AutonomousSlashCommand | undefined {const command = parseSessionSlashCommand(text);if (command?.name !== "autonomous") return undefined;- const rest = command.args.toLowerCase();- if (!rest || rest === "status") {+ const tokens = parseCommandArgs(command.args);+ if (tokens.length === 0 || tokens[0]!.toLowerCase() === "status") {+ if (tokens.length > 1) {+ throw new Error(`Unexpected autonomous argument: ${tokens[1]}. ${AUTONOMOUS_BUDGET_USAGE}`);+ }return { kind: "status" };}- if (rest === "on" || rest === "enable" || rest === "enabled") {- return { kind: "on" };+ const subcommand = tokens[0]!.toLowerCase();+ if (subcommand === "on" || subcommand === "enable" || subcommand === "enabled") {+ return { kind: "on", config: parseAutonomousBudgetOptions(tokens.slice(1)) };}- if (rest === "off" || rest === "disable" || rest === "disabled") {+ if (subcommand === "off" || subcommand === "disable" || subcommand === "disabled") {+ if (tokens.length > 1) {+ throw new Error(`Unexpected autonomous argument: ${tokens[1]}. ${AUTONOMOUS_BUDGET_USAGE}`);+ }return { kind: "off" };}- throw new Error("Usage: /autonomous [on|off|status]");+ throw new Error(AUTONOMOUS_BUDGET_USAGE);}private _formatAutonomousStatus(): string {const status = this.getAutonomousStatus();const state = status.enabled ? "on" : "off";- return `[autonomous-status: ${state}]\n\nContinuations: ${status.continuationsUsed}/${status.limits.maxContinuations}. Turns: ${status.turnsUsed}/${status.limits.maxTurns}. Tokens: ${status.tokensUsed}/${status.limits.maxTokens}.`;+ const elapsedSeconds = status.startedAt ? Math.round((Date.now() - status.startedAt) / 1000) : 0;+ const gateSummary =+ status.gates.commands.length > 0 ? status.gates.commands.map((command) => `"${command}"`).join(", ") : "none";+ const formatCount = (value: number): string =>+ isUnlimitedAutonomousLimit(value) ? "unlimited" : AUTONOMOUS_STATUS_NUMBER_FORMAT.format(value);+ const timeBudget = isUnlimitedAutonomousLimit(status.limits.timeoutMs)+ ? "unlimited"+ : `${AUTONOMOUS_STATUS_NUMBER_FORMAT.format(Math.round(status.limits.timeoutMs / 1000))}s`;+ return `[autonomous-status: ${state}]\n\nContinuations: ${formatCount(status.continuationsUsed)}/${formatCount(status.limits.maxContinuations)}. Turns: ${formatCount(status.turnsUsed)}/${formatCount(status.limits.maxTurns)}. Tokens: ${formatCount(status.tokensUsed)}/${formatCount(status.limits.maxTokens)}. Time: ${elapsedSeconds}s/${timeBudget}. Gates: ${gateSummary}.`;}private _emitAutonomousStatus(): void {@@ -2136,6 +2259,7 @@ export class AgentSession {}if (command.kind === "on") {setAutonomousEnabled(this._autonomousState, true, { cwd: this._cwd });+ setAutonomousLimits(this._autonomousState, command.config);} else if (command.kind === "off") {setAutonomousEnabled(this._autonomousState, false);this._clearQueuedAutonomousContinuations();diff --git a/packages/coding-agent/src/core/autonomous.ts b/packages/coding-agent/src/core/autonomous.tsindex 8b47246fe2..c5efd36063 100644--- a/packages/coding-agent/src/core/autonomous.ts+++ b/packages/coding-agent/src/core/autonomous.ts@@ -59,6 +59,17 @@ export const DEFAULT_AUTONOMOUS_GATES: Required<AgentAutonomousGateConfig> = {timeoutMs: 5 * 60 * 1000,};+/**+ * JSON-safe sentinel meaning "no cap". Limit checks compare usage against the+ * configured value, so this stays finite and serializes to JSON while no+ * realistic run can ever reach it.+ */+export const UNLIMITED_AUTONOMOUS_LIMIT = Number.MAX_SAFE_INTEGER;++export function isUnlimitedAutonomousLimit(value: number): boolean {+ return value >= UNLIMITED_AUTONOMOUS_LIMIT;+}+const MAX_GATE_OUTPUT_CHARS = 6000;const MAX_CHILD_PROCESS_OUTPUT_CHARS = 1024 * 1024;@@ -153,6 +164,31 @@ export function setAutonomousEnabled(}}+/**+ * Apply user-provided budget and gate options to a live runtime state.+ * Only fields present in `config` change; unspecified fields keep the state's+ * current values, which come from the session/CLI configuration or defaults.+ */+export function setAutonomousLimits(state: AutonomousRuntimeState, config?: AgentAutonomousConfig): void {+ if (!config) {+ return;+ }+ state.limits.maxContinuations = normalizeLimit(config.maxContinuations, state.limits.maxContinuations);+ state.limits.maxTurns = normalizeLimit(config.maxTurns, state.limits.maxTurns);+ state.limits.maxTokens = normalizeLimit(config.maxTokens, state.limits.maxTokens);+ state.limits.timeoutMs = normalizeLimit(config.timeoutMs, state.limits.timeoutMs);+ if (config.continuationPrompt?.trim()) {+ state.continuationPrompt = config.continuationPrompt.trim();+ }+ if (config.gates) {+ if (config.gates.commands !== undefined) {+ state.gates.commands = [...config.gates.commands];+ }+ state.gates.maxRetries = normalizeLimit(config.gates.maxRetries, state.gates.maxRetries);+ state.gates.timeoutMs = normalizeLimit(config.gates.timeoutMs, state.gates.timeoutMs);+ }+}+export function autonomousStatus(state: AutonomousRuntimeState): AgentAutonomousStatus {return {enabled: state.enabled,diff --git a/packages/coding-agent/src/core/slash-commands.ts b/packages/coding-agent/src/core/slash-commands.tsindex 984133fd96..5f3091e1e0 100644--- a/packages/coding-agent/src/core/slash-commands.ts+++ b/packages/coding-agent/src/core/slash-commands.ts@@ -167,8 +167,9 @@ const CANONICAL_BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [},{name: "autonomous",- description: "Set or view autonomous mode",- argumentHint: "[status|on|off]",+ description: "Set or view autonomous mode with an optional budget",+ argumentHint:+ "[status|off|on [--max-continuations <n>] [--max-turns <n>] [--max-tokens <n>] [--timeout-ms <n>] [--gate <command>]]",takesArgument: true,},{diff --git a/packages/coding-agent/test/suite/agent-session-autonomous.test.ts b/packages/coding-agent/test/suite/agent-session-autonomous.test.tsindex 9f47bb8445..5d110d607b 100644--- a/packages/coding-agent/test/suite/agent-session-autonomous.test.ts+++ b/packages/coding-agent/test/suite/agent-session-autonomous.test.ts@@ -7,8 +7,10 @@ import {addAutonomousUsage,createAutonomousRuntimeState,DEFAULT_AUTONOMOUS_CONTINUATION_PROMPT,+ isUnlimitedAutonomousLimit,nextAutonomousContinuation,shouldAutonomouslyContinue,+ UNLIMITED_AUTONOMOUS_LIMIT,} from "../../src/core/autonomous.js";import type { AgentCronJob } from "../../src/core/cron-jobs.js";import { createHarness, getAssistantTexts, getMessageText, getUserTexts, type Harness } from "./harness.js";@@ -173,6 +175,180 @@ describe("AgentSession autonomous mode", () => {expect(getMessageText(statusMessages[1]).startsWith("[autonomous-status: off]\n\n")).toBe(true);});+ it("applies user-defined budget flags when enabling autonomous mode", async () => {+ const harness = await createHarness();+ harnesses.push(harness);++ await harness.session.prompt(+ "/autonomous on --max-continuations 5 --max-turns 25 --max-tokens 250000 --timeout-ms 600000",+ );++ expect(harness.getPendingResponseCount()).toBe(0);+ expect(harness.session.getAutonomousStatus()).toMatchObject({+ enabled: true,+ continuationsUsed: 0,+ turnsUsed: 0,+ tokensUsed: 0,+ limits: {+ maxContinuations: 5,+ maxTurns: 25,+ maxTokens: 250_000,+ timeoutMs: 600_000,+ },+ });+ });++ it("continues through a user-defined continuation budget instead of the default three", async () => {+ const harness = await createHarness();+ harnesses.push(harness);+ harness.setResponses(+ Array.from({ length: 8 }, (_, index) => fauxAssistantMessage(`Question ${index + 1}: what next?`)),+ );++ await harness.session.prompt("/autonomous on --max-continuations 5");+ await harness.session.prompt("make the change");++ expect(harness.session.getAutonomousStatus()).toMatchObject({+ enabled: true,+ continuationsUsed: 5,+ limits: { maxContinuations: 5 },+ });+ });++ it("accepts the CLI autonomous flag spellings and inline values", async () => {+ const harness = await createHarness();+ harnesses.push(harness);++ await harness.session.prompt(+ '/autonomous on --autonomous-max-continuations=7 --autonomous-gate "npm test" --autonomous-gate-retries=2 --autonomous-gate-timeout-ms 45000',+ );++ expect(harness.session.getAutonomousStatus()).toMatchObject({+ enabled: true,+ limits: { maxContinuations: 7 },+ gates: {+ commands: ["npm test"],+ maxRetries: 2,+ timeoutMs: 45_000,+ },+ });+ });++ it("bounds the run only by the named budget flags", async () => {+ const harness = await createHarness();+ harnesses.push(harness);++ await harness.session.prompt("/autonomous on --max-tokens 100,000");++ // Only the named budget limit applies; the unnamed ones stop cutting the run short.+ expect(harness.session.getAutonomousStatus().limits).toEqual({+ maxContinuations: UNLIMITED_AUTONOMOUS_LIMIT,+ maxTurns: UNLIMITED_AUTONOMOUS_LIMIT,+ maxTokens: 100_000,+ timeoutMs: UNLIMITED_AUTONOMOUS_LIMIT,+ });+ });++ it("keeps defaults when no budget flags are named and appends repeated gates", async () => {+ const harness = await createHarness();+ harnesses.push(harness);++ await harness.session.prompt('/autonomous on --gate "npm run lint" --gate "npm test"');++ const status = harness.session.getAutonomousStatus();+ expect(status.limits).toEqual({+ maxContinuations: 3,+ maxTurns: 12,+ maxTokens: 80_000,+ timeoutMs: 1_800_000,+ });+ expect(status.gates.commands).toEqual(["npm run lint", "npm test"]);+ });++ it("accepts large budgets written with digit separators", async () => {+ const harness = await createHarness();+ harnesses.push(harness);++ await harness.session.prompt(+ "/autonomous on --max-tokens 100,000,000,000 --max-continuations 1_000 --max-turns 10,000 --timeout-ms 3,600,000",+ );++ expect(harness.session.getAutonomousStatus().limits).toEqual({+ maxContinuations: 1_000,+ maxTurns: 10_000,+ maxTokens: 100_000_000_000,+ timeoutMs: 3_600_000,+ });+ const statusMessages = harness.session.messages.filter(+ (message) => message.role === "custom" && message.customType === "autonomous_status",+ );+ expect(getMessageText(statusMessages[0])).toContain("Tokens: 0/100,000,000,000");+ });++ it("supports unlimited budget values", async () => {+ const harness = await createHarness();+ harnesses.push(harness);++ await harness.session.prompt(+ "/autonomous on --max-continuations unlimited --max-turns unlimited --max-tokens unlimited --timeout-ms unlimited",+ );++ expect(harness.session.getAutonomousStatus().limits).toEqual({+ maxContinuations: UNLIMITED_AUTONOMOUS_LIMIT,+ maxTurns: UNLIMITED_AUTONOMOUS_LIMIT,+ maxTokens: UNLIMITED_AUTONOMOUS_LIMIT,+ timeoutMs: UNLIMITED_AUTONOMOUS_LIMIT,+ });+ const statusMessages = harness.session.messages.filter(+ (message) => message.role === "custom" && message.customType === "autonomous_status",+ );+ const statusText = getMessageText(statusMessages[0]);+ expect(statusText).toContain("Continuations: 0/unlimited");+ expect(statusText).toContain("Time: 0s/unlimited");+ });++ it("continues an unlimited-continuation run past the default three", async () => {+ const harness = await createHarness();+ harnesses.push(harness);+ harness.setResponses(+ Array.from({ length: 6 }, (_, index) => fauxAssistantMessage(`Question ${index + 1}: what next?`)),+ );++ await harness.session.prompt("/autonomous on --max-continuations unlimited --max-turns unlimited");+ await harness.session.prompt("make the change");++ const status = harness.session.getAutonomousStatus();+ expect(isUnlimitedAutonomousLimit(status.limits.maxContinuations)).toBe(true);+ expect(status.continuationsUsed).toBe(6);+ });++ it("rejects invalid budget flags without enabling autonomous mode", async () => {+ const harness = await createHarness();+ harnesses.push(harness);++ for (const input of [+ "/autonomous on --max-continuations 0",+ "/autonomous on --max-continuations",+ "/autonomous on --speed 10",+ "/autonomous on --gate-retries unlimited",+ "/autonomous off --max-continuations 2",+ ]) {+ await harness.session.prompt(input);+ }+ const commandErrors = harness.session.messages+ .filter((message) => message.role === "custom" && message.customType === "session_slash_command_result")+ .map((message) => (message as { content: string }).content);+ expect(commandErrors).toEqual([+ expect.stringContaining('--max-continuations must be a positive integer or "unlimited"'),+ expect.stringContaining("Missing value for --max-continuations"),+ expect.stringContaining("Unknown autonomous budget flag: --speed"),+ expect.stringContaining("--gate-retries must be a positive integer."),+ expect.stringContaining("Unexpected autonomous argument: --max-continuations"),+ ]);++ expect(harness.session.getAutonomousStatus().enabled).toBe(false);+ });+it("continues when the assistant tries to finish without terminal evidence", async () => {const harness = await createHarness({autonomous: { enabled: true, maxContinuations: 1 },