@cruxy/cli 0.28.1 → 0.29.0

package/dist/agent/loop.js

@@ -51,9 +51,9 @@ async function driveLoop(args, renderer, routed) {
         platform: process.platform,
         date: new Date().toISOString().slice(0, 10),
         model: `${config.model.provider}/${config.model.model}`,
-        tools: registry
-            .list()
-            .map((tool) => ({ name: tool.name, description: tool.description })),
+        // Names only: each tool's description/parameters reach the model as its wire
+        // schema, so the prompt's Tools section lists just the roster (see prompts.ts).
+        tools: registry.list().map((tool) => ({ name: tool.name })),
         git: args.git ?? null,
         projectInstructions: args.projectInstructions ?? null,
         recalledMemory: args.recalledMemory ?? null,

package/dist/agent/prompts.d.ts

@@ -8,7 +8,6 @@
  */
 export interface ToolSummary {
     name: string;
-    description: string;
 }
 export interface PromptContext {
     /** Absolute working directory the agent is rooted in. */

package/dist/agent/prompts.js

@@ -74,8 +74,13 @@ function renderTools(tools) {
     if (tools.length === 0) {
         return "## Tools\nNo tools are available this session; respond in text only.";
     }
-    const list = tools.map((t) => `- ${t.name}: ${t.description}`).join("\n");
-    return `## Tools\nYou have these tools available. Use them — don't ask the user to run things you can run yourself:\n${list}`;
+    // Names only. Each tool's description and parameter schema already reach the
+    // model as its wire spec (ToolRegistry.specs → the provider's tools field), so
+    // repeating the descriptions here just duplicated them on every first turn (and
+    // every turn on uncached providers). The roster and the "use them" nudge below
+    // are the parts the wire schema does NOT carry.
+    const names = tools.map((t) => t.name).join(", ");
+    return `## Tools\nYou have these tools available (each one's parameters and description are in its schema). Use them — don't ask the user to run things you can run yourself:\n${names}`;
 }
 /** Assemble the full system prompt for a session. */
 export function buildSystemPrompt(ctx) {

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/dist/tools/file/glob.js

@@ -3,7 +3,22 @@ import { z } from "zod";
 import { contextWorkspace, isEscapingPattern, labelPath, resolveReadRoots, } from "./paths.js";
 /** Cap on returned paths — beyond this we truncate with a notice. */
 const MAX_RESULTS = 200;
-const DEFAULT_IGNORE = ["**/node_modules/**", "**/.git/**"];
+// Dependencies, VCS internals, and conventional compiled-output dirs. The last
+// group keeps gitignored build artifacts (e.g. dist/mcp.js and its .d.ts) from
+// crowding out the real source file a pattern like `**/*mcp*` is looking for.
+// These are glob patterns, not gitignore rules: tinyglobby's `ignore` matches
+// globs, so honoring an actual .gitignore would mean reusing the indexer's
+// gitignore matcher per root — out of proportion for these ad-hoc tools, and the
+// indexed search path already honors .gitignore.
+const DEFAULT_IGNORE = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    "**/.next/**",
+    "**/out/**",
+];
 /**
  * Find files by glob pattern within the workspace. Read-only — no approval.
  * The pattern is constrained to a root (no absolute or `..` patterns) so glob
@@ -17,7 +32,7 @@ const DEFAULT_IGNORE = ["**/node_modules/**", "**/.git/**"];
  */
 export const globTool = {
     name: "glob",
-    description: "Find files by glob pattern (e.g. 'src/**/*.ts') within the project, ignoring node_modules and .git. Returns paths relative to the project root.",
+    description: "Find files by glob pattern (e.g. 'src/**/*.ts') within the project, ignoring node_modules, .git, and common build-output dirs (dist, build, coverage, .next, out). Returns paths relative to the project root.",
     parameters: z.object({
         pattern: z
             .string()

package/dist/tools/file/grep-files.d.ts

@@ -28,7 +28,8 @@ declare const parameters: z.ZodObject<{
  * run_command (which is platform-dependent and routes through the approval gate).
  *
  * Files are enumerated with the same glob mechanism as the `glob` tool (so
- * node_modules and .git are always ignored), binary files are skipped, and the
+ * node_modules, .git, and build-output dirs are always ignored), binary files
+ * are skipped, and the
  * search is bounded by the same root boundary as every file tool.
  *
  * Multi-repo (C.26, Funnel B): with more than one declared root and no root-

package/dist/tools/file/grep-files.js

@@ -10,7 +10,18 @@ const DEFAULT_MAX_RESULTS = 100;
 const MAX_LINE_LENGTH = 200;
 /** Bytes sniffed for a NUL to decide a file is binary and skip it. */
 const BINARY_SNIFF_BYTES = 8 * 1024;
-const DEFAULT_IGNORE = ["**/node_modules/**", "**/.git/**"];
+// Dependencies, VCS internals, and conventional compiled-output dirs — kept in
+// sync with glob's DEFAULT_IGNORE so both file tools skip build artifacts (see
+// glob.ts for why these are static globs rather than a parsed .gitignore).
+const DEFAULT_IGNORE = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/coverage/**",
+    "**/.next/**",
+    "**/out/**",
+];
 const parameters = z.object({
     pattern: z
         .string()
@@ -49,7 +60,8 @@ function firstSegmentIsRoot(ws, p) {
  * run_command (which is platform-dependent and routes through the approval gate).
  *
  * Files are enumerated with the same glob mechanism as the `glob` tool (so
- * node_modules and .git are always ignored), binary files are skipped, and the
+ * node_modules, .git, and build-output dirs are always ignored), binary files
+ * are skipped, and the
  * search is bounded by the same root boundary as every file tool.
  *
  * Multi-repo (C.26, Funnel B): with more than one declared root and no root-
@@ -61,7 +73,7 @@ function firstSegmentIsRoot(ws, p) {
  */
 export const grepFilesTool = {
     name: "grep_files",
-    description: "Search file CONTENTS for a regular expression within the project (vs `glob`, which matches file NAMES). Returns matches as 'path:line: text', ignoring node_modules and .git. Read-only and requires no approval — prefer it over shelling out to grep/rg/find via run_command.",
+    description: "Search file CONTENTS for a regular expression within the project (vs `glob`, which matches file NAMES). Returns matches as 'path:line: text', ignoring node_modules, .git, and common build-output dirs (dist, build, coverage, .next, out). Read-only and requires no approval — prefer it over shelling out to grep/rg/find via run_command.",
     parameters,
     async execute(input, ctx) {
         // Compile the regex up front; an invalid pattern is a clean failure, not a throw.

package/package.json

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