@cruxy/cli 0.28.2 → 0.29.0

package/dist/cli/commands/run.js

@@ -187,7 +187,24 @@ export function runCommand() {
                 logger.info(t.muted(`mcp:     server "${d.server}" declared in ${d.root} not loaded (primary-root MCP only this release)`));
             }
         }
-        const session = buildAgentSession(config, apiKey, workspace, Boolean(process.stdin.isTTY), planMode, renderer, checkpoints, sandbox, hooksRunner, mcp.tools);
+        // One-shot vs REPL turn ceiling. A one-shot run caps at
+        // `agent.maxIterationsOneShot` (default 40): a headless run can't be
+        // resumed by a human, so hitting the cap abandons the whole task — it
+        // needs headroom above the interactive cap to clear legit long work,
+        // while still bounding a runaway (and it now exits non-zero, see below).
+        // The REPL keeps `agent.maxIterations` (a soft checkpoint). Keyed on the
+        // one-shot MODE, never on TTY, so `cruxy run "task"` behaves the same
+        // piped into CI or run in a terminal.
+        const sessionConfig = interactive
+            ? config
+            : {
+                ...config,
+                agent: {
+                    ...config.agent,
+                    maxIterations: config.agent.maxIterationsOneShot,
+                },
+            };
+        const session = buildAgentSession(sessionConfig, apiKey, workspace, Boolean(process.stdin.isTTY), planMode, renderer, checkpoints, sandbox, hooksRunner, mcp.tools);
         if (interactive) {
             try {
                 await runInteractive(session, undefined, renderer, checkpoints, hookCommands);
@@ -253,7 +270,9 @@ export function runCommand() {
                 stop: result.stop,
                 iterations: result.iterations,
                 reason: result.stopReason,
-                maxIterations: config.agent.maxIterations,
+                // The effective one-shot cap (agent.maxIterationsOneShot), so the
+                // message names the limit the run actually hit.
+                maxIterations: sessionConfig.agent.maxIterations,
             });
         }
     });

package/dist/config/schema.d.ts

@@ -26,18 +26,33 @@ export declare const CruxyBackendConfigSchema: z.ZodObject<{
     gatewayUrl?: string | undefined;
 }>;
 export declare const AgentConfigSchema: z.ZodObject<{
-    /** Hard ceiling on agent loop turns. */
+    /**
+     * Hard ceiling on agent loop turns per user turn — the interactive default.
+     * In the REPL this is a soft checkpoint: hitting it ends the turn and the
+     * human continues (or Ctrl-C's a runaway), so it can be generous.
+     */
     maxIterations: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Turn ceiling for a ONE-SHOT `cruxy run "task"` (non-interactive). Set higher
+     * than {@link maxIterations} because a headless run has no human to resume it:
+     * hitting the cap abandons the whole task (fail-loud, non-zero exit), so it
+     * must clear the legit long tail (real "fix the failing tests" work runs
+     * ~10-25 turns) while still bounding a runaway. Not clamped to
+     * `maxIterations` — a user may deliberately set it lower or higher.
+     */
+    maxIterationsOneShot: z.ZodDefault<z.ZodNumber>;
     /** Skip per-action confirmation prompts. */
     autoApprove: z.ZodDefault<z.ZodBoolean>;
     /** Plan mode: propose a plan for approval before executing (C.31, opt-in). */
     planMode: z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     maxIterations: number;
+    maxIterationsOneShot: number;
     autoApprove: boolean;
     planMode: boolean;
 }, {
     maxIterations?: number | undefined;
+    maxIterationsOneShot?: number | undefined;
     autoApprove?: boolean | undefined;
     planMode?: boolean | undefined;
 }>;
@@ -979,18 +994,33 @@ export declare const CruxyConfigSchema: z.ZodObject<{
         gatewayUrl?: string | undefined;
     }>>;
     agent: z.ZodDefault<z.ZodObject<{
-        /** Hard ceiling on agent loop turns. */
+        /**
+         * Hard ceiling on agent loop turns per user turn — the interactive default.
+         * In the REPL this is a soft checkpoint: hitting it ends the turn and the
+         * human continues (or Ctrl-C's a runaway), so it can be generous.
+         */
         maxIterations: z.ZodDefault<z.ZodNumber>;
+        /**
+         * Turn ceiling for a ONE-SHOT `cruxy run "task"` (non-interactive). Set higher
+         * than {@link maxIterations} because a headless run has no human to resume it:
+         * hitting the cap abandons the whole task (fail-loud, non-zero exit), so it
+         * must clear the legit long tail (real "fix the failing tests" work runs
+         * ~10-25 turns) while still bounding a runaway. Not clamped to
+         * `maxIterations` — a user may deliberately set it lower or higher.
+         */
+        maxIterationsOneShot: z.ZodDefault<z.ZodNumber>;
         /** Skip per-action confirmation prompts. */
         autoApprove: z.ZodDefault<z.ZodBoolean>;
         /** Plan mode: propose a plan for approval before executing (C.31, opt-in). */
         planMode: z.ZodDefault<z.ZodBoolean>;
     }, "strict", z.ZodTypeAny, {
         maxIterations: number;
+        maxIterationsOneShot: number;
         autoApprove: boolean;
         planMode: boolean;
     }, {
         maxIterations?: number | undefined;
+        maxIterationsOneShot?: number | undefined;
         autoApprove?: boolean | undefined;
         planMode?: boolean | undefined;
     }>>;
@@ -1737,6 +1767,7 @@ export declare const CruxyConfigSchema: z.ZodObject<{
     };
     agent: {
         maxIterations: number;
+        maxIterationsOneShot: number;
         autoApprove: boolean;
         planMode: boolean;
     };
@@ -1889,6 +1920,7 @@ export declare const CruxyConfigSchema: z.ZodObject<{
     } | undefined;
     agent?: {
         maxIterations?: number | undefined;
+        maxIterationsOneShot?: number | undefined;
         autoApprove?: boolean | undefined;
         planMode?: boolean | undefined;
     } | undefined;

package/dist/config/schema.js

@@ -26,8 +26,21 @@ export const CruxyBackendConfigSchema = z
     .strict();
 export const AgentConfigSchema = z
     .object({
-    /** Hard ceiling on agent loop turns. */
+    /**
+     * Hard ceiling on agent loop turns per user turn — the interactive default.
+     * In the REPL this is a soft checkpoint: hitting it ends the turn and the
+     * human continues (or Ctrl-C's a runaway), so it can be generous.
+     */
     maxIterations: z.number().int().positive().default(25),
+    /**
+     * Turn ceiling for a ONE-SHOT `cruxy run "task"` (non-interactive). Set higher
+     * than {@link maxIterations} because a headless run has no human to resume it:
+     * hitting the cap abandons the whole task (fail-loud, non-zero exit), so it
+     * must clear the legit long tail (real "fix the failing tests" work runs
+     * ~10-25 turns) while still bounding a runaway. Not clamped to
+     * `maxIterations` — a user may deliberately set it lower or higher.
+     */
+    maxIterationsOneShot: z.number().int().positive().default(40),
     /** Skip per-action confirmation prompts. */
     autoApprove: z.boolean().default(false),
     /** Plan mode: propose a plan for approval before executing (C.31, opt-in). */

package/dist/errors/constructors.js

@@ -1235,7 +1235,7 @@ export function agentIncomplete(info) {
         cause: `reached the turn limit${cap} after ${turns} without completing. The work so far is shown above.`,
         nextSteps: [
             "review the partial output above, then re-run with a narrower prompt",
-            "raise `agent.maxIterations` if the task legitimately needs more turns",
+            "raise `agent.maxIterationsOneShot` (one-shot) or `agent.maxIterations` if the task legitimately needs more turns",
         ],
         meta,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "0.28.2",
+  "version": "0.29.0",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {