🤖 feat: show task kind and spawn intent in single-task task_await summary

src/browser/features/Tools/TaskToolCall.test.tsx

@@ -4,7 +4,9 @@ import { GlobalWindow } from "happy-dom";
 
 import { TooltipProvider } from "@/browser/components/Tooltip/Tooltip";
 
+import type { DisplayedMessage } from "@/common/types/message";
 import type { FrontendWorkspaceMetadata } from "@/common/types/workspace";
+import { computeTaskReportLinking } from "@/browser/utils/messages/taskReportLinking";
 
 let workspaceContextMock: {
   workspaceMetadata: Map<string, FrontendWorkspaceMetadata>;
@@ -69,6 +71,23 @@ function createWorkspaceMetadata(
 const taskAwaitArgs = { task_ids: ["task-1"], timeout_secs: 70 };
 const TaskAwaitToolCall = getToolComponent("task_await", taskAwaitArgs);
 
+function createToolMessage(overrides: {
+  toolName: string;
+  args: unknown;
+  result?: unknown;
+}): DisplayedMessage {
+  return {
+    type: "tool",
+    id: "tool-msg-1",
+    historyId: "hist-1",
+    toolCallId: "call-1",
+    status: "completed",
+    isPartial: false,
+    historySequence: 1,
+    ...overrides,
+  };
+}
+
 function renderTaskAwaitToolCall(props: Record<string, unknown> = {}) {
   return render(
     <TooltipProvider>
@@ -363,6 +382,182 @@ describe("TaskAwaitToolCall", () => {
     expect(view.getByText("Task service unavailable")).toBeDefined();
   });
 
+  test("shows bash kind and spawn model_intent for a single completed bash task", () => {
+    const bashSpawn = createToolMessage({
+      toolName: "bash",
+      args: {
+        script: "./scripts/wait_pr_ready.sh 27330",
+        display_name: "PR ready watcher",
+        model_intent: "watching PR 27330 until it is ready",
+        timeout_secs: 3600,
+        run_in_background: true,
+      },
+      result: {
+        success: true,
+        output: "Started",
+        exitCode: 0,
+        wall_duration_ms: 10,
+        taskId: "bash:pr-ready-watcher-a1b2",
+        backgroundProcessId: "pr-ready-watcher-a1b2",
+      },
+    });
+
+    const view = renderTaskAwaitToolCall({
+      status: "completed",
+      args: { task_ids: ["bash:pr-ready-watcher-a1b2"] },
+      result: {
+        results: [
+          {
+            status: "completed",
+            taskId: "bash:pr-ready-watcher-a1b2",
+            title: "PR ready watcher",
+            reportMarkdown: "exit 0",
+          },
+        ],
+      },
+      taskReportLinking: computeTaskReportLinking([bashSpawn]),
+    });
+
+    expect(view.getByText("1 task completed")).toBeDefined();
+    expect(view.getByText(/bash · Watching PR 27330 until it is ready/)).toBeDefined();
+  });
+
+  test("falls back to the task title when the spawn intent merely restates the command", () => {
+    const bashSpawn = createToolMessage({
+      toolName: "bash",
+      args: {
+        script: "git status",
+        display_name: "Repo State",
+        model_intent: "git status",
+        timeout_secs: 30,
+        run_in_background: true,
+      },
+      result: {
+        success: true,
+        output: "Started",
+        exitCode: 0,
+        wall_duration_ms: 10,
+        taskId: "bash:repo-state-a1b2",
+        backgroundProcessId: "repo-state-a1b2",
+      },
+    });
+
+    const view = renderTaskAwaitToolCall({
+      status: "completed",
+      args: { task_ids: ["bash:repo-state-a1b2"] },
+      result: {
+        results: [
+          {
+            status: "completed",
+            taskId: "bash:repo-state-a1b2",
+            title: "Repo State",
+            reportMarkdown: "exit 0",
+          },
+        ],
+      },
+      taskReportLinking: computeTaskReportLinking([bashSpawn]),
+    });
+
+    expect(view.getByText(/bash · Repo State/)).toBeDefined();
+    expect(view.queryByText(/bash · Git status/)).toBeNull();
+  });
+
+  test("falls back to the completed task title when no spawn intent is linked", () => {
+    const view = renderTaskAwaitToolCall({
+      status: "completed",
+      args: { task_ids: ["bash:pr-ready-watcher-a1b2"] },
+      result: {
+        results: [
+          {
+            status: "completed",
+            taskId: "bash:pr-ready-watcher-a1b2",
+            title: "PR ready watcher",
+            reportMarkdown: "exit 0",
+          },
+        ],
+      },
+    });
+
+    expect(view.getByText(/bash · PR ready watcher/)).toBeDefined();
+  });
+
+  test("shows agent type and title for a single completed sub-agent task", () => {
+    const taskSpawn = createToolMessage({
+      toolName: "task",
+      args: {
+        agentId: "explore",
+        prompt: "Find pagination helpers.",
+        title: "Pagination exploration",
+        run_in_background: true,
+      },
+      result: { status: "queued", taskId: "task-1" },
+    });
+
+    const view = renderTaskAwaitToolCall({
+      status: "completed",
+      result: {
+        results: [
+          {
+            status: "completed",
+            taskId: "task-1",
+            title: "Pagination exploration",
+            reportMarkdown: "Report",
+          },
+        ],
+      },
+      taskReportLinking: computeTaskReportLinking([taskSpawn]),
+    });
+
+    expect(view.getByText(/explore · Pagination exploration/)).toBeDefined();
+  });
+
+  test("prefers the spawn title over the sub-agent's own report title", () => {
+    const taskSpawn = createToolMessage({
+      toolName: "task",
+      args: {
+        agentId: "explore",
+        prompt: "Find pagination helpers.",
+        title: "Pagination exploration",
+        run_in_background: true,
+      },
+      result: { status: "queued", taskId: "task-1" },
+    });
+
+    const view = renderTaskAwaitToolCall({
+      status: "completed",
+      result: {
+        results: [
+          {
+            status: "completed",
+            taskId: "task-1",
+            title: "Pagination Helpers Investigation Complete",
+            reportMarkdown: "Report",
+          },
+        ],
+      },
+      taskReportLinking: computeTaskReportLinking([taskSpawn]),
+    });
+
+    expect(view.getByText(/explore · Pagination exploration/)).toBeDefined();
+    expect(view.queryByText(/Investigation Complete/)).toBeNull();
+  });
+
+  test("keeps multi-task completion summaries count-only", () => {
+    const view = renderTaskAwaitToolCall({
+      status: "completed",
+      args: { task_ids: ["task-1", "task-2"] },
+      result: {
+        results: [
+          { status: "completed", taskId: "task-1", title: "First task", reportMarkdown: "a" },
+          { status: "completed", taskId: "task-2", title: "Second task", reportMarkdown: "b" },
+        ],
+      },
+    });
+
+    expect(view.getByText("2 tasks completed")).toBeDefined();
+    expect(view.queryByText(/First task/)).toBeNull();
+  });
+
   test("uses valid legacy agentType for task_await rows when agentId is invalid", () => {
     workspaceContextMock = {
       workspaceMetadata: new Map([

src/browser/features/Tools/TaskToolCall.tsx

@@ -46,6 +46,7 @@ import type {
 } from "@/common/types/tools";
 import type { TaskReportLinking } from "@/browser/utils/messages/taskReportLinking";
 import { formatGitPatchArtifactSummary } from "./taskPatchSummary";
+import { sanitizeDisplayableModelIntent } from "./bashCollapsedSummary";
 import {
   formatTaskGroupCreationLabel,
   formatTaskGroupHeader,
@@ -460,6 +461,10 @@ function isWorkspaceTurnTaskHandleId(taskId: string): boolean {
   return /^wst_[a-z0-9][a-z0-9_-]*$/.test(taskId);
 }
 
+function isWorkflowRunTaskHandleId(taskId: string): boolean {
+  return taskId.startsWith("wfr_");
+}
+
 function fromBashTaskId(taskId: string): string | null {
   const prefix = "bash:";
   if (!taskId.startsWith(prefix)) {
@@ -1334,6 +1339,33 @@ export const TaskAwaitToolCall: React.FC<TaskAwaitToolCallProps> = ({
   const targetCount = totalCount > 0 ? totalCount : taskIds?.length;
   const formatTasks = (count: number) => `${count} ${count === 1 ? "task" : "tasks"}`;
 
+  // "1 task completed" alone says nothing about what finished; for single-task awaits,
+  // surface the task's kind plus its spawn intent/title in the collapsed row.
+  const firstResult = results[0];
+  let singleTaskDetail: string | undefined;
+  if (results.length === 1 && firstResult.status === "completed") {
+    const completedTaskId = firstResult.taskId;
+    const bashSpawn = taskReportLinking?.bashSpawnByTaskId.get(completedTaskId);
+    const kind = fromBashTaskId(completedTaskId)
+      ? "bash"
+      : isWorkflowRunTaskHandleId(completedTaskId)
+        ? "workflow"
+        : isWorkspaceTurnTaskHandleId(completedTaskId) ||
+            firstResult.handleKind === "workspace_turn"
+          ? "workspace"
+          : taskReportLinking?.spawnAgentTypeByTaskId.get(completedTaskId);
+    // Spawn-side intent first (bash model_intent, task spawn title); the result's own
+    // title (report heading, bash display_name) is only a fallback.
+    const description =
+      (bashSpawn
+        ? sanitizeDisplayableModelIntent(bashSpawn.modelIntent, bashSpawn.script)
+        : undefined) ??
+      trimToNonEmptyString(taskReportLinking?.spawnTitleByTaskId.get(completedTaskId)) ??
+      trimToNonEmptyString(firstResult.title);
+    const detail = [kind, description].filter((part): part is string => part != null).join(" · ");
+    singleTaskDetail = detail.length > 0 ? detail : undefined;
+  }
+
   let summaryTitle: string;
   let summaryDetail: string | undefined;
   let summaryTone: "active" | "danger" | "interrupted" | "success" | "waiting";
@@ -1369,6 +1401,7 @@ export const TaskAwaitToolCall: React.FC<TaskAwaitToolCallProps> = ({
     summaryTone = "waiting";
   } else if (completedCount > 0) {
     summaryTitle = `${formatTasks(completedCount)} completed`;
+    summaryDetail = singleTaskDetail;
     summaryTone = "success";
   } else {
     summaryTitle = "Checked task status";

src/browser/features/Tools/bashCollapsedSummary.ts

@@ -37,11 +37,7 @@ export function buildBashCollapsedSummary(
     return { kind: "command", command };
   }
 
-  const intent = sanitizeModelIntent(options.args.model_intent, command);
-  const displayIntent =
-    intent && normalizeForComparison(intent) !== normalizeForComparison(command)
-      ? intent
-      : undefined;
+  const displayIntent = sanitizeDisplayableModelIntent(options.args.model_intent, command);
   if (mode === "intent") {
     return {
       kind: "intent",
@@ -91,6 +87,17 @@ export function sanitizeModelIntent(rawIntent: unknown, command: string): string
   return capitalize(intent);
 }
 
+/** Sanitized intent, or undefined when it merely restates the command. */
+export function sanitizeDisplayableModelIntent(
+  rawIntent: unknown,
+  command: string
+): string | undefined {
+  const intent = sanitizeModelIntent(rawIntent, command);
+  return intent && normalizeForComparison(intent) !== normalizeForComparison(command)
+    ? intent
+    : undefined;
+}
+
 function getIntentOnlyFallback(args: BashToolArgs, command: string): string {
   const displayName = typeof args.display_name === "string" ? args.display_name.trim() : "";
   if (displayName && normalizeForComparison(displayName) !== normalizeForComparison(command)) {