🤖 feat: unify bash into task_* tools

Change-Id: Ic4a03eb4953916443fcc074412498e0853c0ff17
Signed-off-by: Thomas Kosiewski <tk@coder.com>

Author: ThomasK33

src/browser/components/tools/TaskToolCall.tsx

@@ -162,6 +162,9 @@ const TaskId: React.FC<{ id: string; className?: string }> = ({ id, className })
 // TASK TOOL CALL (spawn sub-agent)
 // ═══════════════════════════════════════════════════════════════════════════════
 
+function isBashTaskArgs(args: TaskToolArgs): args is Extract<TaskToolArgs, { kind: "bash" }> {
+  return (args as { kind?: unknown }).kind === "bash";
+}
 interface TaskToolCallProps {
   args: TaskToolArgs;
   result?: TaskToolSuccessResult;
@@ -174,27 +177,44 @@ export const TaskToolCall: React.FC<TaskToolCallProps> = ({ args, result, status
   const { expanded, toggleExpanded } = useToolExpansion(hasReport);
 
   const isBackground = args.run_in_background ?? false;
-  const agentType = args.subagent_type;
-  const prompt = args.prompt;
-  const title = args.title;
+
+  let isBashTask: boolean;
+  let title: string;
+  let promptOrScript: string;
+  let kindBadge: React.ReactNode;
+
+  if (isBashTaskArgs(args)) {
+    isBashTask = true;
+    title = args.display_name;
+    promptOrScript = args.script;
+    kindBadge = <AgentTypeBadge type="bash" />;
+  } else {
+    isBashTask = false;
+    title = args.title;
+    promptOrScript = args.prompt;
+    kindBadge = <AgentTypeBadge type={args.subagent_type} />;
+  }
 
   // Derive task state from result
   const taskId = result?.taskId;
   const taskStatus = result?.status;
   const reportMarkdown = result?.status === "completed" ? result.reportMarkdown : undefined;
   const reportTitle = result?.status === "completed" ? result.title : undefined;
+  const exitCode = result?.status === "completed" ? result.exitCode : undefined;
 
-  // Show preview of prompt (first line or truncated)
-  const promptPreview =
-    prompt.length > 60 ? prompt.slice(0, 60).trim() + "…" : prompt.split("\n")[0];
+  // Show preview (first line or truncated)
+  const preview =
+    promptOrScript.length > 60
+      ? promptOrScript.slice(0, 60).trim() + "…"
+      : promptOrScript.split("\n")[0];
 
   return (
     <ToolContainer expanded={expanded}>
       <ToolHeader onClick={toggleExpanded}>
         <ExpandIcon expanded={expanded}>▶</ExpandIcon>
         <TaskIcon toolName="task" />
         <ToolName>task</ToolName>
-        <AgentTypeBadge type={agentType} />
+        {kindBadge}
         {isBackground && (
           <span className="text-backgrounded text-[10px] font-medium">background</span>
         )}
@@ -205,26 +225,33 @@ export const TaskToolCall: React.FC<TaskToolCallProps> = ({ args, result, status
         <ToolDetails>
           {/* Task info surface */}
           <div className="task-surface mt-1 rounded-md p-3">
-            <div className="task-divider mb-2 flex items-center gap-2 border-b pb-2">
+            <div className="task-divider mb-2 flex flex-wrap items-center gap-2 border-b pb-2">
               <span className="text-task-mode text-[12px] font-semibold">
                 {reportTitle ?? title}
               </span>
               {taskId && <TaskId id={taskId} />}
               {taskStatus && <TaskStatusBadge status={taskStatus} />}
+              {exitCode !== undefined && (
+                <span className="text-muted text-[10px]">exit {exitCode}</span>
+              )}
             </div>
 
-            {/* Prompt section */}
+            {/* Prompt / script */}
             <div className="mb-2">
-              <div className="text-muted mb-1 text-[10px] tracking-wide uppercase">Prompt</div>
-              <div className="text-foreground bg-code-bg max-h-[100px] overflow-y-auto rounded-sm p-2 text-[11px] break-words whitespace-pre-wrap">
-                {prompt}
+              <div className="text-muted mb-1 text-[10px] tracking-wide uppercase">
+                {isBashTask ? "Script" : "Prompt"}
+              </div>
+              <div className="text-foreground bg-code-bg max-h-[140px] overflow-y-auto rounded-sm p-2 text-[11px] break-words whitespace-pre-wrap">
+                {promptOrScript}
               </div>
             </div>
 
             {/* Report section */}
             {reportMarkdown && (
               <div className="task-divider border-t pt-2">
-                <div className="text-muted mb-1 text-[10px] tracking-wide uppercase">Report</div>
+                <div className="text-muted mb-1 text-[10px] tracking-wide uppercase">
+                  {isBashTask ? "Output" : "Report"}
+                </div>
                 <div className="text-[11px]">
                   <MarkdownRenderer content={reportMarkdown} />
                 </div>
@@ -243,7 +270,7 @@ export const TaskToolCall: React.FC<TaskToolCallProps> = ({ args, result, status
       )}
 
       {/* Collapsed preview */}
-      {!expanded && <div className="text-muted mt-1 truncate text-[10px]">{promptPreview}</div>}
+      {!expanded && <div className="text-muted mt-1 truncate text-[10px]">{preview}</div>}
     </ToolContainer>
   );
 };
@@ -270,6 +297,12 @@ export const TaskAwaitToolCall: React.FC<TaskAwaitToolCallProps> = ({
   const timeoutSecs = args.timeout_secs;
   const results = result?.results ?? [];
 
+  const showConfigInfo =
+    taskIds !== undefined ||
+    timeoutSecs !== undefined ||
+    args.filter !== undefined ||
+    args.filter_exclude === true;
+
   // Summary for header
   const completedCount = results.filter((r) => r.status === "completed").length;
   const totalCount = results.length;
@@ -292,10 +325,12 @@ export const TaskAwaitToolCall: React.FC<TaskAwaitToolCallProps> = ({
         <ToolDetails>
           <div className="task-surface mt-1 rounded-md p-3">
             {/* Config info */}
-            {(taskIds ?? timeoutSecs) && (
+            {showConfigInfo && (
               <div className="task-divider text-muted mb-2 flex flex-wrap gap-2 border-b pb-2 text-[10px]">
-                {taskIds && <span>Waiting for: {taskIds.length} task(s)</span>}
-                {timeoutSecs && <span>Timeout: {timeoutSecs}s</span>}
+                {taskIds !== undefined && <span>Waiting for: {taskIds.length} task(s)</span>}
+                {timeoutSecs !== undefined && <span>Timeout: {timeoutSecs}s</span>}
+                {args.filter !== undefined && <span>Filter: {args.filter}</span>}
+                {args.filter_exclude === true && <span>Exclude: true</span>}
               </div>
             )}
 
@@ -329,20 +364,35 @@ const TaskAwaitResult: React.FC<{
   const reportMarkdown = isCompleted ? result.reportMarkdown : undefined;
   const title = isCompleted ? result.title : undefined;
 
+  const output = "output" in result ? result.output : undefined;
+  const note = "note" in result ? result.note : undefined;
+  const exitCode = "exitCode" in result ? result.exitCode : undefined;
+  const elapsedMs = "elapsed_ms" in result ? result.elapsed_ms : undefined;
+
   return (
     <div className="bg-code-bg rounded-sm p-2">
-      <div className="mb-1 flex items-center gap-2">
+      <div className="mb-1 flex flex-wrap items-center gap-2">
         <TaskId id={result.taskId} />
         <TaskStatusBadge status={result.status} />
         {title && <span className="text-foreground text-[11px] font-medium">{title}</span>}
+        {exitCode !== undefined && <span className="text-muted text-[10px]">exit {exitCode}</span>}
+        {elapsedMs !== undefined && <span className="text-muted text-[10px]">{elapsedMs}ms</span>}
       </div>
 
+      {!isCompleted && output && output.length > 0 && (
+        <div className="text-foreground bg-code-bg max-h-[140px] overflow-y-auto rounded-sm p-2 text-[11px] break-words whitespace-pre-wrap">
+          {output}
+        </div>
+      )}
+
       {reportMarkdown && (
         <div className="mt-2 text-[11px]">
           <MarkdownRenderer content={reportMarkdown} />
         </div>
       )}
 
+      {note && <div className="text-muted mt-1 text-[10px]">{note}</div>}
+
       {"error" in result && result.error && (
         <div className="text-danger mt-1 text-[11px]">{result.error}</div>
       )}

src/common/utils/tools/toolDefinitions.ts

@@ -94,7 +94,7 @@ const SubagentTypeSchema = z.preprocess(
   z.enum(BUILT_IN_SUBAGENT_TYPES)
 );
 
-export const TaskToolArgsSchema = z
+const TaskToolAgentArgsSchema = z
   .object({
     subagent_type: SubagentTypeSchema,
     prompt: z.string().min(1),
@@ -103,6 +103,18 @@ export const TaskToolArgsSchema = z
   })
   .strict();
 
+const TaskToolBashArgsSchema = z
+  .object({
+    kind: z.literal("bash"),
+    script: z.string().min(1),
+    timeout_secs: z.number().positive(),
+    run_in_background: z.boolean().default(false),
+    display_name: z.string().min(1),
+  })
+  .strict();
+
+export const TaskToolArgsSchema = z.union([TaskToolAgentArgsSchema, TaskToolBashArgsSchema]);
+
 export const TaskToolQueuedResultSchema = z
   .object({
     status: z.enum(["queued", "running"]),
@@ -117,6 +129,8 @@ export const TaskToolCompletedResultSchema = z
     reportMarkdown: z.string(),
     title: z.string().optional(),
     agentType: z.string().optional(),
+    exitCode: z.number().optional(),
+    note: z.string().optional(),
   })
   .strict();
 
@@ -137,12 +151,28 @@ export const TaskAwaitToolArgsSchema = z
       .describe(
         "List of task IDs to await. When omitted, waits for all active descendant tasks of the current workspace."
       ),
+    filter: z
+      .string()
+      .optional()
+      .describe(
+        "Optional regex to filter bash task output lines. By default, only matching lines are returned. " +
+          "When filter_exclude is true, matching lines are excluded instead. " +
+          "Non-matching lines are discarded and cannot be retrieved later."
+      ),
+    filter_exclude: z
+      .boolean()
+      .optional()
+      .describe(
+        "When true, lines matching 'filter' are excluded instead of kept. " +
+          "Requires 'filter' to be set."
+      ),
     timeout_secs: z
       .number()
-      .positive()
+      .min(0)
       .optional()
       .describe(
         "Maximum time to wait in seconds for each task. " +
+          "For bash tasks, this waits for NEW output (or process exit). " +
           "If exceeded, the result returns status=queued|running|awaiting_report (task is still active). " +
           "Optional, defaults to 10 minutes."
       ),
@@ -155,13 +185,20 @@ export const TaskAwaitToolCompletedResultSchema = z
     taskId: z.string(),
     reportMarkdown: z.string(),
     title: z.string().optional(),
+    output: z.string().optional(),
+    elapsed_ms: z.number().optional(),
+    exitCode: z.number().optional(),
+    note: z.string().optional(),
   })
   .strict();
 
 export const TaskAwaitToolActiveResultSchema = z
   .object({
     status: z.enum(["queued", "running", "awaiting_report"]),
     taskId: z.string(),
+    output: z.string().optional(),
+    elapsed_ms: z.number().optional(),
+    note: z.string().optional(),
   })
   .strict();
 
@@ -513,31 +550,35 @@ export const TOOL_DEFINITIONS = {
   },
   task: {
     description:
-      "Spawn a sub-agent task in a child workspace. " +
-      'Use this to delegate work to specialized presets like "explore" (read-only investigation) or "exec" (general-purpose coding in a child workspace). ' +
-      "If run_in_background is false, this tool blocks until the sub-agent calls agent_report, then returns the report. " +
-      "If run_in_background is true, you can await it later with task_await.",
+      "Unified task tool for (1) spawning sub-agent tasks and (2) running bash commands. " +
+      "\n\nAgent tasks: provide subagent_type, prompt, title, run_in_background. " +
+      '\nBash tasks: set kind="bash" and provide script, timeout_secs, display_name, run_in_background. ' +
+      "\n\nIf run_in_background is false, returns a completed reportMarkdown. " +
+      "If run_in_background is true, returns a running taskId; use task_await to read incremental output and task_terminate to stop it.",
     schema: TaskToolArgsSchema,
   },
   task_await: {
     description:
-      "Wait for one or more sub-agent tasks to finish and return their reports. " +
+      "Wait for one or more tasks to produce output. " +
+      "Agent tasks return reports when completed. " +
+      "Bash tasks return incremental output while running and a final reportMarkdown when they exit. " +
       "Use this tool to WAIT; do not poll task_list in a loop to wait for task completion (that is misuse and wastes tool calls). " +
       "This is similar to Promise.allSettled(): you always get per-task results. " +
       "Possible statuses: completed, queued, running, awaiting_report, not_found, invalid_scope, error.",
     schema: TaskAwaitToolArgsSchema,
   },
   task_terminate: {
     description:
-      "Terminate one or more sub-agent tasks immediately. " +
-      "This stops their AI streams and deletes their workspaces (best-effort). " +
+      "Terminate one or more tasks immediately (sub-agent tasks or background bash tasks). " +
+      "For sub-agent tasks, this stops their AI streams and deletes their workspaces (best-effort). " +
       "No report will be delivered; any in-progress work is discarded. " +
       "If the task has descendant sub-agent tasks, they are terminated too.",
     schema: TaskTerminateToolArgsSchema,
   },
   task_list: {
     description:
-      "List descendant sub-agent tasks for the current workspace, including their status and metadata. " +
+      "List descendant tasks for the current workspace, including status + metadata. " +
+      "This includes sub-agent tasks and background bash tasks. " +
       "Use this after compaction or interruptions to rediscover which tasks are still active. " +
       "This is a discovery tool, NOT a waiting mechanism: if you need to wait for tasks to finish, call task_await (optionally omit task_ids to await all active descendant tasks).",
     schema: TaskListToolArgsSchema,
@@ -961,10 +1002,6 @@ export function getAvailableTools(
 
   // Base tools available for all models
   const baseTools = [
-    "bash",
-    "bash_output",
-    "bash_background_list",
-    "bash_background_terminate",
     "file_read",
     "agent_skill_read",
     "agent_skill_read_file",

src/common/utils/tools/tools.ts

@@ -20,6 +20,7 @@ import { createAgentSkillReadFileTool } from "@/node/services/tools/agent_skill_
 import { createAgentReportTool } from "@/node/services/tools/agent_report";
 import { wrapWithInitWait } from "@/node/services/tools/wrapWithInitWait";
 import { log } from "@/node/services/log";
+import { getAvailableTools } from "@/common/utils/tools/toolDefinitions";
 import { sanitizeMCPToolsForOpenAI } from "@/common/utils/tools/schemaSanitizer";
 
 import type { Runtime } from "@/node/runtime/Runtime";
@@ -139,21 +140,26 @@ export async function getToolsForModel(
     // to leave repository in broken state due to issues with concurrent file modifications
     // and line number miscalculations. Use file_edit_replace_string instead.
     // file_edit_replace_lines: wrap(createFileEditReplaceLinesTool(config)),
+
+    // Unified task abstraction (agent + bash)
+    task: wrap(createTaskTool(config)),
+    task_await: wrap(createTaskAwaitTool(config)),
+    task_terminate: wrap(createTaskTerminateTool(config)),
+    task_list: wrap(createTaskListTool(config)),
+
+    // Legacy bash tools (deprecated: prefer task(kind="bash"))
     bash: wrap(createBashTool(config)),
     bash_output: wrap(createBashOutputTool(config)),
     bash_background_list: wrap(createBashBackgroundListTool(config)),
     bash_background_terminate: wrap(createBashBackgroundTerminateTool(config)),
+
     web_fetch: wrap(createWebFetchTool(config)),
   };
 
   // Non-runtime tools execute immediately (no init wait needed)
   const nonRuntimeTools: Record<string, Tool> = {
     ...(config.mode === "plan" ? { ask_user_question: createAskUserQuestionTool(config) } : {}),
     propose_plan: createProposePlanTool(config),
-    task: createTaskTool(config),
-    task_await: createTaskAwaitTool(config),
-    task_terminate: createTaskTerminateTool(config),
-    task_list: createTaskListTool(config),
     ...(config.enableAgentReport ? { agent_report: createAgentReportTool(config) } : {}),
     todo_write: createTodoWriteTool(config),
     todo_read: createTodoReadTool(config),
@@ -220,6 +226,19 @@ export async function getToolsForModel(
     log.error(`No web search tools available for ${provider}:`, error);
   }
 
+  // Filter tools to the canonical allowlist so system prompt + toolset stay in sync.
+  // Include MCP tools even if they're not in getAvailableTools().
+  const allowlistedToolNames = new Set(
+    getAvailableTools(modelString, config.mode, { enableAgentReport: config.enableAgentReport })
+  );
+  for (const toolName of Object.keys(mcpTools ?? {})) {
+    allowlistedToolNames.add(toolName);
+  }
+
+  allTools = Object.fromEntries(
+    Object.entries(allTools).filter(([toolName]) => allowlistedToolNames.has(toolName))
+  );
+
   // Apply tool-specific instructions if provided
   if (toolInstructions) {
     const augmentedTools: Record<string, Tool> = {};