@probelabs/probe 0.6.0-rc238 → 0.6.0-rc240

package/build/agent/ProbeAgent.js

@@ -49,6 +49,7 @@ import {
   delegateToolDefinition,
   analyzeAllToolDefinition,
   getExecutePlanToolDefinition,
+  getCleanupExecutePlanToolDefinition,
   bashToolDefinition,
   listFilesToolDefinition,
   searchFilesToolDefinition,
@@ -870,6 +871,10 @@ export class ProbeAgent {
     }
     if (this.enableExecutePlan && wrappedTools.executePlanToolInstance && isToolAllowed('execute_plan')) {
       this.toolImplementations.execute_plan = wrappedTools.executePlanToolInstance;
+      // cleanup_execute_plan is enabled together with execute_plan
+      if (wrappedTools.cleanupExecutePlanToolInstance && isToolAllowed('cleanup_execute_plan')) {
+        this.toolImplementations.cleanup_execute_plan = wrappedTools.cleanupExecutePlanToolInstance;
+      }
     } else if (wrappedTools.analyzeAllToolInstance && isToolAllowed('analyze_all')) {
       // analyze_all is fallback when execute_plan is not enabled
       this.toolImplementations.analyze_all = wrappedTools.analyzeAllToolInstance;
@@ -2582,6 +2587,10 @@ ${extractGuidance}
       if (isToolAllowed('listFiles')) dslFunctions.push('listFiles');
       if (this.enableBash && isToolAllowed('bash')) dslFunctions.push('bash');
       toolDefinitions += `${getExecutePlanToolDefinition(dslFunctions)}\n`;
+      // cleanup_execute_plan is enabled together with execute_plan
+      if (isToolAllowed('cleanup_execute_plan')) {
+        toolDefinitions += `${getCleanupExecutePlanToolDefinition()}\n`;
+      }
     } else if (isToolAllowed('analyze_all')) {
       // Fallback: only register analyze_all if execute_plan is not available
       toolDefinitions += `${analyzeAllToolDefinition}\n`;
@@ -2661,6 +2670,9 @@ The configuration is loaded from src/config.js lines 15-25 which contains the da
     }
     if (this.enableExecutePlan && isToolAllowed('execute_plan')) {
       availableToolsList += '- execute_plan: Execute a DSL program to orchestrate tool calls. ALWAYS use this for: questions containing "all"/"every"/"comprehensive"/"complete inventory", multi-topic analysis, open-ended discovery questions, or any task requiring full codebase coverage.\n';
+      if (isToolAllowed('cleanup_execute_plan')) {
+        availableToolsList += '- cleanup_execute_plan: Clean up output buffer and session store from previous execute_plan calls.\n';
+      }
     } else if (isToolAllowed('analyze_all')) {
       availableToolsList += '- analyze_all: Process ALL data matching a query using map-reduce (for aggregate questions needing 100% coverage).\n';
     }
@@ -2891,8 +2903,10 @@ Follow these instructions carefully:
       // Track initial history length for storage
       const oldHistoryLength = this.history.length;
 
-      // Reset output buffer for this answer() call
-      if (this._outputBuffer) {
+      // Reset output buffer for this answer() call — but NOT during schema correction recursion
+      // When _schemaFormatted is true, this is a recursive call to fix JSON formatting,
+      // and we must preserve the output buffer so the parent call can append it
+      if (this._outputBuffer && !options?._schemaFormatted) {
         this._outputBuffer.items = [];
       }
 
@@ -3411,6 +3425,10 @@ Follow these instructions carefully:
           // Execute Plan tool (requires enableExecutePlan flag, supersedes analyze_all)
           if (this.enableExecutePlan && this.allowedTools.isEnabled('execute_plan')) {
             validTools.push('execute_plan');
+            // cleanup_execute_plan is enabled together with execute_plan
+            if (this.allowedTools.isEnabled('cleanup_execute_plan')) {
+              validTools.push('cleanup_execute_plan');
+            }
           } else if (this.allowedTools.isEnabled('analyze_all')) {
             validTools.push('analyze_all');
           }

package/build/agent/dsl/runtime.js

@@ -4,7 +4,7 @@
  * Orchestrates the full pipeline:
  * 1. Validate (AST whitelist)
  * 2. Transform (inject await, wrap in async IIFE)
- * 3. Execute in SandboxJS with tool globals + timeout
+ * 3. Execute in SandboxJS with tool globals
  *
  * Returns the result or a structured error.
  */
@@ -25,7 +25,6 @@ const Sandbox = SandboxModule.default || SandboxModule;
  * @param {Object} [options.mcpTools={}] - MCP tool metadata
  * @param {Function} options.llmCall - Function for LLM() calls: (instruction, data, options?) => Promise<any>
  * @param {number} [options.mapConcurrency=3] - Concurrency limit for map()
- * @param {number} [options.timeoutMs=120000] - Execution timeout in milliseconds (default 2 min)
  * @param {number} [options.maxLoopIterations=5000] - Max iterations for while/for loops
  * @param {Object} [options.tracer=null] - SimpleAppTracer instance for OTEL telemetry
  * @returns {Object} Runtime with execute() method
@@ -37,7 +36,6 @@ export function createDSLRuntime(options) {
     mcpTools = {},
     llmCall,
     mapConcurrency = 3,
-    timeoutMs = 120000,
     maxLoopIterations = 5000,
     tracer = null,
     sessionStore = {},
@@ -108,9 +106,8 @@ export function createDSLRuntime(options) {
       };
     }
 
-    // Step 3: Execute in SandboxJS with timeout
+    // Step 3: Execute in SandboxJS
     tracer?.addEvent?.('dsl.phase.execute_start', {
-      'dsl.timeout_ms': timeoutMs,
       'dsl.max_loop_iterations': maxLoopIterations,
     });
 
@@ -147,20 +144,10 @@ export function createDSLRuntime(options) {
       };
       process.on('unhandledRejection', rejectionHandler);
 
-      // Race execution against timeout
-      let timeoutHandle;
-      const executionPromise = exec().run();
-      const timeoutPromise = new Promise((_, reject) => {
-        timeoutHandle = setTimeout(() => {
-          reject(new Error(`Execution timed out after ${Math.round(timeoutMs / 1000)}s. Script took too long — reduce the amount of work (fewer items, smaller data) or increase timeout.`));
-        }, timeoutMs);
-      });
-
       let result;
       try {
-        result = await Promise.race([executionPromise, timeoutPromise]);
+        result = await exec().run();
       } finally {
-        clearTimeout(timeoutHandle);
         // Delay handler removal — SandboxJS can throw async errors after execution completes
         setTimeout(() => {
           process.removeListener('unhandledRejection', rejectionHandler);

package/build/agent/dsl/validator.js

@@ -16,18 +16,23 @@ const ALLOWED_NODE_TYPES = new Set([
   'BlockStatement',
   'VariableDeclaration',
   'VariableDeclarator',
+  'FunctionDeclaration',
   'ArrowFunctionExpression',
   'FunctionExpression',
   'CallExpression',
+  'NewExpression',
   'MemberExpression',
   'Identifier',
   'Literal',
   'TemplateLiteral',
   'TemplateElement',
+  'TaggedTemplateExpression',
   'ArrayExpression',
   'ObjectExpression',
   'SpreadElement',
   'IfStatement',
+  'SwitchStatement',
+  'SwitchCase',
   'ConditionalExpression',
   'ForOfStatement',
   'ForInStatement',
@@ -127,10 +132,6 @@ export function validateDSL(code) {
       errors.push(`Generator functions are not allowed at position ${node.start}`);
     }
 
-    // Block regex literals — SandboxJS doesn't support them
-    if (node.type === 'Literal' && node.regex) {
-      errors.push(`Regex literals are not supported at position ${node.start}. Use String methods like indexOf(), includes(), startsWith() instead.`);
-    }
 
     // Check identifiers against blocklist
     if (node.type === 'Identifier' && BLOCKED_IDENTIFIERS.has(node.name)) {

package/build/agent/index.js

@@ -9905,7 +9905,7 @@ function resolveTargetPath(target, cwd) {
   }
   return filePart + suffix;
 }
-var searchSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, bashSchema, analyzeAllSchema, executePlanSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, analyzeAllToolDefinition, bashToolDefinition, googleSearchToolDefinition, urlContextToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, analyzeAllDescription, DEFAULT_VALID_TOOLS;
+var searchSchema, querySchema, extractSchema, delegateSchema, listSkillsSchema, useSkillSchema, bashSchema, analyzeAllSchema, executePlanSchema, cleanupExecutePlanSchema, attemptCompletionSchema, searchToolDefinition, queryToolDefinition, extractToolDefinition, delegateToolDefinition, attemptCompletionToolDefinition, analyzeAllToolDefinition, bashToolDefinition, googleSearchToolDefinition, urlContextToolDefinition, searchDescription, queryDescription, extractDescription, delegateDescription, analyzeAllDescription, DEFAULT_VALID_TOOLS;
 var init_common = __esm({
   "src/tools/common.js"() {
     "use strict";
@@ -9953,6 +9953,10 @@ var init_common = __esm({
       code: external_exports.string().min(1).describe("JavaScript DSL code to execute. All function calls look synchronous \u2014 do NOT use async/await. Use map(items, fn) for batch operations. Use LLM(instruction, data) for AI processing."),
       description: external_exports.string().optional().describe("Human-readable description of what this plan does, for logging.")
     });
+    cleanupExecutePlanSchema = external_exports.object({
+      clearOutputBuffer: external_exports.boolean().optional().default(true).describe("Clear the output buffer from previous execute_plan calls"),
+      clearSessionStore: external_exports.boolean().optional().default(false).describe("Clear the session store (persisted data across execute_plan calls)")
+    });
     attemptCompletionSchema = {
       // Custom validation that requires result parameter but allows direct XML response
       safeParse: (params) => {
@@ -10300,6 +10304,7 @@ Capabilities:
       "delegate",
       "analyze_all",
       "execute_plan",
+      "cleanup_execute_plan",
       "listSkills",
       "useSkill",
       "listFiles",
@@ -21499,9 +21504,6 @@ function validateDSL(code) {
     if (node.type === "FunctionExpression" && node.generator) {
       errors.push(`Generator functions are not allowed at position ${node.start}`);
     }
-    if (node.type === "Literal" && node.regex) {
-      errors.push(`Regex literals are not supported at position ${node.start}. Use String methods like indexOf(), includes(), startsWith() instead.`);
-    }
     if (node.type === "Identifier" && BLOCKED_IDENTIFIERS.has(node.name)) {
       errors.push(`Blocked identifier: '${node.name}' at position ${node.start}`);
     }
@@ -21540,18 +21542,23 @@ var init_validator = __esm({
       "BlockStatement",
       "VariableDeclaration",
       "VariableDeclarator",
+      "FunctionDeclaration",
       "ArrowFunctionExpression",
       "FunctionExpression",
       "CallExpression",
+      "NewExpression",
       "MemberExpression",
       "Identifier",
       "Literal",
       "TemplateLiteral",
       "TemplateElement",
+      "TaggedTemplateExpression",
       "ArrayExpression",
       "ObjectExpression",
       "SpreadElement",
       "IfStatement",
+      "SwitchStatement",
+      "SwitchCase",
       "ConditionalExpression",
       "ForOfStatement",
       "ForInStatement",
@@ -22013,7 +22020,6 @@ function createDSLRuntime(options) {
     mcpTools = {},
     llmCall,
     mapConcurrency = 3,
-    timeoutMs = 12e4,
     maxLoopIterations = 5e3,
     tracer = null,
     sessionStore = {},
@@ -22068,7 +22074,6 @@ ${validation.errors.join("\n")}`,
       };
     }
     tracer?.addEvent?.("dsl.phase.execute_start", {
-      "dsl.timeout_ms": timeoutMs,
       "dsl.max_loop_iterations": maxLoopIterations
     });
     try {
@@ -22096,18 +22101,10 @@ ${validation.errors.join("\n")}`,
         escapedError = reason;
       };
       process.on("unhandledRejection", rejectionHandler);
-      let timeoutHandle;
-      const executionPromise = exec6().run();
-      const timeoutPromise = new Promise((_, reject2) => {
-        timeoutHandle = setTimeout(() => {
-          reject2(new Error(`Execution timed out after ${Math.round(timeoutMs / 1e3)}s. Script took too long \u2014 reduce the amount of work (fewer items, smaller data) or increase timeout.`));
-        }, timeoutMs);
-      });
       let result;
       try {
-        result = await Promise.race([executionPromise, timeoutPromise]);
+        result = await exec6().run();
       } finally {
-        clearTimeout(timeoutHandle);
         setTimeout(() => {
           process.removeListener("unhandledRejection", rejectionHandler);
         }, 500);
@@ -29094,6 +29091,14 @@ Logs: ${result.logs.join(" | ")}` : "";
             "dsl.error": lastError.substring(0, 1e3)
           });
         }
+        if (outputBuffer && outputBuffer.items && outputBuffer.items.length > 0) {
+          const clearedChars = outputBuffer.items.reduce((sum, item) => sum + item.length, 0);
+          outputBuffer.items = [];
+          planSpan?.addEvent?.("dsl.auto_cleanup", {
+            "cleanup.chars_cleared": clearedChars,
+            "cleanup.reason": "all_retries_exhausted"
+          });
+        }
         finalOutput = `Plan execution failed after ${maxRetries} retries.
 
 Last error: ${lastError}`;
@@ -29106,6 +29111,9 @@ Last error: ${lastError}`;
         planSpan?.end?.();
         return finalOutput;
       } catch (e) {
+        if (outputBuffer && outputBuffer.items && outputBuffer.items.length > 0) {
+          outputBuffer.items = [];
+        }
         planSpan?.setStatus?.("ERROR");
         planSpan?.addEvent?.("exception", {
           "exception.message": e.message,
@@ -29549,6 +29557,62 @@ output(table);
 return "Generated table with " + results.length + " items.";
 \`\`\``;
 }
+function createCleanupExecutePlanTool(options) {
+  const { outputBuffer, sessionStore, tracer } = options;
+  return tool4({
+    description: "Clean up output buffer and session store from previous execute_plan calls. Use this when a previous execute_plan failed and left stale data, or before starting a fresh analysis.",
+    parameters: cleanupExecutePlanSchema,
+    execute: async ({ clearOutputBuffer = true, clearSessionStore = false }) => {
+      const span = tracer?.createToolSpan?.("cleanup_execute_plan", {
+        "cleanup.clear_output_buffer": clearOutputBuffer,
+        "cleanup.clear_session_store": clearSessionStore
+      }) || null;
+      const results = [];
+      try {
+        if (clearOutputBuffer && outputBuffer) {
+          const itemCount = outputBuffer.items?.length || 0;
+          const charCount = outputBuffer.items?.reduce((sum, item) => sum + item.length, 0) || 0;
+          outputBuffer.items = [];
+          results.push(`Output buffer cleared (${itemCount} items, ${charCount} chars)`);
+        }
+        if (clearSessionStore && sessionStore) {
+          const keyCount = Object.keys(sessionStore).length;
+          for (const key of Object.keys(sessionStore)) {
+            delete sessionStore[key];
+          }
+          results.push(`Session store cleared (${keyCount} keys)`);
+        }
+        const output = results.length > 0 ? `Cleanup complete:
+- ${results.join("\n- ")}` : "Nothing to clean up";
+        span?.setAttributes?.({
+          "cleanup.result": output,
+          "cleanup.success": true
+        });
+        span?.setStatus?.("OK");
+        span?.end?.();
+        return output;
+      } catch (e) {
+        span?.setStatus?.("ERROR");
+        span?.addEvent?.("exception", { "exception.message": e.message });
+        span?.end?.();
+        return `Cleanup failed: ${e.message}`;
+      }
+    }
+  });
+}
+function getCleanupExecutePlanToolDefinition() {
+  return `## cleanup_execute_plan
+Description: Clean up output buffer and session store from previous execute_plan calls. Use when a previous execute_plan failed and left stale data, or before starting a fresh analysis.
+
+Parameters:
+- clearOutputBuffer: (optional, default: true) Clear the output buffer from previous execute_plan calls
+- clearSessionStore: (optional, default: false) Clear the session store (persisted data across execute_plan calls)
+
+Example:
+<cleanup_execute_plan>
+<clearOutputBuffer>true</clearOutputBuffer>
+</cleanup_execute_plan>`;
+}
 var init_executePlan = __esm({
   "src/tools/executePlan.js"() {
     "use strict";
@@ -30344,6 +30408,13 @@ function createWrappedTools(baseTools) {
       baseTools.executePlanTool.execute
     );
   }
+  if (baseTools.cleanupExecutePlanTool) {
+    wrappedTools.cleanupExecutePlanToolInstance = wrapToolWithEmitter(
+      baseTools.cleanupExecutePlanTool,
+      "cleanup_execute_plan",
+      baseTools.cleanupExecutePlanTool.execute
+    );
+  }
   if (baseTools.bashTool) {
     wrappedTools.bashToolInstance = wrapToolWithEmitter(
       baseTools.bashTool,
@@ -31253,6 +31324,9 @@ function createTools(configOptions) {
   }
   if (configOptions.enableExecutePlan && isToolAllowed("execute_plan")) {
     tools2.executePlanTool = createExecutePlanTool(configOptions);
+    if (isToolAllowed("cleanup_execute_plan")) {
+      tools2.cleanupExecutePlanTool = createCleanupExecutePlanTool(configOptions);
+    }
   } else if (isToolAllowed("analyze_all")) {
     tools2.analyzeAllTool = analyzeAllTool(configOptions);
   }
@@ -68665,15 +68739,31 @@ function isSimpleTextWrapperSchema(schema) {
     return null;
   }
   const trimmed = schema.trim();
-  const simplePatterns = [
-    /^\{\s*["']?(\w+)["']?\s*:\s*["']?string["']?\s*\}$/i,
-    /^\{\s*["']?type["']?\s*:\s*["']?object["']?\s*,\s*["']?properties["']?\s*:\s*\{\s*["']?(\w+)["']?\s*:\s*\{\s*["']?type["']?\s*:\s*["']?string["']?\s*\}\s*\}\s*\}$/i
-  ];
-  for (const pattern of simplePatterns) {
-    const match2 = trimmed.match(pattern);
-    if (match2) {
-      return { fieldName: match2[1] };
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed !== "object" || parsed === null) {
+    } else {
+      const keys2 = Object.keys(parsed);
+      if (keys2.length === 1 && parsed[keys2[0]] === "string") {
+        return { fieldName: keys2[0] };
+      }
+      if (parsed.type === "object" && parsed.properties) {
+        const propKeys = Object.keys(parsed.properties);
+        if (propKeys.length === 1) {
+          const prop = parsed.properties[propKeys[0]];
+          if (prop && prop.type === "string") {
+            return { fieldName: propKeys[0] };
+          }
+        }
+      }
+      return null;
     }
+  } catch {
+  }
+  const simplePattern = /^\{\s*["']?(\w+)["']?\s*:\s*["']?string["']?\s*\}$/i;
+  const match2 = trimmed.match(simplePattern);
+  if (match2) {
+    return { fieldName: match2[1] };
   }
   return null;
 }
@@ -81536,6 +81626,9 @@ var init_ProbeAgent = __esm({
         }
         if (this.enableExecutePlan && wrappedTools.executePlanToolInstance && isToolAllowed("execute_plan")) {
           this.toolImplementations.execute_plan = wrappedTools.executePlanToolInstance;
+          if (wrappedTools.cleanupExecutePlanToolInstance && isToolAllowed("cleanup_execute_plan")) {
+            this.toolImplementations.cleanup_execute_plan = wrappedTools.cleanupExecutePlanToolInstance;
+          }
         } else if (wrappedTools.analyzeAllToolInstance && isToolAllowed("analyze_all")) {
           this.toolImplementations.analyze_all = wrappedTools.analyzeAllToolInstance;
         }
@@ -82909,6 +83002,10 @@ Workspace: ${this.allowedFolders.join(", ")}`;
           if (this.enableBash && isToolAllowed("bash")) dslFunctions.push("bash");
           toolDefinitions += `${getExecutePlanToolDefinition(dslFunctions)}
 `;
+          if (isToolAllowed("cleanup_execute_plan")) {
+            toolDefinitions += `${getCleanupExecutePlanToolDefinition()}
+`;
+          }
         } else if (isToolAllowed("analyze_all")) {
           toolDefinitions += `${analyzeAllToolDefinition}
 `;
@@ -82984,6 +83081,9 @@ The configuration is loaded from src/config.js lines 15-25 which contains the da
         }
         if (this.enableExecutePlan && isToolAllowed("execute_plan")) {
           availableToolsList += '- execute_plan: Execute a DSL program to orchestrate tool calls. ALWAYS use this for: questions containing "all"/"every"/"comprehensive"/"complete inventory", multi-topic analysis, open-ended discovery questions, or any task requiring full codebase coverage.\n';
+          if (isToolAllowed("cleanup_execute_plan")) {
+            availableToolsList += "- cleanup_execute_plan: Clean up output buffer and session store from previous execute_plan calls.\n";
+          }
         } else if (isToolAllowed("analyze_all")) {
           availableToolsList += "- analyze_all: Process ALL data matching a query using map-reduce (for aggregate questions needing 100% coverage).\n";
         }
@@ -83210,7 +83310,7 @@ You are working with a workspace. Available paths: ${workspaceDesc}
         }
         try {
           const oldHistoryLength = this.history.length;
-          if (this._outputBuffer) {
+          if (this._outputBuffer && !options?._schemaFormatted) {
             this._outputBuffer.items = [];
           }
           if (this.enableTasks) {
@@ -83570,6 +83670,9 @@ You are working with a workspace. Available paths: ${workspaceDesc}
               }
               if (this.enableExecutePlan && this.allowedTools.isEnabled("execute_plan")) {
                 validTools.push("execute_plan");
+                if (this.allowedTools.isEnabled("cleanup_execute_plan")) {
+                  validTools.push("cleanup_execute_plan");
+                }
               } else if (this.allowedTools.isEnabled("analyze_all")) {
                 validTools.push("analyze_all");
               }

package/build/agent/probeTool.js

@@ -220,6 +220,15 @@ export function createWrappedTools(baseTools) {
     );
   }
 
+  // Wrap cleanup_execute_plan tool
+  if (baseTools.cleanupExecutePlanTool) {
+    wrappedTools.cleanupExecutePlanToolInstance = wrapToolWithEmitter(
+      baseTools.cleanupExecutePlanTool,
+      'cleanup_execute_plan',
+      baseTools.cleanupExecutePlanTool.execute
+    );
+  }
+
   // Wrap bash tool
   if (baseTools.bashTool) {
     wrappedTools.bashToolInstance = wrapToolWithEmitter(

package/build/agent/schemaUtils.js

@@ -784,18 +784,42 @@ export function isSimpleTextWrapperSchema(schema) {
 
   const trimmed = schema.trim();
 
-  // Match patterns like: {text: string}, {"text": "string"}, {response: string}, etc.
-  // These are simple wrappers that just need a single text field
-  const simplePatterns = [
-    /^\{\s*["']?(\w+)["']?\s*:\s*["']?string["']?\s*\}$/i,
-    /^\{\s*["']?type["']?\s*:\s*["']?object["']?\s*,\s*["']?properties["']?\s*:\s*\{\s*["']?(\w+)["']?\s*:\s*\{\s*["']?type["']?\s*:\s*["']?string["']?\s*\}\s*\}\s*\}$/i
-  ];
+  // First, try parsing as JSON for full JSON Schema format
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed !== 'object' || parsed === null) {
+      // Fall through to regex matching
+    } else {
+      // Shorthand JSON format: {"text": "string"} or {"fieldName": "string"}
+      const keys = Object.keys(parsed);
+      if (keys.length === 1 && parsed[keys[0]] === 'string') {
+        return { fieldName: keys[0] };
+      }
 
-  for (const pattern of simplePatterns) {
-    const match = trimmed.match(pattern);
-    if (match) {
-      return { fieldName: match[1] };
+      // Full JSON Schema format: {"type":"object","properties":{"text":{"type":"string",...}}}
+      // Handles schemas with "required", "description", and other extra fields
+      if (parsed.type === 'object' && parsed.properties) {
+        const propKeys = Object.keys(parsed.properties);
+        if (propKeys.length === 1) {
+          const prop = parsed.properties[propKeys[0]];
+          if (prop && prop.type === 'string') {
+            return { fieldName: propKeys[0] };
+          }
+        }
+      }
+
+      // Valid JSON but not a simple wrapper
+      return null;
     }
+  } catch {
+    // Not valid JSON, fall through to regex matching
+  }
+
+  // Fallback: regex matching for shorthand formats like {text: string}, {'text': 'string'}
+  const simplePattern = /^\{\s*["']?(\w+)["']?\s*:\s*["']?string["']?\s*\}$/i;
+  const match = trimmed.match(simplePattern);
+  if (match) {
+    return { fieldName: match[1] };
   }
 
   return null;

package/build/agent/tools.js

@@ -6,6 +6,7 @@ import {
   delegateTool,
   analyzeAllTool,
   createExecutePlanTool,
+  createCleanupExecutePlanTool,
   bashTool,
   editTool,
   createTool,
@@ -18,6 +19,7 @@ import {
   delegateSchema,
   analyzeAllSchema,
   executePlanSchema,
+  cleanupExecutePlanSchema,
   bashSchema,
   editSchema,
   createSchema,
@@ -27,6 +29,7 @@ import {
   delegateToolDefinition,
   analyzeAllToolDefinition,
   getExecutePlanToolDefinition,
+  getCleanupExecutePlanToolDefinition,
   bashToolDefinition,
   editToolDefinition,
   createToolDefinition,
@@ -63,6 +66,10 @@ export function createTools(configOptions) {
   }
   if (configOptions.enableExecutePlan && isToolAllowed('execute_plan')) {
     tools.executePlanTool = createExecutePlanTool(configOptions);
+    // cleanup_execute_plan is enabled together with execute_plan
+    if (isToolAllowed('cleanup_execute_plan')) {
+      tools.cleanupExecutePlanTool = createCleanupExecutePlanTool(configOptions);
+    }
   } else if (isToolAllowed('analyze_all')) {
     // analyze_all is fallback when execute_plan is not enabled
     tools.analyzeAllTool = analyzeAllTool(configOptions);
@@ -104,6 +111,7 @@ export {
   delegateSchema,
   analyzeAllSchema,
   executePlanSchema,
+  cleanupExecutePlanSchema,
   bashSchema,
   editSchema,
   createSchema,
@@ -114,6 +122,7 @@ export {
   delegateToolDefinition,
   analyzeAllToolDefinition,
   getExecutePlanToolDefinition,
+  getCleanupExecutePlanToolDefinition,
   bashToolDefinition,
   editToolDefinition,
   createToolDefinition,

package/build/index.js

@@ -27,6 +27,7 @@ import {
 	delegateSchema,
 	analyzeAllSchema,
 	executePlanSchema,
+	cleanupExecutePlanSchema,
 	attemptCompletionSchema,
 	bashSchema,
 	searchToolDefinition,
@@ -47,7 +48,7 @@ import {
 	createToolDefinition
 } from './tools/edit.js';
 import { searchTool, queryTool, extractTool, delegateTool, analyzeAllTool } from './tools/vercel.js';
-import { createExecutePlanTool, getExecutePlanToolDefinition } from './tools/executePlan.js';
+import { createExecutePlanTool, getExecutePlanToolDefinition, createCleanupExecutePlanTool, getCleanupExecutePlanToolDefinition } from './tools/executePlan.js';
 import { bashTool } from './tools/bash.js';
 import { editTool, createTool } from './tools/edit.js';
 import { ProbeAgent } from './agent/ProbeAgent.js';
@@ -93,6 +94,7 @@ export {
 	delegateTool,
 	analyzeAllTool,
 	createExecutePlanTool,
+	createCleanupExecutePlanTool,
 	bashTool,
 	editTool,
 	createTool,
@@ -106,6 +108,7 @@ export {
 	delegateSchema,
 	analyzeAllSchema,
 	executePlanSchema,
+	cleanupExecutePlanSchema,
 	attemptCompletionSchema,
 	bashSchema,
 	editSchema,
@@ -117,6 +120,7 @@ export {
 	delegateToolDefinition,
 	analyzeAllToolDefinition,
 	getExecutePlanToolDefinition,
+	getCleanupExecutePlanToolDefinition,
 	attemptCompletionToolDefinition,
 	bashToolDefinition,
 	editToolDefinition,

package/build/tools/common.js

@@ -59,6 +59,11 @@ export const executePlanSchema = z.object({
 	description: z.string().optional().describe('Human-readable description of what this plan does, for logging.')
 });
 
+export const cleanupExecutePlanSchema = z.object({
+	clearOutputBuffer: z.boolean().optional().default(true).describe('Clear the output buffer from previous execute_plan calls'),
+	clearSessionStore: z.boolean().optional().default(false).describe('Clear the session store (persisted data across execute_plan calls)')
+});
+
 // Schema for the attempt_completion tool - flexible validation for direct XML response
 export const attemptCompletionSchema = {
 	// Custom validation that requires result parameter but allows direct XML response
@@ -431,6 +436,7 @@ export const DEFAULT_VALID_TOOLS = [
 	'delegate',
 	'analyze_all',
 	'execute_plan',
+	'cleanup_execute_plan',
 	'listSkills',
 	'useSkill',
 	'listFiles',