@corbat-tech/coco 2.37.0 → 2.38.0

package/dist/cli/index.js

@@ -43227,6 +43227,145 @@ Response format (JSON only, no prose):
   return spec;
 }
 
+// src/runtime/multi-agent.ts
+function createAgentArtifact(input) {
+  return {
+    ...input,
+    id: input.id ?? `artifact-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+    createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createSummaryArtifact(output, metadata = {}) {
+  return createAgentArtifact({
+    kind: "summary",
+    content: output,
+    title: metadata.title ?? "Agent summary",
+    agentRunId: metadata.agentRunId,
+    taskId: metadata.taskId
+  });
+}
+function normalizeAgentRunResult(input) {
+  const completedAt = input.completedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const startedAt = input.startedAt ?? completedAt;
+  const status = input.status ?? (input.success ? "completed" : "failed");
+  const artifacts = input.artifacts && input.artifacts.length > 0 ? input.artifacts.map(cloneArtifact) : [createSummaryArtifact(input.output, { agentRunId: input.id, taskId: input.taskId })];
+  return {
+    id: input.id,
+    taskId: input.taskId,
+    role: input.role,
+    status,
+    success: input.success,
+    output: input.output,
+    artifacts,
+    toolsUsed: [...input.toolsUsed ?? []],
+    turns: input.turns ?? 0,
+    durationMs: input.durationMs ?? 0,
+    usage: input.usage,
+    error: input.error,
+    startedAt,
+    completedAt,
+    metadata: input.metadata
+  };
+}
+function validateAgentGraph(graph) {
+  const issues = [];
+  const nodeIds = /* @__PURE__ */ new Set();
+  const gateIds = new Set((graph.gates ?? []).map((gate) => gate.id));
+  if (graph.parallelism !== void 0 && graph.parallelism < 1) {
+    issues.push({
+      code: "invalid-parallelism",
+      message: "Graph parallelism must be greater than zero."
+    });
+  }
+  for (const node of graph.nodes) {
+    if (nodeIds.has(node.id)) {
+      issues.push({
+        code: "duplicate-node",
+        message: `Duplicate graph node '${node.id}'.`,
+        nodeId: node.id
+      });
+    }
+    nodeIds.add(node.id);
+    if (node.retryPolicy && node.retryPolicy.maxAttempts < 1) {
+      issues.push({
+        code: "invalid-retry-policy",
+        message: `Node '${node.id}' retry policy must allow at least one attempt.`,
+        nodeId: node.id
+      });
+    }
+    for (const dep of node.dependsOn ?? []) {
+      if (!nodeIds.has(dep) && !graph.nodes.some((candidate) => candidate.id === dep)) {
+        issues.push({
+          code: "missing-dependency",
+          message: `Node '${node.id}' depends on missing node '${dep}'.`,
+          nodeId: node.id
+        });
+      }
+    }
+    for (const gate of node.gates ?? []) {
+      if (!gateIds.has(gate)) {
+        issues.push({
+          code: "missing-gate",
+          message: `Node '${node.id}' references missing gate '${gate}'.`,
+          nodeId: node.id,
+          gateId: gate
+        });
+      }
+    }
+  }
+  for (const edge of graph.edges ?? []) {
+    if (!nodeIds.has(edge.from)) {
+      issues.push({
+        code: "missing-edge-node",
+        message: `Graph edge references missing source node '${edge.from}'.`,
+        nodeId: edge.from
+      });
+    }
+    if (!nodeIds.has(edge.to)) {
+      issues.push({
+        code: "missing-edge-node",
+        message: `Graph edge references missing target node '${edge.to}'.`,
+        nodeId: edge.to
+      });
+    }
+  }
+  const levels = buildExecutionLevels(graph, issues);
+  return { valid: issues.length === 0, issues, levels };
+}
+function buildExecutionLevels(graph, issues) {
+  const dependencies = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    dependencies.set(node.id, new Set(node.dependsOn ?? []));
+  }
+  for (const edge of graph.edges ?? []) {
+    if (dependencies.has(edge.to)) {
+      dependencies.get(edge.to).add(edge.from);
+    }
+  }
+  const completed = /* @__PURE__ */ new Set();
+  const levels = [];
+  while (completed.size < dependencies.size) {
+    const level = [...dependencies.entries()].filter(([id, deps]) => !completed.has(id) && [...deps].every((dep) => completed.has(dep))).map(([id]) => id);
+    if (level.length === 0) {
+      const remaining = [...dependencies.keys()].filter((id) => !completed.has(id));
+      issues.push({
+        code: "cycle",
+        message: `Graph contains a cycle involving: ${remaining.join(", ")}.`
+      });
+      return levels;
+    }
+    for (const id of level) completed.add(id);
+    levels.push(level);
+  }
+  return levels;
+}
+function cloneArtifact(artifact) {
+  return {
+    ...artifact,
+    metadata: artifact.metadata ? { ...artifact.metadata } : void 0
+  };
+}
+
 // src/agents/executor.ts
 var AgentExecutor = class {
   constructor(provider, toolRegistry) {
@@ -43240,6 +43379,7 @@ var AgentExecutor = class {
    */
   async execute(agent, task) {
     const startTime = Date.now();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const toolsUsed = /* @__PURE__ */ new Set();
     const messages = [
       {
@@ -43250,6 +43390,8 @@ var AgentExecutor = class {
     const agentToolDefs = this.getToolDefinitionsForAgent(agent.allowedTools);
     let turn = 0;
     let totalTokens = 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
     while (turn < agent.maxTurns) {
       turn++;
       try {
@@ -43258,16 +43400,23 @@ var AgentExecutor = class {
           system: agent.systemPrompt
         });
         const usage = response.usage;
+        totalInputTokens += usage?.inputTokens || 0;
+        totalOutputTokens += usage?.outputTokens || 0;
         totalTokens += (usage?.inputTokens || 0) + (usage?.outputTokens || 0);
         if (response.stopReason !== "tool_use" || response.toolCalls.length === 0) {
-          return {
+          return this.toAgentResult({
+            agent,
+            task,
             output: response.content,
             success: true,
             turns: turn,
             toolsUsed: Array.from(toolsUsed),
             tokensUsed: totalTokens,
-            duration: Date.now() - startTime
-          };
+            inputTokens: totalInputTokens,
+            outputTokens: totalOutputTokens,
+            duration: Date.now() - startTime,
+            startedAt
+          });
         }
         const assistantContent = [];
         if (response.content) {
@@ -43313,24 +43462,38 @@ var AgentExecutor = class {
           content: toolResults
         });
       } catch (error) {
-        return {
-          output: `Agent error on turn ${turn}: ${error instanceof Error ? error.message : String(error)}`,
+        const output2 = `Agent error on turn ${turn}: ${error instanceof Error ? error.message : String(error)}`;
+        return this.toAgentResult({
+          agent,
+          task,
+          output: output2,
           success: false,
           turns: turn,
           toolsUsed: Array.from(toolsUsed),
           tokensUsed: totalTokens,
-          duration: Date.now() - startTime
-        };
+          inputTokens: totalInputTokens,
+          outputTokens: totalOutputTokens,
+          duration: Date.now() - startTime,
+          startedAt,
+          error: output2
+        });
       }
     }
-    return {
-      output: "Agent reached maximum turns without completing task",
+    const output = "Agent reached maximum turns without completing task";
+    return this.toAgentResult({
+      agent,
+      task,
+      output,
       success: false,
       turns: turn,
       toolsUsed: Array.from(toolsUsed),
       tokensUsed: totalTokens,
-      duration: Date.now() - startTime
-    };
+      inputTokens: totalInputTokens,
+      outputTokens: totalOutputTokens,
+      duration: Date.now() - startTime,
+      startedAt,
+      error: output
+    });
   }
   /**
    * Build task prompt with context
@@ -43356,7 +43519,36 @@ Complete this task autonomously using the available tools. When done, provide a
     if (allowedToolNames.length === 0) return allDefs;
     return allDefs.filter((def) => allowedToolNames.includes(def.name));
   }
+  toAgentResult(input) {
+    const structuredResult = normalizeAgentRunResult({
+      id: `${input.task.id}-${Date.now().toString(36)}`,
+      taskId: input.task.id,
+      role: normalizeRole(input.agent.role),
+      success: input.success,
+      output: input.output,
+      turns: input.turns,
+      toolsUsed: input.toolsUsed,
+      durationMs: input.duration,
+      startedAt: input.startedAt,
+      usage: { inputTokens: input.inputTokens, outputTokens: input.outputTokens },
+      error: input.error,
+      metadata: { legacyRole: input.agent.role }
+    });
+    return {
+      output: input.output,
+      success: input.success,
+      turns: input.turns,
+      toolsUsed: input.toolsUsed,
+      tokensUsed: input.tokensUsed,
+      duration: input.duration,
+      artifacts: structuredResult.artifacts,
+      structuredResult
+    };
+  }
 };
+function normalizeRole(role) {
+  return role === "researcher" || role === "architect" || role === "editor" || role === "coder" || role === "tester" || role === "reviewer" || role === "optimizer" || role === "planner" ? role : "coder";
+}
 var AGENT_ROLES = {
   researcher: {
     role: "researcher",
@@ -44194,6 +44386,9 @@ var testTools = [runTestsTool, getCoverageTool, runTestFileTool];
 // src/tools/index.ts
 init_registry4();
 
+// src/tools/profiles.ts
+init_registry4();
+
 // src/tools/file.ts
 init_registry4();
 init_errors();
@@ -45820,11 +46015,15 @@ var AgentManager = class extends EventEmitter {
       failedAgent.status = "failed";
       failedAgent.error = error;
       failedAgent.completedAt = /* @__PURE__ */ new Date();
-      return {
+      return this.buildResult({
         agent: failedAgent,
         success: false,
-        output: error
-      };
+        output: error,
+        turns: 0,
+        toolsUsed: [],
+        startedAt: failedAgent.createdAt.toISOString(),
+        usage: { inputTokens: 0, outputTokens: 0 }
+      });
     }
     const agent = this.createAgent(type, task);
     this.activeAgents.set(agent.id, agent);
@@ -45876,11 +46075,15 @@ var AgentManager = class extends EventEmitter {
       options.onStatusChange?.(agent);
       this.logger.error(`Agent ${agent.id} failed unexpectedly`, { error: errorMessage });
       this.emitEvent("fail", agent);
-      return {
+      return this.buildResult({
         agent,
         success: false,
-        output: errorMessage
-      };
+        output: errorMessage,
+        turns: 0,
+        toolsUsed: [],
+        startedAt: agent.createdAt.toISOString(),
+        usage: { inputTokens: 0, outputTokens: 0 }
+      });
     }
   }
   /**
@@ -46001,6 +46204,8 @@ var AgentManager = class extends EventEmitter {
     let finalOutput = "";
     let iteration = 0;
     const maxTurns = config.maxTurns ?? 10;
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const toolsUsed = /* @__PURE__ */ new Set();
     while (iteration < maxTurns) {
       iteration++;
       if (options.signal?.aborted) {
@@ -46009,12 +46214,15 @@ var AgentManager = class extends EventEmitter {
         agent.completedAt = /* @__PURE__ */ new Date();
         this.moveToCompleted(agent.id);
         options.onStatusChange?.(agent);
-        return {
+        return this.buildResult({
           agent,
           success: false,
           output: "Agent execution was aborted",
+          turns: iteration,
+          toolsUsed: Array.from(toolsUsed),
+          startedAt,
           usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens }
-        };
+        });
       }
       const response = await this.provider.chatWithTools(messages, {
         system: config.systemPrompt,
@@ -46031,7 +46239,7 @@ var AgentManager = class extends EventEmitter {
         messages.push({ role: "assistant", content: response.content });
         break;
       }
-      const toolResults = await this.executeToolCalls(response.toolCalls, config);
+      const toolResults = await this.executeToolCalls(response.toolCalls, config, toolsUsed);
       const toolUses = response.toolCalls.map((tc) => ({
         type: "tool_use",
         id: tc.id,
@@ -46055,12 +46263,15 @@ var AgentManager = class extends EventEmitter {
       iterations: iteration,
       outputLength: finalOutput.length
     });
-    return {
+    return this.buildResult({
       agent,
       success: true,
       output: finalOutput,
+      turns: iteration,
+      toolsUsed: Array.from(toolsUsed),
+      startedAt,
       usage: { inputTokens: totalInputTokens, outputTokens: totalOutputTokens }
-    };
+    });
   }
   /**
    * Get tool definitions filtered for the agent's allowed tools
@@ -46073,10 +46284,11 @@ var AgentManager = class extends EventEmitter {
   /**
    * Execute tool calls and return results
    */
-  async executeToolCalls(toolCalls, config) {
+  async executeToolCalls(toolCalls, config, toolsUsed) {
     const results = [];
     const allowedTools = new Set(config.tools);
     for (const toolCall of toolCalls) {
+      toolsUsed.add(toolCall.name);
       if (!allowedTools.has(toolCall.name)) {
         results.push({
           type: "tool_result",
@@ -46117,6 +46329,33 @@ var AgentManager = class extends EventEmitter {
       this.abortControllers.delete(agentId);
     }
   }
+  buildResult(input) {
+    const structuredResult = normalizeAgentRunResult({
+      id: `${input.agent.id}-run`,
+      taskId: input.agent.id,
+      role: agentTypeToRuntimeRole(input.agent.type),
+      success: input.success,
+      output: input.output,
+      turns: input.turns,
+      toolsUsed: input.toolsUsed,
+      usage: input.usage,
+      startedAt: input.startedAt,
+      durationMs: input.agent.completedAt ? input.agent.completedAt.getTime() - input.agent.createdAt.getTime() : 0,
+      status: input.success ? "completed" : "failed",
+      error: input.success ? void 0 : input.agent.error,
+      metadata: { agentType: input.agent.type }
+    });
+    return {
+      agent: input.agent,
+      success: input.success,
+      output: input.output,
+      artifacts: structuredResult.artifacts,
+      structuredResult,
+      toolsUsed: input.toolsUsed,
+      turns: input.turns,
+      usage: input.usage
+    };
+  }
   /**
    * Emit an agent event
    */
@@ -46126,6 +46365,31 @@ var AgentManager = class extends EventEmitter {
     this.emit("agent", event);
   }
 };
+function agentTypeToRuntimeRole(type) {
+  switch (type) {
+    case "explore":
+      return "researcher";
+    case "plan":
+      return "planner";
+    case "test":
+    case "e2e":
+    case "tdd":
+      return "tester";
+    case "debug":
+    case "refactor":
+      return "coder";
+    case "review":
+      return "reviewer";
+    case "architect":
+      return "architect";
+    case "security":
+      return "security";
+    case "docs":
+      return "docs";
+    case "database":
+      return "database";
+  }
+}
 
 // src/agents/provider-bridge.ts
 var agentProvider = null;
@@ -57522,7 +57786,8 @@ var DESTRUCTIVE_TOOL_NAMES = /* @__PURE__ */ new Set([
   "delete_file",
   "restore_checkpoint",
   "git_commit",
-  "git_push"
+  "git_push",
+  "request_human_escalation"
 ]);
 function riskForTool(tool) {
   if (READ_ONLY_TOOL_NAMES.has(tool.name)) return "read-only";
@@ -57667,7 +57932,32 @@ function cloneWorkflow(workflow) {
     steps: workflow.steps.map((step) => ({
       ...step,
       requiredTools: [...step.requiredTools]
-    }))
+    })),
+    nodes: workflow.nodes?.map((node) => ({
+      ...node,
+      dependsOn: node.dependsOn ? [...node.dependsOn] : void 0,
+      requiredTools: node.requiredTools ? [...node.requiredTools] : void 0,
+      gates: node.gates ? [...node.gates] : void 0,
+      retryPolicy: node.retryPolicy ? { ...node.retryPolicy } : void 0
+    })),
+    edges: workflow.edges?.map((edge) => ({ ...edge })),
+    gates: workflow.gates?.map((gate) => ({ ...gate })),
+    retryPolicy: workflow.retryPolicy ? { ...workflow.retryPolicy } : void 0
+  };
+}
+function workflowToAgentGraph(workflow) {
+  const nodes = workflow.nodes ?? workflow.steps.map((step, index) => ({
+    id: step.id,
+    description: step.description,
+    requiredTools: [...step.requiredTools],
+    risk: step.risk,
+    dependsOn: index > 0 ? [workflow.steps[index - 1].id] : []
+  }));
+  return {
+    nodes,
+    edges: workflow.edges,
+    gates: workflow.gates,
+    parallelism: workflow.parallelism
   };
 }
 var WorkflowCatalog = class {
@@ -57678,6 +57968,12 @@ var WorkflowCatalog = class {
     }
   }
   register(workflow) {
+    const validation = validateAgentGraph(workflowToAgentGraph(workflow));
+    if (!validation.valid) {
+      throw new Error(
+        `Invalid workflow graph for '${workflow.id}': ${validation.issues.map((issue) => issue.message).join("; ")}`
+      );
+    }
     this.workflows.set(workflow.id, cloneWorkflow(workflow));
   }
   get(id) {
@@ -57703,7 +57999,8 @@ var WorkflowCatalog = class {
       workflowId,
       planId: plan.id,
       replayable: workflow.replayable,
-      checks: workflow.checks
+      checks: workflow.checks,
+      graphLevels: validateAgentGraph(workflowToAgentGraph(workflow)).levels
     });
     return plan;
   }
@@ -58298,6 +58595,118 @@ async function createAgentRuntime(options) {
   return runtime;
 }
 
+// src/runtime/tool-calling-turn-runner.ts
+function runtimeWithTools(runtime) {
+  if (runtime && typeof runtime === "object" && "executeTool" in runtime && typeof runtime.executeTool === "function") {
+    return runtime;
+  }
+  throw new Error("ToolCallingRuntimeTurnRunner requires a runtime with executeTool().");
+}
+function toolResultToContent(result) {
+  if (!result.success) {
+    return `Error: ${result.error ?? "Tool failed."}`;
+  }
+  if (typeof result.output === "string") return result.output;
+  return JSON.stringify(result.output ?? null);
+}
+var ToolCallingRuntimeTurnRunner = class {
+  maxToolIterations;
+  constructor(options = {}) {
+    this.maxToolIterations = options.maxToolIterations ?? 10;
+  }
+  async run(input, context) {
+    const runtime = runtimeWithTools(context.runtime);
+    const messages = [
+      ...context.session.messages,
+      {
+        role: "user",
+        content: input.content
+      }
+    ];
+    const tools = context.toolRegistry.getToolDefinitionsForLLM();
+    const confirmedTools = new Set(input.confirmedTools ?? []);
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let lastModel = input.options?.model ?? context.provider.id;
+    for (let iteration = 0; iteration < this.maxToolIterations; iteration++) {
+      const response = await context.provider.chatWithTools(messages, {
+        tools,
+        model: input.options?.model,
+        maxTokens: input.options?.maxTokens,
+        temperature: input.options?.temperature,
+        stopSequences: input.options?.stopSequences,
+        system: context.session.instructions ?? input.options?.system,
+        timeout: input.options?.timeout,
+        signal: input.options?.signal,
+        thinking: input.options?.thinking
+      });
+      inputTokens += response.usage.inputTokens;
+      outputTokens += response.usage.outputTokens;
+      lastModel = response.model;
+      if (response.stopReason !== "tool_use" || response.toolCalls.length === 0) {
+        return {
+          sessionId: context.session.id,
+          content: response.content,
+          usage: { inputTokens, outputTokens },
+          model: response.model,
+          mode: context.session.mode
+        };
+      }
+      const assistantContent = [];
+      if (response.content.trim().length > 0) {
+        assistantContent.push({ type: "text", text: response.content });
+      }
+      for (const toolCall of response.toolCalls) {
+        assistantContent.push({
+          type: "tool_use",
+          id: toolCall.id,
+          name: toolCall.name,
+          input: toolCall.input,
+          geminiThoughtSignature: toolCall.geminiThoughtSignature
+        });
+      }
+      messages.push({
+        role: "assistant",
+        content: assistantContent
+      });
+      const toolResults = [];
+      for (const toolCall of response.toolCalls) {
+        const result = await runtime.executeTool({
+          sessionId: context.session.id,
+          mode: context.session.mode,
+          toolName: toolCall.name,
+          input: toolCall.input,
+          confirmed: confirmedTools.has(toolCall.name),
+          metadata: input.metadata
+        });
+        toolResults.push({
+          type: "tool_result",
+          tool_use_id: toolCall.id,
+          content: toolResultToContent(result),
+          is_error: !result.success
+        });
+      }
+      messages.push({
+        role: "user",
+        content: toolResults
+      });
+    }
+    return {
+      sessionId: context.session.id,
+      content: "The tool-calling runtime reached its maximum tool iteration budget.",
+      usage: { inputTokens, outputTokens },
+      model: lastModel,
+      mode: context.session.mode
+    };
+  }
+};
+function createToolCallingRuntimeTurnRunner(options) {
+  return new ToolCallingRuntimeTurnRunner(options);
+}
+
+// src/runtime/blueprints.ts
+init_registry4();
+
 // src/cli/repl/index.ts
 init_version();
 init_trust_store();
@@ -60132,12 +60541,43 @@ ${stdinContent}
       model: session.config.provider.model || void 0,
       provider,
       eventLogPath: path39__default.join(options.projectPath, ".coco", "events", `${session.id}.jsonl`),
+      turnRunner: options.useRuntimeRunner ? createToolCallingRuntimeTurnRunner() : void 0,
       publishToGlobalBridge: true
     });
     session.runtime = runtime;
     const toolRegistry = runtime.toolRegistry;
     await loadAllowedPaths(options.projectPath);
     await initializeContextManager(session, provider);
+    if (options.useRuntimeRunner) {
+      const runtimeSession = runtime.createSession({
+        id: session.id,
+        mode: "build",
+        instructions: session.config.agent.systemPrompt || void 0,
+        metadata: {
+          surface: "cli",
+          product: "coco-code",
+          execution: "headless-runtime-runner"
+        }
+      });
+      const result2 = await runtime.runTurn({
+        sessionId: runtimeSession.id,
+        content: task,
+        metadata: { surface: "cli", product: "coco-code" }
+      });
+      const events = runtime.eventLog.list();
+      const headlessResult2 = {
+        success: true,
+        output: result2.content,
+        toolsExecuted: events.filter((event) => event.type === "tool.completed").length,
+        usage: result2.usage
+      };
+      if (options.outputFormat === "json") {
+        process.stdout.write(JSON.stringify(headlessResult2, null, 2) + "\n");
+      } else {
+        process.stdout.write(result2.content + "\n");
+      }
+      return headlessResult2;
+    }
     const result = await executeAgentTurn(session, task, provider, toolRegistry, {
       skipConfirmation: true,
       // No interactive confirmations in headless mode
@@ -60203,7 +60643,10 @@ program.command("setup").description("Configure AI provider and API key").action
     console.log("\n\u274C Setup cancelled.");
   }
 });
-program.command("chat", { isDefault: true }).description("Start interactive chat session with the agent").option("-m, --model <model>", "LLM model to use").option("--provider <provider>", "LLM provider (anthropic, openai, codex, gemini, kimi)").option("--editor-model <model>", "Cheap model for file edits (architect/editor split)").option("--weak-model <model>", "Cheap model for background tasks (compaction, summaries)").option("-p, --path <path>", "Project path", process.cwd()).option("-P, --print [task]", "Headless mode: run task and print output (no interactive UI)").option("--output <format>", "Output format for headless mode (text or json)", "text").option("--setup", "Run setup wizard before starting").action(
+program.command("chat", { isDefault: true }).description("Start interactive chat session with the agent").option("-m, --model <model>", "LLM model to use").option("--provider <provider>", "LLM provider (anthropic, openai, codex, gemini, kimi)").option("--editor-model <model>", "Cheap model for file edits (architect/editor split)").option("--weak-model <model>", "Cheap model for background tasks (compaction, summaries)").option("-p, --path <path>", "Project path", process.cwd()).option("-P, --print [task]", "Headless mode: run task and print output (no interactive UI)").option(
+  "--runtime-runner",
+  "Experimental: run headless tasks through the reusable runtime tool-calling runner"
+).option("--output <format>", "Output format for headless mode (text or json)", "text").option("--setup", "Run setup wizard before starting").action(
   async (options) => {
     if (options.setup) {
       const result = await runOnboardingV2();
@@ -60220,6 +60663,7 @@ program.command("chat", { isDefault: true }).description("Start interactive chat
         task,
         projectPath: options.path,
         outputFormat: options.output === "json" ? "json" : "text",
+        useRuntimeRunner: options.runtimeRunner === true,
         config: {
           provider: {
             type: providerType,