From 3b5aafc991d2de43927983c496d9e9e57ed5b8f5 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Mon, 3 Aug 2026 15:49:20 +0000
Subject: [PATCH 1/8] =?UTF-8?q?=F0=9F=A4=96=20feat:=20expose=20sub-agent?=
 =?UTF-8?q?=20model=20and=20thinking=20level=20in=20task=20schedule=20and?=
 =?UTF-8?q?=20report?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Task tool results (spawned rows, completed reports) and the sub-agent report
envelope now carry the child's resolved modelString/thinkingLevel, and the
TaskToolCall card plus SubagentReportMessageContent render them.

---

_Generated with `mux` • Model: `anthropic:claude-fable-5` • Thinking: `xhigh`_

<!-- mux-attribution: model=anthropic:claude-fable-5 thinking=xhigh -->
---
 .../Messages/MessageRenderer.test.tsx         | 26 ++++++++
 .../Messages/SubagentReportMessageContent.tsx | 18 +++++
 .../features/Tools/TaskToolCall.stories.tsx   |  6 ++
 src/browser/features/Tools/TaskToolCall.tsx   | 66 +++++++++++++++++++
 .../stories/helpers/subagentReportStory.tsx   |  4 ++
 src/browser/stories/mocks/messages.ts         |  5 ++
 .../utils/subagentReportEnvelope.test.ts      | 28 ++++++++
 src/common/utils/subagentReportEnvelope.ts    | 12 ++++
 src/common/utils/tools/toolDefinitions.ts     | 13 +++-
 src/node/services/taskService.test.ts         | 10 ++-
 src/node/services/taskService.ts              | 47 ++++++++++++-
 src/node/services/tools/task.ts               | 22 +++++++
 12 files changed, 250 insertions(+), 7 deletions(-)

diff --git a/src/browser/features/Messages/MessageRenderer.test.tsx b/src/browser/features/Messages/MessageRenderer.test.tsx
index 187bcb4cac..2e8dabe71b 100644
--- a/src/browser/features/Messages/MessageRenderer.test.tsx
+++ b/src/browser/features/Messages/MessageRenderer.test.tsx
@@ -288,6 +288,32 @@ Found the **message renderer** and its responsive story coverage.
     expect(parseSubagentReportEnvelope(formatSubagentReportEnvelope(expected))).toEqual(expected);
   });
 
+  test("shows the sub-agent model and thinking level when the envelope carries them", () => {
+    const withMetadata = createReportMessage(`<mux_subagent_report>
+{"taskId":"task-model","agentType":"explore","status":"completed","title":"Model exposed","reportMarkdown":"Body","model":"anthropic:claude-opus-5","thinkingLevel":"high"}
+</mux_subagent_report>`);
+
+    const metadataView = render(
+      <TooltipProvider>
+        <MessageRenderer message={withMetadata} />
+      </TooltipProvider>
+    );
+    expect(metadataView.getByText("Opus 5")).toBeDefined();
+    expect(metadataView.getByText("thinking: high")).toBeDefined();
+    metadataView.unmount();
+
+    const withoutMetadata = createReportMessage(`<mux_subagent_report>
+{"taskId":"task-no-model","agentType":"explore","status":"completed","title":"No model","reportMarkdown":"Body"}
+</mux_subagent_report>`);
+
+    const plainView = render(
+      <TooltipProvider>
+        <MessageRenderer message={withoutMetadata} />
+      </TooltipProvider>
+    );
+    expect(plainView.queryByText(/thinking:/)).toBeNull();
+  });
+
   test("normalizes multiline report titles instead of exposing the envelope", () => {
     const message = createReportMessage(`<mux_subagent_report>
 <task_id>task-multiline-title</task_id>
diff --git a/src/browser/features/Messages/SubagentReportMessageContent.tsx b/src/browser/features/Messages/SubagentReportMessageContent.tsx
index 106d0cfa97..dae51c7f25 100644
--- a/src/browser/features/Messages/SubagentReportMessageContent.tsx
+++ b/src/browser/features/Messages/SubagentReportMessageContent.tsx
@@ -2,8 +2,10 @@ import { useState, type ReactElement } from "react";
 import { Bot, Braces, ChevronRight, CircleCheck, Radio } from "lucide-react";
 
 import { cn } from "@/common/lib/utils";
+import { getThinkingOptionLabel } from "@/common/types/thinking";
 import type { SubagentReportEnvelope } from "@/common/utils/subagentReportEnvelope";
 import { MarkdownRenderer } from "./MarkdownRenderer";
+import { ModelDisplay } from "./ModelDisplay";
 
 export { parseSubagentReportEnvelope } from "@/common/utils/subagentReportEnvelope";
 
@@ -40,6 +42,22 @@ export function SubagentReportMessageContent(
           </div>
           <div className="text-muted mt-0.5 flex min-w-0 flex-wrap items-center gap-x-1.5 gap-y-0.5 text-xs leading-snug">
             <span className="truncate">{props.report.agentType}</span>
+            {props.report.model && (
+              <>
+                <span aria-hidden="true">·</span>
+                <span className="truncate">
+                  <ModelDisplay modelString={props.report.model} />
+                </span>
+              </>
+            )}
+            {props.report.thinkingLevel != null && (
+              <>
+                <span aria-hidden="true">·</span>
+                <span className="shrink-0">
+                  thinking: {getThinkingOptionLabel(props.report.thinkingLevel, props.report.model)}
+                </span>
+              </>
+            )}
             <span aria-hidden="true">·</span>
             <span
               className={cn(
diff --git a/src/browser/features/Tools/TaskToolCall.stories.tsx b/src/browser/features/Tools/TaskToolCall.stories.tsx
index 5d4087e4bf..01786d6955 100644
--- a/src/browser/features/Tools/TaskToolCall.stories.tsx
+++ b/src/browser/features/Tools/TaskToolCall.stories.tsx
@@ -36,6 +36,8 @@ export const TaskWorkflowStates: Story = {
         result={{
           status: "running",
           taskId: "task-fe-001",
+          modelString: "anthropic:claude-opus-5",
+          thinkingLevel: "high",
           note: "Use task_await to monitor progress.",
         }}
         status="completed"
@@ -75,6 +77,8 @@ export const TaskWithReport: Story = {
           status: "completed",
           taskId: "task-abc123",
           title: "Test File Analysis",
+          modelString: "openai:gpt-5.6-sol",
+          thinkingLevel: "xhigh",
           reportMarkdown: `# Test File Analysis
 
 Found **47 test files** across the project.
@@ -111,6 +115,8 @@ export const BestOfTaskGroup: Story = {
               title: "Option 1",
               agentId: "explore",
               agentType: "explore",
+              modelString: "anthropic:claude-sonnet-5",
+              thinkingLevel: "medium",
               reportMarkdown: "Use **shared helper utilities** for tree coalescing.",
             },
             {
diff --git a/src/browser/features/Tools/TaskToolCall.tsx b/src/browser/features/Tools/TaskToolCall.tsx
index 63f5a88993..164e27c24b 100644
--- a/src/browser/features/Tools/TaskToolCall.tsx
+++ b/src/browser/features/Tools/TaskToolCall.tsx
@@ -60,6 +60,8 @@ import {
 import { resolvePersistedAgentId } from "@/common/utils/agentIds";
 import { formatDuration } from "@/common/utils/formatDuration";
 import { ElapsedTimeDisplay } from "./Shared/ElapsedTimeDisplay";
+import { ModelDisplay } from "../Messages/ModelDisplay";
+import { getThinkingOptionLabel, type ThinkingLevel } from "@/common/types/thinking";
 
 /**
  * Clean SVG icon for task tools - represents spawning/branching work
@@ -449,8 +451,34 @@ interface TaskToolDisplayEntry {
   openWorkspaceId?: string;
   groupKind?: TaskGroupKind;
   label?: string;
+  modelString?: string;
+  thinkingLevel?: ThinkingLevel;
 }
 
+interface TaskAiSettingsInfo {
+  modelString?: string;
+  thinkingLevel?: ThinkingLevel;
+}
+
+const TaskAiSettingsDisplay: React.FC<TaskAiSettingsInfo & { className?: string }> = (props) => {
+  if (!props.modelString && props.thinkingLevel == null) {
+    return null;
+  }
+  return (
+    <span
+      className={cn("text-muted inline-flex flex-wrap items-center gap-1.5", props.className)}
+      data-task-ai-settings
+    >
+      {props.modelString && <ModelDisplay modelString={props.modelString} />}
+      {props.thinkingLevel != null && (
+        <span className="rounded bg-[var(--color-bg-tertiary)] px-1 py-0.5 font-mono leading-none">
+          thinking: {getThinkingOptionLabel(props.thinkingLevel, props.modelString)}
+        </span>
+      )}
+    </span>
+  );
+};
+
 interface TaskToolOwnReport {
   reportMarkdown: string;
   title?: string;
@@ -654,12 +682,14 @@ function collectTaskToolResultDisplayData(result: TaskToolSuccessResult | null):
   ownReportsByTaskId: Map<string, TaskToolOwnReport>;
   taskGroupsByTaskId: Map<string, { groupKind?: TaskGroupKind; label?: string }>;
   workspaceIdByTaskId: Map<string, string>;
+  aiSettingsByTaskId: Map<string, TaskAiSettingsInfo>;
 } {
   const taskIds = new Set<string>();
   const statusByTaskId = new Map<string, string>();
   const ownReportsByTaskId = new Map<string, TaskToolOwnReport>();
   const taskGroupsByTaskId = new Map<string, { groupKind?: TaskGroupKind; label?: string }>();
   const workspaceIdByTaskId = new Map<string, string>();
+  const aiSettingsByTaskId = new Map<string, TaskAiSettingsInfo>();
   if (!result) {
     return {
       taskIds: [],
@@ -667,6 +697,7 @@ function collectTaskToolResultDisplayData(result: TaskToolSuccessResult | null):
       ownReportsByTaskId,
       taskGroupsByTaskId,
       workspaceIdByTaskId,
+      aiSettingsByTaskId,
     };
   }
 
@@ -699,10 +730,23 @@ function collectTaskToolResultDisplayData(result: TaskToolSuccessResult | null):
     }
   };
 
+  const rememberAiSettings = (taskId: string, settings: TaskAiSettingsInfo): void => {
+    const modelString = trimToNonEmptyString(settings.modelString) ?? undefined;
+    if (!modelString && settings.thinkingLevel == null) {
+      return;
+    }
+    const existing = aiSettingsByTaskId.get(taskId);
+    aiSettingsByTaskId.set(taskId, {
+      modelString: existing?.modelString ?? modelString,
+      thinkingLevel: existing?.thinkingLevel ?? settings.thinkingLevel,
+    });
+  };
+
   const taskStatuses = "tasks" in result && Array.isArray(result.tasks) ? result.tasks : undefined;
   const singleTaskId = rememberTaskId(result.taskId);
   if (singleTaskId) {
     rememberWorkspace(singleTaskId, result.workspaceId);
+    rememberAiSettings(singleTaskId, result);
   }
   if (singleTaskId && result.status === "completed" && typeof result.reportMarkdown === "string") {
     ownReportsByTaskId.set(singleTaskId, {
@@ -724,6 +768,7 @@ function collectTaskToolResultDisplayData(result: TaskToolSuccessResult | null):
         statusByTaskId.set(taskId, task.status);
         rememberWorkspace(taskId, task.workspaceId);
         rememberTaskGroup(taskId, { groupKind: task.groupKind, label: task.label });
+        rememberAiSettings(taskId, task);
       }
     }
   }
@@ -740,6 +785,7 @@ function collectTaskToolResultDisplayData(result: TaskToolSuccessResult | null):
         });
         rememberWorkspace(taskId, report.workspaceId);
         rememberTaskGroup(taskId, { groupKind: report.groupKind, label: report.label });
+        rememberAiSettings(taskId, report);
       }
     }
   }
@@ -757,6 +803,7 @@ function collectTaskToolResultDisplayData(result: TaskToolSuccessResult | null):
     ownReportsByTaskId,
     taskGroupsByTaskId,
     workspaceIdByTaskId,
+    aiSettingsByTaskId,
   };
 }
 
@@ -808,6 +855,11 @@ const TaskToolCandidateCard: React.FC<{
         {entry.title && (
           <span className="text-foreground text-[11px] font-medium">{entry.title}</span>
         )}
+        <TaskAiSettingsDisplay
+          modelString={entry.modelString}
+          thinkingLevel={entry.thinkingLevel}
+          className="text-[10px]"
+        />
         {canViewTranscript && (
           <button
             type="button"
@@ -853,6 +905,7 @@ export const TaskToolCall: React.FC<TaskToolCallProps> = ({
     ownReportsByTaskId,
     taskGroupsByTaskId,
     workspaceIdByTaskId,
+    aiSettingsByTaskId,
   } = collectTaskToolResultDisplayData(successResult);
 
   const requestedTaskGroupCount = getTaskGroupCount(args);
@@ -913,6 +966,8 @@ export const TaskToolCall: React.FC<TaskToolCallProps> = ({
         ? "completed"
         : (getTaskToolWorkspaceStatus(metadata?.taskStatus) ?? statusByTaskId.get(taskId));
 
+    const resultAiSettings = aiSettingsByTaskId.get(taskId);
+
     return {
       taskId,
       status:
@@ -930,6 +985,10 @@ export const TaskToolCall: React.FC<TaskToolCallProps> = ({
         resultTaskGroup?.label ??
         normalizeTaskGroupLabel(metadata?.bestOf?.label) ??
         getTaskGroupLabelAtIndex(args, index),
+      // Result-carried settings survive child workspace cleanup; live metadata covers
+      // tasks spawned before the result existed (e.g. task-created events).
+      modelString: resultAiSettings?.modelString ?? metadata?.taskModelString,
+      thinkingLevel: resultAiSettings?.thinkingLevel ?? metadata?.taskThinkingLevel,
     };
   });
 
@@ -1030,6 +1089,13 @@ export const TaskToolCall: React.FC<TaskToolCallProps> = ({
               {!isTaskGroup && singleEntry?.status && (
                 <TaskStatusBadge status={singleEntry.status} />
               )}
+              {!isTaskGroup && singleEntry && (
+                <TaskAiSettingsDisplay
+                  modelString={singleEntry.modelString}
+                  thinkingLevel={singleEntry.thinkingLevel}
+                  className="text-[10px]"
+                />
+              )}
               {!isTaskGroup && singleEntry?.status === "completed" && (
                 <button
                   type="button"
diff --git a/src/browser/stories/helpers/subagentReportStory.tsx b/src/browser/stories/helpers/subagentReportStory.tsx
index 2ee06e8f88..dcda5fe204 100644
--- a/src/browser/stories/helpers/subagentReportStory.tsx
+++ b/src/browser/stories/helpers/subagentReportStory.tsx
@@ -28,6 +28,8 @@ const REPORT_MESSAGES = [
     taskId: "18c2511cea",
     agentType: "explore",
     status: "in_progress",
+    model: "anthropic:claude-opus-5",
+    thinkingLevel: "high",
     title: "Current report presentation traced across the parent transcript",
     reportMarkdown:
       "Parent-side reports currently expose the model-facing envelope. A dedicated renderer can preserve **markdown**, paths like `src/browser/features/Messages/UserMessage.tsx`, and status without the raw protocol.",
@@ -38,6 +40,8 @@ const REPORT_MESSAGES = [
     taskId: "18c2511cea",
     agentType: "explore",
     // Omit status to cover report envelopes persisted before incremental updates existed.
+    model: "anthropic:claude-opus-5",
+    thinkingLevel: "high",
     title: "Presentation recommendation complete",
     reportMarkdown: [
       "## Recommendation",
diff --git a/src/browser/stories/mocks/messages.ts b/src/browser/stories/mocks/messages.ts
index 0917deaf5b..f593da08a7 100644
--- a/src/browser/stories/mocks/messages.ts
+++ b/src/browser/stories/mocks/messages.ts
@@ -8,6 +8,7 @@ import type {
   MuxToolPart,
 } from "@/common/types/message";
 import { formatSubagentReportEnvelope } from "@/common/utils/subagentReportEnvelope";
+import type { ThinkingLevel } from "@/common/types/thinking";
 import { DEFAULT_MODEL } from "@/common/constants/knownModels";
 import {
   GOAL_BUDGET_LIMIT_KIND,
@@ -134,6 +135,8 @@ export function createSubagentReportMessage(
     title: string;
     reportMarkdown: string;
     status?: "in_progress" | "completed";
+    model?: string;
+    thinkingLevel?: ThinkingLevel;
     structuredOutput?: unknown;
   }
 ): ChatMuxMessage {
@@ -145,6 +148,8 @@ export function createSubagentReportMessage(
       status: opts.status ?? "completed",
       title: opts.title,
       reportMarkdown: opts.reportMarkdown,
+      ...(opts.model !== undefined ? { model: opts.model } : {}),
+      ...(opts.thinkingLevel !== undefined ? { thinkingLevel: opts.thinkingLevel } : {}),
       ...(opts.structuredOutput !== undefined ? { structuredOutput: opts.structuredOutput } : {}),
     }),
     {
diff --git a/src/common/utils/subagentReportEnvelope.test.ts b/src/common/utils/subagentReportEnvelope.test.ts
index 0f682294df..26c5841ccd 100644
--- a/src/common/utils/subagentReportEnvelope.test.ts
+++ b/src/common/utils/subagentReportEnvelope.test.ts
@@ -22,6 +22,34 @@ describe("subagentReportEnvelope", () => {
     expect(parseSubagentReportEnvelope(formatSubagentReportEnvelope(report))).toEqual(report);
   });
 
+  test("round-trips model and thinking level metadata", () => {
+    const report = {
+      taskId: "task-model-metadata",
+      agentType: "exec",
+      status: "in_progress" as const,
+      title: "Progress",
+      reportMarkdown: "Working on it",
+      model: "anthropic:claude-opus-4-6",
+      thinkingLevel: "high" as const,
+    };
+
+    expect(parseSubagentReportEnvelope(formatSubagentReportEnvelope(report))).toEqual(report);
+  });
+
+  test("drops malformed model/thinking metadata without rejecting the report", () => {
+    const parsed = parseSubagentReportEnvelope(`<mux_subagent_report>
+{"taskId":"t1","agentType":"exec","status":"completed","title":"Done","reportMarkdown":"Body","model":"","thinkingLevel":"turbo"}
+</mux_subagent_report>`);
+
+    expect(parsed).toEqual({
+      taskId: "t1",
+      agentType: "exec",
+      status: "completed",
+      title: "Done",
+      reportMarkdown: "Body",
+    });
+  });
+
   test("parses legacy envelopes without an explicit status as completed", () => {
     const legacy = `<mux_subagent_report>
 <task_id>legacy-task</task_id>
diff --git a/src/common/utils/subagentReportEnvelope.ts b/src/common/utils/subagentReportEnvelope.ts
index 7459423fe2..d3f139ab58 100644
--- a/src/common/utils/subagentReportEnvelope.ts
+++ b/src/common/utils/subagentReportEnvelope.ts
@@ -1,3 +1,5 @@
+import { THINKING_LEVELS, type ThinkingLevel } from "@/common/types/thinking";
+
 export type SubagentReportStatus = "in_progress" | "completed";
 
 export interface SubagentReportEnvelope {
@@ -6,6 +8,8 @@ export interface SubagentReportEnvelope {
   status: SubagentReportStatus;
   title: string;
   reportMarkdown: string;
+  model?: string;
+  thinkingLevel?: ThinkingLevel;
   structuredOutput?: unknown;
 }
 
@@ -26,6 +30,10 @@ function isStatus(value: unknown): value is SubagentReportStatus {
   return value === "in_progress" || value === "completed";
 }
 
+function isThinkingLevel(value: unknown): value is ThinkingLevel {
+  return typeof value === "string" && (THINKING_LEVELS as readonly string[]).includes(value);
+}
+
 /**
  * New reports use JSON framing so arbitrary Markdown and protocol examples round-trip exactly while
  * remaining readable to the parent model. The outer tag preserves the existing prompt contract.
@@ -64,6 +72,10 @@ function parseJsonEnvelope(inner: string): SubagentReportEnvelope | null {
     status: record.status,
     title: record.title,
     reportMarkdown: record.reportMarkdown,
+    // Model/thinking are display metadata: tolerate absent or malformed values so a bad
+    // producer can never invalidate an otherwise well-formed report.
+    ...(isNonEmptyString(record.model) ? { model: record.model } : {}),
+    ...(isThinkingLevel(record.thinkingLevel) ? { thinkingLevel: record.thinkingLevel } : {}),
     ...(Object.hasOwn(record, "structuredOutput")
       ? { structuredOutput: record.structuredOutput }
       : {}),
diff --git a/src/common/utils/tools/toolDefinitions.ts b/src/common/utils/tools/toolDefinitions.ts
index 9435a9a2f6..a1390586f6 100644
--- a/src/common/utils/tools/toolDefinitions.ts
+++ b/src/common/utils/tools/toolDefinitions.ts
@@ -531,6 +531,7 @@ export function buildTaskToolAgentArgsSchema(options: {
 }
 
 const TaskHandleKindSchema = z.enum(["agent_task", "workspace_turn"]);
+const TaskThinkingLevelSchema = z.enum(THINKING_LEVELS);
 const TaskToolSpawnedTaskSchema = z
   .object({
     taskId: z.string(),
@@ -539,6 +540,8 @@ const TaskToolSpawnedTaskSchema = z
     workspaceId: z.string().optional(),
     groupKind: z.enum(TASK_GROUP_KIND_VALUES).optional(),
     label: z.string().optional(),
+    modelString: z.string().optional(),
+    thinkingLevel: TaskThinkingLevelSchema.optional(),
   })
   .strict();
 
@@ -557,6 +560,8 @@ const TaskToolCompletedReportSchema = z
     finalMessageRef: WorkspaceTurnFinalMessageRefSchema.optional(),
     groupKind: z.enum(TASK_GROUP_KIND_VALUES).optional(),
     label: z.string().optional(),
+    modelString: z.string().optional(),
+    thinkingLevel: TaskThinkingLevelSchema.optional(),
   })
   .strict();
 
@@ -569,6 +574,8 @@ export const TaskToolQueuedResultSchema = z
     workspaceId: z.string().optional(),
     tasks: z.array(TaskToolSpawnedTaskSchema).min(1).optional(),
     reports: z.array(TaskToolCompletedReportSchema).min(1).optional(),
+    modelString: z.string().optional(),
+    thinkingLevel: TaskThinkingLevelSchema.optional(),
     note: z
       .string()
       .min(1)
@@ -605,6 +612,8 @@ export const TaskToolCompletedResultSchema = z
     messageId: z.string().optional(),
     finalMessageRef: WorkspaceTurnFinalMessageRefSchema.optional(),
     reports: z.array(TaskToolCompletedReportSchema).min(1).optional(),
+    modelString: z.string().optional(),
+    thinkingLevel: TaskThinkingLevelSchema.optional(),
   })
   .strict()
   .superRefine((value, ctx) => {
@@ -1160,8 +1169,6 @@ const TaskListStatusSchema = z.enum([
   "failed",
   "completed",
 ]);
-const TaskListThinkingLevelSchema = z.enum(THINKING_LEVELS);
-
 export const TaskListToolArgsSchema = z
   .object({
     statuses: z
@@ -1193,7 +1200,7 @@ export const TaskListToolTaskSchema = z
     handleKind: TaskHandleKindSchema.optional(),
     workspaceId: z.string().optional(),
     modelString: z.string().optional(),
-    thinkingLevel: TaskListThinkingLevelSchema.optional(),
+    thinkingLevel: TaskThinkingLevelSchema.optional(),
     sticky: z.boolean().optional(),
     workflowProgress: WorkflowProgressSummarySchema.optional(),
     depth: z.number().int().min(0),
diff --git a/src/node/services/taskService.test.ts b/src/node/services/taskService.test.ts
index 046d052384..6ec29793ac 100644
--- a/src/node/services/taskService.test.ts
+++ b/src/node/services/taskService.test.ts
@@ -631,7 +631,15 @@ describe("TaskService", () => {
 
     const result = await createAgentTask(taskService, parentId, "Inspect the scratch files");
 
-    expect(result).toEqual(Ok({ taskId: childId, kind: "agent", status: "running" }));
+    expect(result).toEqual(
+      Ok({
+        taskId: childId,
+        kind: "agent",
+        status: "running",
+        modelString: "anthropic:claude-opus-4-6",
+        thinkingLevel: "high",
+      })
+    );
     const scratchProject = config.loadConfigOrDefault().projects.get(SCRATCH_PROJECT_CONFIG_KEY);
     const child = scratchProject?.workspaces.find((workspace) => workspace.id === childId);
     expect(child?.kind).toBe("scratch");
diff --git a/src/node/services/taskService.ts b/src/node/services/taskService.ts
index 2986aff08a..9ced8a2057 100644
--- a/src/node/services/taskService.ts
+++ b/src/node/services/taskService.ts
@@ -292,6 +292,8 @@ function formatSubagentReportUserMessage(params: {
   title: string;
   reportMarkdown: string;
   status: "in_progress" | "completed";
+  model?: string;
+  thinkingLevel?: ThinkingLevel;
   structuredOutput?: unknown;
 }): string {
   assert(params.childWorkspaceId.length > 0, "subagent report message requires child id");
@@ -305,6 +307,8 @@ function formatSubagentReportUserMessage(params: {
     status: params.status,
     title: params.title,
     reportMarkdown: params.reportMarkdown,
+    ...(params.model != null ? { model: params.model } : {}),
+    ...(params.thinkingLevel != null ? { thinkingLevel: params.thinkingLevel } : {}),
     ...(params.structuredOutput !== undefined ? { structuredOutput: params.structuredOutput } : {}),
   });
 }
@@ -560,6 +564,9 @@ export interface TaskCreateResult {
   taskId: string;
   kind: TaskKind;
   status: "queued" | "starting" | "running";
+  /** Resolved (post-precedence) AI settings the child was created with. */
+  modelString?: string;
+  thinkingLevel?: ThinkingLevel;
 }
 
 type TaskLaunchStart = { kind: "sendMessage"; prompt: string } | { kind: "resumeStream" };
@@ -2598,7 +2605,13 @@ export class TaskService {
           ? { preferredTrunkBranch: parentBranchName }
           : {}),
       });
-      results.push({ taskId, kind: "agent", status });
+      results.push({
+        taskId,
+        kind: "agent",
+        status,
+        modelString: taskModelString,
+        thinkingLevel: effectiveThinkingLevel,
+      });
     }
 
     for (const [index, result] of results.entries()) {
@@ -3764,7 +3777,13 @@ export class TaskService {
       // Schedule queue processing (best-effort).
       void this.maybeStartQueuedTasks();
       taskQueueDebug("TaskService.create queued scheduled maybeStartQueuedTasks", { taskId });
-      return Ok({ taskId, kind: "agent", status: "queued" });
+      return Ok({
+        taskId,
+        kind: "agent",
+        status: "queued",
+        modelString: taskModelString,
+        thinkingLevel: effectiveThinkingLevel,
+      });
     }
 
     const initLogger = this.startWorkspaceInit(taskId, parentMeta.projectPath);
@@ -3971,7 +3990,13 @@ export class TaskService {
       return Err(message);
     }
 
-    return Ok({ taskId, kind: "agent", status: "running" });
+    return Ok({
+      taskId,
+      kind: "agent",
+      status: "running",
+      modelString: taskModelString,
+      thinkingLevel: effectiveThinkingLevel,
+    });
   }
 
   async terminateDescendantAgentTask(
@@ -5746,6 +5771,12 @@ export class TaskService {
         title,
         reportMarkdown: report.reportMarkdown,
         status: "in_progress",
+        ...(childEntry.workspace.taskModelString != null
+          ? { model: childEntry.workspace.taskModelString }
+          : {}),
+        ...(childEntry.workspace.taskThinkingLevel != null
+          ? { thinkingLevel: childEntry.workspace.taskThinkingLevel }
+          : {}),
         ...(report.structuredOutput !== undefined
           ? { structuredOutput: report.structuredOutput }
           : {}),
@@ -11114,6 +11145,8 @@ export class TaskService {
       agentType?: string;
       groupKind?: TaskGroupKind;
       label?: string;
+      modelString?: string;
+      thinkingLevel?: ThinkingLevel;
     }> = [];
 
     for (const sibling of siblings) {
@@ -11132,6 +11165,8 @@ export class TaskService {
         agentType: sibling.agentType,
         groupKind: sibling.kind,
         label: sibling.label,
+        modelString: artifact.model,
+        thinkingLevel: artifact.thinkingLevel,
       });
     }
 
@@ -11315,6 +11350,8 @@ export class TaskService {
     options?: { uiVisible?: boolean }
   ): Promise<readonly string[]> {
     const agentType = coerceNonEmptyString(childEntry?.workspace.agentType) ?? "agent";
+    const childModelString = childEntry?.workspace.taskModelString;
+    const childThinkingLevel = childEntry?.workspace.taskThinkingLevel;
 
     const output = {
       status: "completed" as const,
@@ -11324,6 +11361,8 @@ export class TaskService {
       planFilePath: report.planFilePath,
       structuredOutput: report.structuredOutput,
       agentType,
+      modelString: childModelString,
+      thinkingLevel: childThinkingLevel,
     };
     const parsedOutput = TaskToolResultSchema.safeParse(output);
     if (!parsedOutput.success) {
@@ -11396,6 +11435,8 @@ export class TaskService {
       title: titlePrefix,
       reportMarkdown: report.reportMarkdown,
       status: "completed",
+      ...(childModelString != null ? { model: childModelString } : {}),
+      ...(childThinkingLevel != null ? { thinkingLevel: childThinkingLevel } : {}),
       ...(report.structuredOutput !== undefined
         ? { structuredOutput: report.structuredOutput }
         : {}),
diff --git a/src/node/services/tools/task.ts b/src/node/services/tools/task.ts
index dcfdbe353a..3f964a9518 100644
--- a/src/node/services/tools/task.ts
+++ b/src/node/services/tools/task.ts
@@ -150,6 +150,8 @@ interface SpawnedTaskInfo {
   status: "queued" | "starting" | "running";
   groupKind?: TaskGroupKind;
   label?: string;
+  modelString?: string;
+  thinkingLevel?: ThinkingLevel;
 }
 
 interface PendingTaskInfo {
@@ -157,6 +159,8 @@ interface PendingTaskInfo {
   status: "queued" | "starting" | "running" | "completed" | "interrupted";
   groupKind?: TaskGroupKind;
   label?: string;
+  modelString?: string;
+  thinkingLevel?: ThinkingLevel;
 }
 
 interface CompletedTaskInfo {
@@ -168,6 +172,8 @@ interface CompletedTaskInfo {
   agentType: string;
   groupKind?: TaskGroupKind;
   label?: string;
+  modelString?: string;
+  thinkingLevel?: ThinkingLevel;
 }
 
 type ForegroundWaitOutcome =
@@ -223,6 +229,8 @@ function serializeCompletedReport(report: CompletedTaskInfo) {
     agentType: report.agentType,
     groupKind: report.groupKind,
     label: report.label,
+    modelString: report.modelString,
+    thinkingLevel: report.thinkingLevel,
   };
 }
 
@@ -274,6 +282,8 @@ function buildPendingTaskResult(params: {
     return {
       status,
       taskId: task.taskId,
+      modelString: task.modelString,
+      thinkingLevel: task.thinkingLevel,
       note: params.note,
     };
   }
@@ -286,6 +296,8 @@ function buildPendingTaskResult(params: {
       status: task.status,
       groupKind: task.groupKind,
       label: task.label,
+      modelString: task.modelString,
+      thinkingLevel: task.thinkingLevel,
     })),
     note: params.note,
     ...(serializedReports ? { reports: serializedReports } : {}),
@@ -306,6 +318,8 @@ function buildCompletedTaskResult(params: {
       title: report.title,
       agentId: report.agentId,
       agentType: report.agentType,
+      modelString: report.modelString,
+      thinkingLevel: report.thinkingLevel,
     };
   }
 
@@ -329,6 +343,8 @@ function normalizePendingTaskStatuses(params: {
         status: "completed",
         groupKind: createdTask.groupKind,
         label: createdTask.label,
+        modelString: createdTask.modelString,
+        thinkingLevel: createdTask.thinkingLevel,
       };
     }
 
@@ -346,6 +362,8 @@ function normalizePendingTaskStatuses(params: {
               : "running",
       groupKind: createdTask.groupKind,
       label: createdTask.label,
+      modelString: createdTask.modelString,
+      thinkingLevel: createdTask.thinkingLevel,
     };
   });
 }
@@ -585,6 +603,8 @@ export const createTaskTool: ToolFactory = (config: ToolConfiguration) => {
         const task = {
           taskId: created.data.taskId,
           status: created.data.status,
+          modelString: created.data.modelString,
+          thinkingLevel: created.data.thinkingLevel,
           ...(taskGroupCount > 1 || launch.label
             ? { groupKind: launch.kind, ...(launch.label ? { label: launch.label } : {}) }
             : {}),
@@ -632,6 +652,8 @@ export const createTaskTool: ToolFactory = (config: ToolConfiguration) => {
                 agentType: requestedAgentId,
                 groupKind: createdTask.groupKind,
                 label: createdTask.label,
+                modelString: createdTask.modelString,
+                thinkingLevel: createdTask.thinkingLevel,
               } satisfies CompletedTaskInfo,
             };
           } catch (error: unknown) {

From e9d56e5961642e33710c6ff4b5d8709fe9a88c71 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Mon, 3 Aug 2026 17:35:09 +0000
Subject: [PATCH 2/8] harden partial task-output ID extraction against future
 fields

---
 src/node/services/taskService.test.ts | 120 ++++++++++++++++++++++++++
 src/node/services/taskService.ts      |  60 +++++++------
 2 files changed, 156 insertions(+), 24 deletions(-)

diff --git a/src/node/services/taskService.test.ts b/src/node/services/taskService.test.ts
index 6ec29793ac..e8fd19865f 100644
--- a/src/node/services/taskService.test.ts
+++ b/src/node/services/taskService.test.ts
@@ -18035,6 +18035,126 @@ describe("TaskService", () => {
     ).toHaveLength(1);
   });
 
+  test("deferred fallback honors partial task outputs carrying unknown future fields", async () => {
+    const config = await createTestConfig(rootDir);
+
+    const projectPath = path.join(rootDir, "repo");
+    const parentId = "parent-best-of-future-fields-fallback";
+    const childOneId = "child-best-of-future-fields-fallback-1";
+    const childTwoId = "child-best-of-future-fields-fallback-2";
+    const childThreeId = "child-best-of-future-fields-fallback-3";
+    const bestOf = {
+      groupId: "best-of-future-fields-fallback-group",
+      index: 0,
+      total: 3,
+    } as const;
+
+    await saveWorkspaces(
+      config,
+      projectPath,
+      [
+        projectWorkspace(projectPath, "parent", parentId),
+        {
+          path: path.join(projectPath, "child-1"),
+          id: childOneId,
+          name: "agent_explore_child_1",
+          parentWorkspaceId: parentId,
+          agentType: "explore",
+          taskStatus: "reported",
+          bestOf,
+        },
+        projectWorkspace(projectPath, "child-2", childTwoId, {
+          name: "agent_explore_child_2",
+          parentWorkspaceId: parentId,
+          agentType: "explore",
+          taskStatus: "interrupted",
+          bestOf: { ...bestOf, index: 1 },
+        }),
+        projectWorkspace(projectPath, "child-3", childThreeId, {
+          name: "agent_explore_child_3",
+          parentWorkspaceId: parentId,
+          agentType: "explore",
+          taskStatus: "interrupted",
+          bestOf: { ...bestOf, index: 2 },
+        }),
+      ],
+      testTaskSettings()
+    );
+
+    const { aiService } = createAIServiceMocks(config);
+    const { workspaceService } = createWorkspaceServiceMocks();
+    const { historyService, partialService, taskService } = createTaskServiceHarness(config, {
+      aiService,
+      workspaceService,
+    });
+
+    // An output written by a newer release: extra fields fail the strict result schema, but
+    // the referenced-task bookkeeping must still see these IDs or recovery would append a
+    // duplicate fallback report after a downgrade.
+    const parentPartial = createMuxMessage(
+      "assistant-parent-best-of-future-fields-fallback",
+      "assistant",
+      "Waiting on best-of subagents…",
+      { timestamp: Date.now() },
+      [
+        {
+          type: "dynamic-tool",
+          toolCallId: "task-best-of-future-fields-fallback-call",
+          toolName: "task",
+          input: {
+            subagent_type: "explore",
+            prompt: "compare options",
+            title: "Best of 3",
+            n: 3,
+          },
+          state: "output-available",
+          output: {
+            status: "running",
+            taskIds: [childOneId, childTwoId, childThreeId],
+            tasks: [
+              { taskId: childOneId, status: "completed", futureRowField: "x" },
+              { taskId: childTwoId, status: "running" },
+              { taskId: childThreeId, status: "running" },
+            ],
+            note: "use task_await to monitor progress",
+            futureTopLevelField: "y",
+          },
+        },
+      ]
+    );
+    expect((await partialService.writePartial(parentId, parentPartial)).success).toBe(true);
+
+    await upsertSubagentReportArtifact({
+      workspaceId: parentId,
+      workspaceSessionDir: config.getSessionDir(parentId),
+      childTaskId: childOneId,
+      parentWorkspaceId: parentId,
+      ancestorWorkspaceIds: [parentId],
+      reportMarkdown: "Report from child one",
+      title: "Option one",
+      nowMs: Date.now(),
+    });
+
+    const internal = taskService as unknown as {
+      deliverDeferredBestOfSiblingReports: (params: {
+        parentWorkspaceId: string;
+        groupId: string;
+        total: number;
+      }) => Promise<void>;
+    };
+
+    await internal.deliverDeferredBestOfSiblingReports({
+      parentWorkspaceId: parentId,
+      groupId: bestOf.groupId,
+      total: bestOf.total,
+    });
+
+    const parentHistory = await collectFullHistory(historyService, parentId);
+    const serializedParentHistory = JSON.stringify(parentHistory);
+    expect(serializedParentHistory).not.toContain("<mux_subagent_report>");
+    expect(serializedParentHistory).not.toContain("Report from child one");
+  });
+
   test("incremental best-of updates do not suppress deferred terminal reports", async () => {
     const config = await createTestConfig(rootDir);
     const projectPath = path.join(rootDir, "repo");
diff --git a/src/node/services/taskService.ts b/src/node/services/taskService.ts
index 9ced8a2057..b9670aa92d 100644
--- a/src/node/services/taskService.ts
+++ b/src/node/services/taskService.ts
@@ -910,6 +910,41 @@ function collectWorkflowRunIdsFromToolOutput(output: unknown): string[] {
   return runIds;
 }
 
+/**
+ * Tolerant extraction of the task IDs a persisted task tool output references. Recovery
+ * bookkeeping must survive outputs written by newer releases (extra fields would fail the
+ * strict result schema) so that a mid-stream downgrade cannot duplicate fallback reports.
+ */
+function collectReferencedTaskIdsFromTaskToolOutput(output: unknown, into: Set<string>): void {
+  if (output == null || typeof output !== "object") {
+    return;
+  }
+  const addTaskId = (value: unknown): void => {
+    if (typeof value === "string" && value.length > 0) {
+      into.add(value);
+    }
+  };
+
+  const record = output as Record<string, unknown>;
+  addTaskId(record.taskId);
+  if (Array.isArray(record.taskIds)) {
+    for (const taskId of record.taskIds) {
+      addTaskId(taskId);
+    }
+  }
+  for (const key of ["tasks", "reports"] as const) {
+    const rows = record[key];
+    if (!Array.isArray(rows)) {
+      continue;
+    }
+    for (const row of rows) {
+      if (row != null && typeof row === "object") {
+        addTaskId((row as Record<string, unknown>).taskId);
+      }
+    }
+  }
+}
+
 function collectWorkflowRunIdsFromTaskAwaitInput(input: unknown): string[] {
   if (input == null || typeof input !== "object") {
     return [];
@@ -11222,30 +11257,7 @@ export class TaskService {
         continue;
       }
 
-      const parsedOutput = TaskToolResultSchema.safeParse(part.output);
-      if (!parsedOutput.success) {
-        continue;
-      }
-
-      const output = parsedOutput.data;
-      if (typeof output.taskId === "string") {
-        referencedTaskIds.add(output.taskId);
-      }
-      if (Array.isArray(output.taskIds)) {
-        for (const taskId of output.taskIds) {
-          referencedTaskIds.add(taskId);
-        }
-      }
-      if ("tasks" in output && Array.isArray(output.tasks)) {
-        for (const task of output.tasks) {
-          referencedTaskIds.add(task.taskId);
-        }
-      }
-      if ("reports" in output && Array.isArray(output.reports)) {
-        for (const report of output.reports) {
-          referencedTaskIds.add(report.taskId);
-        }
-      }
+      collectReferencedTaskIdsFromTaskToolOutput(part.output, referencedTaskIds);
     }
 
     return {

From 7ddf7c09885af28cdd480318c32cd6d4f0e89821 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Mon, 3 Aug 2026 17:45:59 +0000
Subject: [PATCH 3/8] use report-time AI settings in completed task results

---
 src/node/services/taskService.ts     | 25 ++++++++++++++-
 src/node/services/tools/task.test.ts | 46 ++++++++++++++++++++++++++++
 src/node/services/tools/task.ts      | 17 ++++++----
 3 files changed, 81 insertions(+), 7 deletions(-)

diff --git a/src/node/services/taskService.ts b/src/node/services/taskService.ts
index b9670aa92d..84ebc2a12b 100644
--- a/src/node/services/taskService.ts
+++ b/src/node/services/taskService.ts
@@ -777,6 +777,8 @@ interface PendingTaskWaiter extends BackgroundableForegroundWaiter {
     title?: string;
     structuredOutput?: unknown;
     planFilePath?: string;
+    model?: string;
+    thinkingLevel?: ThinkingLevel;
   }) => void;
 }
 
@@ -790,6 +792,9 @@ interface CompletedAgentReportCacheEntry {
   planFilePath?: string;
   structuredOutput?: unknown;
   title?: string;
+  // Final settings the child reported with (post plan-to-exec handoff), not the launch snapshot.
+  model?: string;
+  thinkingLevel?: ThinkingLevel;
   // Ancestor workspace IDs captured when the report was cached.
   // Used to keep descendant-scope checks working even if the task workspace is cleaned up.
   ancestorWorkspaceIds: string[];
@@ -6055,6 +6060,8 @@ export class TaskService {
     title?: string;
     structuredOutput?: unknown;
     planFilePath?: string;
+    model?: string;
+    thinkingLevel?: ThinkingLevel;
   }> {
     assert(taskId.length > 0, "waitForAgentReport: taskId must be non-empty");
 
@@ -6067,6 +6074,8 @@ export class TaskService {
         title: cached.title,
         planFilePath: cached.planFilePath,
         structuredOutput: cached.structuredOutput,
+        model: cached.model,
+        thinkingLevel: cached.thinkingLevel,
       };
     }
 
@@ -6084,6 +6093,8 @@ export class TaskService {
       planFilePath?: string;
       structuredOutput?: unknown;
       title?: string;
+      model?: string;
+      thinkingLevel?: ThinkingLevel;
     } | null> => {
       if (!requestingWorkspaceId) {
         return null;
@@ -6101,6 +6112,8 @@ export class TaskService {
         title: artifact.title,
         planFilePath: artifact.planFilePath,
         structuredOutput: artifact.structuredOutput,
+        model: artifact.model,
+        thinkingLevel: artifact.thinkingLevel,
         workflowOwnedAncestorWorkspaceIds: artifact.workflowOwnedAncestorWorkspaceIds,
         ancestorWorkspaceIds: artifact.ancestorWorkspaceIds,
       });
@@ -6128,6 +6141,8 @@ export class TaskService {
         title: artifact.title,
         planFilePath: artifact.planFilePath,
         structuredOutput: artifact.structuredOutput,
+        model: artifact.model,
+        thinkingLevel: artifact.thinkingLevel,
       };
     };
 
@@ -10780,7 +10795,11 @@ export class TaskService {
     );
 
     // Resolve foreground waiters.
-    const hadForegroundWaiters = this.resolveWaiters(childWorkspaceId, reportArgs);
+    const hadForegroundWaiters = this.resolveWaiters(childWorkspaceId, {
+      ...reportArgs,
+      model: latestChildEntry?.workspace.taskModelString,
+      thinkingLevel: latestChildEntry?.workspace.taskThinkingLevel,
+    });
 
     // Free slot and start queued tasks.
     await this.maybeStartQueuedTasks();
@@ -10854,6 +10873,8 @@ export class TaskService {
       title?: string;
       structuredOutput?: unknown;
       planFilePath?: string;
+      model?: string;
+      thinkingLevel?: ThinkingLevel;
     }
   ): boolean {
     this.markTaskForegroundRelevant(taskId);
@@ -10875,6 +10896,8 @@ export class TaskService {
       title: report.title,
       planFilePath: report.planFilePath,
       structuredOutput: report.structuredOutput,
+      model: report.model,
+      thinkingLevel: report.thinkingLevel,
       ancestorWorkspaceIds,
       workflowOwnedAncestorWorkspaceIds,
     });
diff --git a/src/node/services/tools/task.test.ts b/src/node/services/tools/task.test.ts
index 3fc1fabfb8..f6d10eb105 100644
--- a/src/node/services/tools/task.test.ts
+++ b/src/node/services/tools/task.test.ts
@@ -832,6 +832,52 @@ describe("task tool", () => {
     });
   });
 
+  it("prefers report-time AI settings over the launch snapshot in completed results", async () => {
+    using tempDir = new TestTempDir("test-task-tool-report-time-settings");
+    const baseConfig = createTestToolConfig(tempDir.path, { workspaceId: "parent-workspace" });
+
+    // Launch resolves plan-phase settings; the report arrives after a plan-to-exec
+    // handoff rewrote the child's task settings.
+    const create = mock(() =>
+      Ok({
+        taskId: "child-task",
+        kind: "agent" as const,
+        status: "running" as const,
+        modelString: "openai:plan-model",
+        thinkingLevel: "low" as const,
+      })
+    );
+    const waitForAgentReport = mock(() =>
+      Promise.resolve({
+        reportMarkdown: "final report",
+        model: "anthropic:exec-model",
+        thinkingLevel: "high" as const,
+      })
+    );
+    const taskService = { create, waitForAgentReport } as unknown as TaskService;
+
+    const tool = createTaskTool({ ...baseConfig, taskService });
+
+    const result: unknown = await Promise.resolve(
+      tool.execute!(
+        {
+          subagent_type: "plan",
+          prompt: "plan then implement",
+          title: "Plan task",
+          run_in_background: false,
+        },
+        mockToolCallOptions
+      )
+    );
+
+    expect(result).toMatchObject({
+      status: "completed",
+      taskId: "child-task",
+      modelString: "anthropic:exec-model",
+      thinkingLevel: "high",
+    });
+  });
+
   it("preserves completed best-of reports when another foreground wait times out", async () => {
     using tempDir = new TestTempDir("test-task-tool-best-of-timeout-partial-complete");
     const baseConfig = createTestToolConfig(tempDir.path, { workspaceId: "parent-workspace" });
diff --git a/src/node/services/tools/task.ts b/src/node/services/tools/task.ts
index 3f964a9518..e0a05a6982 100644
--- a/src/node/services/tools/task.ts
+++ b/src/node/services/tools/task.ts
@@ -335,16 +335,19 @@ function normalizePendingTaskStatuses(params: {
   createdTasks: readonly SpawnedTaskInfo[];
   completedReports?: readonly CompletedTaskInfo[];
 }): PendingTaskInfo[] {
-  const completedTaskIds = new Set((params.completedReports ?? []).map((report) => report.taskId));
+  const completedReportsByTaskId = new Map(
+    (params.completedReports ?? []).map((report) => [report.taskId, report])
+  );
   return params.createdTasks.map((createdTask) => {
-    if (completedTaskIds.has(createdTask.taskId)) {
+    const completedReport = completedReportsByTaskId.get(createdTask.taskId);
+    if (completedReport) {
       return {
         taskId: createdTask.taskId,
         status: "completed",
         groupKind: createdTask.groupKind,
         label: createdTask.label,
-        modelString: createdTask.modelString,
-        thinkingLevel: createdTask.thinkingLevel,
+        modelString: completedReport.modelString ?? createdTask.modelString,
+        thinkingLevel: completedReport.thinkingLevel ?? createdTask.thinkingLevel,
       };
     }
 
@@ -652,8 +655,10 @@ export const createTaskTool: ToolFactory = (config: ToolConfiguration) => {
                 agentType: requestedAgentId,
                 groupKind: createdTask.groupKind,
                 label: createdTask.label,
-                modelString: createdTask.modelString,
-                thinkingLevel: createdTask.thinkingLevel,
+                // Prefer the settings the report was produced with: a plan child that
+                // auto-handoffs to exec rewrites its task settings after launch.
+                modelString: report.model ?? createdTask.modelString,
+                thinkingLevel: report.thinkingLevel ?? createdTask.thinkingLevel,
               } satisfies CompletedTaskInfo,
             };
           } catch (error: unknown) {

From 3bd8aef2468849f6bb6d79085be5cecfdb80799d Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Mon, 3 Aug 2026 17:50:55 +0000
Subject: [PATCH 4/8] add service-level coverage for report-time settings

---
 src/node/services/taskService.test.ts | 62 +++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/src/node/services/taskService.test.ts b/src/node/services/taskService.test.ts
index e8fd19865f..b710837d5a 100644
--- a/src/node/services/taskService.test.ts
+++ b/src/node/services/taskService.test.ts
@@ -10036,6 +10036,68 @@ describe("TaskService", () => {
     expect(serializedParentHistory).toContain("claims");
   });
 
+  test("waitForAgentReport surfaces the child's report-time AI settings", async () => {
+    const config = await createTestConfig(rootDir);
+
+    const projectPath = path.join(rootDir, "repo");
+    const parentWorkspaceId = "parent-report-settings";
+    const childTaskId = "task-report-settings";
+
+    // The persisted settings at report time differ from any launch-time snapshot a
+    // caller may hold (e.g. after a plan-to-exec handoff rewrote them).
+    await saveWorkspaces(
+      config,
+      projectPath,
+      [
+        projectWorkspace(projectPath, "parent", parentWorkspaceId, {
+          aiSettings: { model: "openai:gpt-5.2", thinkingLevel: "medium" },
+        }),
+        {
+          path: path.join(projectPath, "child-task"),
+          id: childTaskId,
+          name: "agent_exec_child",
+          parentWorkspaceId,
+          agentType: "exec",
+          taskStatus: "running",
+          taskModelString: "anthropic:claude-opus-5",
+          taskThinkingLevel: "high",
+        },
+      ],
+      testTaskSettings()
+    );
+
+    const { aiService } = createAIServiceMocks(config);
+    const { workspaceService } = createWorkspaceServiceMocks();
+    const { taskService } = createTaskServiceHarness(config, { aiService, workspaceService });
+
+    await handleTaskServiceStreamEndForTest(taskService, {
+      type: "stream-end",
+      workspaceId: childTaskId,
+      messageId: "assistant-child-report-settings",
+      metadata: { model: "anthropic:claude-opus-5", finishReason: "stop" },
+      parts: [
+        {
+          type: "dynamic-tool",
+          toolCallId: "agent-report-settings-call",
+          toolName: "agent_report",
+          input: { reportMarkdown: "Done", title: "Result" },
+          state: "output-available",
+          output: {
+            success: true,
+            report: { reportMarkdown: "Done", title: "Result" },
+          },
+        },
+        { type: "text", text: "Done" },
+      ],
+    });
+
+    const report = await taskService.waitForAgentReport(childTaskId, {
+      requestingWorkspaceId: parentWorkspaceId,
+    });
+    expect(report.model).toBe("anthropic:claude-opus-5");
+    expect(report.thinkingLevel).toBe("high");
+  });
+
   test("workflow-owned child reports do not trigger generic parent handoff", async () => {
     const config = await createTestConfig(rootDir);
 

From 4ffb83dfb3853f026dbe80ef721c56aedf1133ab Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Mon, 3 Aug 2026 17:54:47 +0000
Subject: [PATCH 5/8] update report shape assertions for report-time settings

---
 src/node/services/taskService.test.ts | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/node/services/taskService.test.ts b/src/node/services/taskService.test.ts
index b710837d5a..7cd72f7b6d 100644
--- a/src/node/services/taskService.test.ts
+++ b/src/node/services/taskService.test.ts
@@ -15929,7 +15929,11 @@ describe("TaskService", () => {
     });
 
     const report = await waiter;
-    expect(report).toEqual({ reportMarkdown: "Interrupted child report", title: "Result" });
+    expect(report).toEqual({
+      reportMarkdown: "Interrupted child report",
+      title: "Result",
+      model: "openai:gpt-4o-mini",
+    });
 
     const postCfg = config.loadConfigOrDefault();
     const ws = Array.from(postCfg.projects.values())
@@ -15943,7 +15947,11 @@ describe("TaskService", () => {
       timeoutMs: 10_000,
       requestingWorkspaceId: parentId,
     });
-    expect(persisted).toEqual({ reportMarkdown: "Interrupted child report", title: "Result" });
+    expect(persisted).toEqual({
+      reportMarkdown: "Interrupted child report",
+      title: "Result",
+      model: "openai:gpt-4o-mini",
+    });
   });
 
   test("handleStreamEnd rejects waiters when interrupted task stream ends without report", async () => {
@@ -19012,6 +19020,7 @@ describe("TaskService", () => {
         reportMarkdown: "# Proposed workflow plan\n\nDo the tiny safe change.\n",
         title: "Proposed plan",
         planFilePath: planPath,
+        model: "openai:gpt-4o-mini",
       });
       expect(debugSpy).toHaveBeenCalledWith(
         "Workflow plan completion using canonical plan file path",
@@ -19099,6 +19108,7 @@ describe("TaskService", () => {
         reportMarkdown: "# Interrupted workflow plan\n\nStill complete.\n",
         title: "Proposed plan",
         planFilePath: planPath,
+        model: "openai:gpt-4o-mini",
       });
       expect(replaceHistory).not.toHaveBeenCalled();
       expect(sendMessage).not.toHaveBeenCalled();

From 0c42b2fa70bdad28ce77b95699a90e14263cc7d3 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Mon, 3 Aug 2026 18:11:28 +0000
Subject: [PATCH 6/8] constrain long model IDs in narrow task cards

---
 .../features/Tools/TaskToolCall.stories.tsx   | 54 +++++++++++++++++++
 src/browser/features/Tools/TaskToolCall.tsx   | 13 ++++-
 2 files changed, 65 insertions(+), 2 deletions(-)

diff --git a/src/browser/features/Tools/TaskToolCall.stories.tsx b/src/browser/features/Tools/TaskToolCall.stories.tsx
index 01786d6955..96b675f704 100644
--- a/src/browser/features/Tools/TaskToolCall.stories.tsx
+++ b/src/browser/features/Tools/TaskToolCall.stories.tsx
@@ -1,4 +1,5 @@
 import type { Meta, StoryObj } from "@storybook/react-vite";
+import { waitFor, within } from "@storybook/test";
 import type { ReactNode } from "react";
 import { TaskApplyGitPatchToolCall } from "@/browser/features/Tools/TaskApplyGitPatchToolCall";
 import { TaskToolCall } from "@/browser/features/Tools/TaskToolCall";
@@ -141,6 +142,59 @@ export const BestOfTaskGroup: Story = {
   ),
 };
 
+/** long custom model IDs must wrap inside a narrow card instead of overflowing */
+export const TaskNarrowLongModelId: Story = {
+  render: () => (
+    <div data-testid="narrow-task-card" className="bg-background w-[320px] p-2">
+      <TaskToolCall
+        args={{
+          subagent_type: "explore",
+          prompt: "Analyze the frontend React components in src/browser/",
+          title: "Frontend analysis",
+          run_in_background: true,
+        }}
+        result={{
+          status: "running",
+          taskId: "task-fe-001",
+          // Deliberately hyphen-free: only an unbroken token exercises the wrap fix.
+          modelString:
+            "openrouter:acmelabs/somextremelylongcustommodelidentifierwithoutanybreakopportunitieswhatsoeverv2instruct",
+          thinkingLevel: "high",
+          note: "Use task_await to monitor progress.",
+        }}
+        status="completed"
+      />
+    </div>
+  ),
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement);
+    canvas.getByText("task").click();
+    await waitFor(() => {
+      if (!canvasElement.querySelector("[data-task-ai-settings]")) {
+        throw new Error("task AI settings did not render after expanding");
+      }
+    });
+    const container = canvasElement.querySelector('[data-testid="narrow-task-card"]');
+    if (!(container instanceof HTMLElement)) {
+      throw new Error("narrow task card container not found");
+    }
+    await new Promise<void>((resolve) =>
+      requestAnimationFrame(() => requestAnimationFrame(() => resolve()))
+    );
+    const containerRight = container.getBoundingClientRect().right;
+    const settings = container.querySelector("[data-task-ai-settings]");
+    const settingsRight = settings?.getBoundingClientRect().right ?? Number.POSITIVE_INFINITY;
+    // Right-edge containment, not scrollWidth: ancestors clip overflow, which would
+    // hide a too-wide settings row from scrollWidth-based checks.
+    if (settingsRight > containerRight + 1) {
+      throw new Error(
+        `task AI settings overflowed the ${container.clientWidth}px card by ` +
+          `${Math.round(settingsRight - containerRight)}px`
+      );
+    }
+  },
+};
+
 /** task_apply_git_patch states: executing, dry-run, success, and failure */
 export const TaskApplyGitPatchStates: Story = {
   render: () => (
diff --git a/src/browser/features/Tools/TaskToolCall.tsx b/src/browser/features/Tools/TaskToolCall.tsx
index 164e27c24b..9557d52614 100644
--- a/src/browser/features/Tools/TaskToolCall.tsx
+++ b/src/browser/features/Tools/TaskToolCall.tsx
@@ -465,11 +465,20 @@ const TaskAiSettingsDisplay: React.FC<TaskAiSettingsInfo & { className?: string
     return null;
   }
   return (
+    // min-w-0 at both flex levels + break-words let long custom model IDs wrap inside
+    // narrow cards instead of forcing right-edge overflow.
     <span
-      className={cn("text-muted inline-flex flex-wrap items-center gap-1.5", props.className)}
+      className={cn(
+        "text-muted inline-flex min-w-0 max-w-full flex-wrap items-center gap-1.5 break-words",
+        props.className
+      )}
       data-task-ai-settings
     >
-      {props.modelString && <ModelDisplay modelString={props.modelString} />}
+      {props.modelString && (
+        <span className="min-w-0">
+          <ModelDisplay modelString={props.modelString} />
+        </span>
+      )}
       {props.thinkingLevel != null && (
         <span className="rounded bg-[var(--color-bg-tertiary)] px-1 py-0.5 font-mono leading-none">
           thinking: {getThinkingOptionLabel(props.thinkingLevel, props.modelString)}

From 7a1e21c0d955a377d112141ccd4c52ebaf70abc5 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Mon, 3 Aug 2026 18:20:37 +0000
Subject: [PATCH 7/8] prefer live workspace settings over result snapshot in
 task card

---
 .../features/Tools/TaskToolCall.test.tsx      | 75 +++++++++++++++++++
 src/browser/features/Tools/TaskToolCall.tsx   |  9 ++-
 2 files changed, 80 insertions(+), 4 deletions(-)

diff --git a/src/browser/features/Tools/TaskToolCall.test.tsx b/src/browser/features/Tools/TaskToolCall.test.tsx
index ffc6fe7b83..376d88ab4a 100644
--- a/src/browser/features/Tools/TaskToolCall.test.tsx
+++ b/src/browser/features/Tools/TaskToolCall.test.tsx
@@ -137,6 +137,81 @@ describe("TaskToolCall", () => {
     expect(setSelectedWorkspace).toHaveBeenCalledTimes(1);
     expect(setSelectedWorkspace.mock.calls[0][0]).toEqual(workspace);
   });
+
+  test("prefers live workspace settings over the result snapshot", () => {
+    // A plan child's auto-handoff to exec rewrites live metadata after launch; the
+    // result snapshot keeps the stale plan-phase settings.
+    const workspace = createWorkspaceMetadata({
+      id: "task-child-1",
+      taskModelString: "anthropic:claude-opus-5",
+      taskThinkingLevel: "high",
+    });
+    workspaceContextMock = {
+      workspaceMetadata: new Map([[workspace.id, workspace]]),
+    };
+
+    const agentTaskArgs = {
+      subagent_type: "plan",
+      prompt: "Plan then implement.",
+      title: "Plan task",
+      run_in_background: true,
+    };
+    const AgentTaskToolCall = getToolComponent("task", agentTaskArgs);
+    const view = render(
+      <TooltipProvider>
+        <AgentTaskToolCall
+          args={agentTaskArgs}
+          result={{
+            status: "running",
+            taskId: "task-child-1",
+            modelString: "openai:gpt-5.2",
+            thinkingLevel: "low",
+            note: "Task started in background.",
+          }}
+          status="completed"
+        />
+      </TooltipProvider>
+    );
+
+    fireEvent.click(view.getByText("task"));
+
+    const settings = view.container.querySelector("[data-task-ai-settings]");
+    expect(settings?.textContent).toContain("Opus 5");
+    expect(settings?.textContent).toContain("thinking: high");
+    expect(settings?.textContent).not.toContain("thinking: low");
+  });
+
+  test("falls back to result-carried settings after workspace cleanup", () => {
+    workspaceContextMock = { workspaceMetadata: new Map() };
+
+    const agentTaskArgs = {
+      subagent_type: "explore",
+      prompt: "Look around.",
+      title: "Explore task",
+      run_in_background: true,
+    };
+    const AgentTaskToolCall = getToolComponent("task", agentTaskArgs);
+    const view = render(
+      <TooltipProvider>
+        <AgentTaskToolCall
+          args={agentTaskArgs}
+          result={{
+            status: "running",
+            taskId: "task-child-2",
+            modelString: "openai:gpt-5.2",
+            thinkingLevel: "low",
+            note: "Task started in background.",
+          }}
+          status="completed"
+        />
+      </TooltipProvider>
+    );
+
+    fireEvent.click(view.getByText("task"));
+
+    const settings = view.container.querySelector("[data-task-ai-settings]");
+    expect(settings?.textContent).toContain("thinking: low");
+  });
 });
 
 describe("TaskAwaitToolCall", () => {
diff --git a/src/browser/features/Tools/TaskToolCall.tsx b/src/browser/features/Tools/TaskToolCall.tsx
index 9557d52614..7d45b27682 100644
--- a/src/browser/features/Tools/TaskToolCall.tsx
+++ b/src/browser/features/Tools/TaskToolCall.tsx
@@ -994,10 +994,11 @@ export const TaskToolCall: React.FC<TaskToolCallProps> = ({
         resultTaskGroup?.label ??
         normalizeTaskGroupLabel(metadata?.bestOf?.label) ??
         getTaskGroupLabelAtIndex(args, index),
-      // Result-carried settings survive child workspace cleanup; live metadata covers
-      // tasks spawned before the result existed (e.g. task-created events).
-      modelString: resultAiSettings?.modelString ?? metadata?.taskModelString,
-      thinkingLevel: resultAiSettings?.thinkingLevel ?? metadata?.taskThinkingLevel,
+      // Prefer live metadata while the workspace exists: a plan child's auto-handoff to
+      // exec rewrites its settings after launch, so a result snapshot can go stale.
+      // Result-carried settings remain as the fallback surviving workspace cleanup.
+      modelString: metadata?.taskModelString ?? resultAiSettings?.modelString,
+      thinkingLevel: metadata?.taskThinkingLevel ?? resultAiSettings?.thinkingLevel,
     };
   });
 

From f0f3b5423008366ee25f704b91e8dbb51fd3c398 Mon Sep 17 00:00:00 2001
From: Michael Suchacz <203725896+ibetitsmike@users.noreply.github.com>
Date: Mon, 3 Aug 2026 18:28:55 +0000
Subject: [PATCH 8/8] propagate report-time settings through task_await and
 report linking

---
 .../features/Tools/TaskToolCall.test.tsx      | 51 +++++++++++++++++++
 src/browser/features/Tools/TaskToolCall.tsx   | 13 +++--
 .../utils/messages/taskReportLinking.ts       | 16 ++++++
 src/common/utils/tools/toolDefinitions.ts     |  2 +
 src/node/services/tools/task_await.test.ts    | 37 ++++++++++++++
 src/node/services/tools/task_await.ts         |  4 ++
 6 files changed, 119 insertions(+), 4 deletions(-)

diff --git a/src/browser/features/Tools/TaskToolCall.test.tsx b/src/browser/features/Tools/TaskToolCall.test.tsx
index 376d88ab4a..ca4f63fd13 100644
--- a/src/browser/features/Tools/TaskToolCall.test.tsx
+++ b/src/browser/features/Tools/TaskToolCall.test.tsx
@@ -181,6 +181,57 @@ describe("TaskToolCall", () => {
     expect(settings?.textContent).not.toContain("thinking: low");
   });
 
+  test("prefers linked report settings over the spawn snapshot after cleanup", () => {
+    // Workspace already cleaned up; the task_await-linked report carries the exec
+    // settings while the spawn result kept the stale plan-phase ones.
+    workspaceContextMock = { workspaceMetadata: new Map() };
+
+    const agentTaskArgs = {
+      subagent_type: "plan",
+      prompt: "Plan then implement.",
+      title: "Plan task",
+      run_in_background: true,
+    };
+    const AgentTaskToolCall = getToolComponent("task", agentTaskArgs);
+    const view = render(
+      <TooltipProvider>
+        <AgentTaskToolCall
+          args={agentTaskArgs}
+          result={{
+            status: "running",
+            taskId: "task-child-3",
+            modelString: "openai:gpt-5.2",
+            thinkingLevel: "low",
+            note: "Task started in background.",
+          }}
+          taskReportLinking={{
+            reportByTaskId: new Map([
+              [
+                "task-child-3",
+                {
+                  taskId: "task-child-3",
+                  reportMarkdown: "done",
+                  modelString: "anthropic:claude-opus-5",
+                  thinkingLevel: "high",
+                },
+              ],
+            ]),
+            suppressReportInAwaitTaskIds: new Set(["task-child-3"]),
+            spawnTitleByTaskId: new Map(),
+          }}
+          status="completed"
+        />
+      </TooltipProvider>
+    );
+
+    fireEvent.click(view.getByText("task"));
+
+    const settings = view.container.querySelector("[data-task-ai-settings]");
+    expect(settings?.textContent).toContain("Opus 5");
+    expect(settings?.textContent).toContain("thinking: high");
+    expect(settings?.textContent).not.toContain("thinking: low");
+  });
+
   test("falls back to result-carried settings after workspace cleanup", () => {
     workspaceContextMock = { workspaceMetadata: new Map() };
 
diff --git a/src/browser/features/Tools/TaskToolCall.tsx b/src/browser/features/Tools/TaskToolCall.tsx
index 7d45b27682..6aeadcd03d 100644
--- a/src/browser/features/Tools/TaskToolCall.tsx
+++ b/src/browser/features/Tools/TaskToolCall.tsx
@@ -995,10 +995,15 @@ export const TaskToolCall: React.FC<TaskToolCallProps> = ({
         normalizeTaskGroupLabel(metadata?.bestOf?.label) ??
         getTaskGroupLabelAtIndex(args, index),
       // Prefer live metadata while the workspace exists: a plan child's auto-handoff to
-      // exec rewrites its settings after launch, so a result snapshot can go stale.
-      // Result-carried settings remain as the fallback surviving workspace cleanup.
-      modelString: metadata?.taskModelString ?? resultAiSettings?.modelString,
-      thinkingLevel: metadata?.taskThinkingLevel ?? resultAiSettings?.thinkingLevel,
+      // exec rewrites its settings after launch, so a spawn snapshot can go stale. After
+      // cleanup, a linked task_await report carries report-time settings; the spawn
+      // result is the last resort.
+      modelString:
+        metadata?.taskModelString ?? linkedReport?.modelString ?? resultAiSettings?.modelString,
+      thinkingLevel:
+        metadata?.taskThinkingLevel ??
+        linkedReport?.thinkingLevel ??
+        resultAiSettings?.thinkingLevel,
     };
   });
 
diff --git a/src/browser/utils/messages/taskReportLinking.ts b/src/browser/utils/messages/taskReportLinking.ts
index cb731621d4..221d3f9364 100644
--- a/src/browser/utils/messages/taskReportLinking.ts
+++ b/src/browser/utils/messages/taskReportLinking.ts
@@ -1,9 +1,14 @@
 import type { DisplayedMessage } from "@/common/types/message";
+import { THINKING_LEVELS, type ThinkingLevel } from "@/common/types/thinking";
 
 export interface LinkedTaskReport {
   taskId: string;
   reportMarkdown: string;
   title?: string;
+  // Report-time AI settings: fresher than the spawn result when a plan child
+  // handed off to exec after launch.
+  modelString?: string;
+  thinkingLevel?: ThinkingLevel;
 }
 
 export interface TaskReportLinking {
@@ -122,12 +127,23 @@ export function computeTaskReportLinking(messages: DisplayedMessage[]): TaskRepo
       if (typeof reportMarkdown !== "string") continue;
 
       const title = (r as { title?: unknown }).title;
+      const modelString = (r as { modelString?: unknown }).modelString;
+      const thinkingLevel = (r as { thinkingLevel?: unknown }).thinkingLevel;
 
       // Last-wins (history order)
       reportByTaskId.set(taskId, {
         taskId,
         reportMarkdown,
         title: typeof title === "string" ? title : undefined,
+        modelString:
+          typeof modelString === "string" && modelString.trim().length > 0
+            ? modelString
+            : undefined,
+        thinkingLevel:
+          typeof thinkingLevel === "string" &&
+          (THINKING_LEVELS as readonly string[]).includes(thinkingLevel)
+            ? (thinkingLevel as ThinkingLevel)
+            : undefined,
       });
     }
   }
diff --git a/src/common/utils/tools/toolDefinitions.ts b/src/common/utils/tools/toolDefinitions.ts
index a1390586f6..9489870039 100644
--- a/src/common/utils/tools/toolDefinitions.ts
+++ b/src/common/utils/tools/toolDefinitions.ts
@@ -788,6 +788,8 @@ export const TaskAwaitToolCompletedResultSchema = z
     finalMessageRef: WorkspaceTurnFinalMessageRefSchema.optional(),
     structuredOutput: z.unknown().optional(),
     title: z.string().optional(),
+    modelString: z.string().optional(),
+    thinkingLevel: TaskThinkingLevelSchema.optional(),
     output: z.string().optional(),
     elapsed_ms: z.number().optional(),
     exitCode: z.number().optional(),
diff --git a/src/node/services/tools/task_await.test.ts b/src/node/services/tools/task_await.test.ts
index f270737082..81b345a0f8 100644
--- a/src/node/services/tools/task_await.test.ts
+++ b/src/node/services/tools/task_await.test.ts
@@ -565,6 +565,43 @@ describe("task_await tool", () => {
     );
   });
 
+  it("propagates report-time AI settings into completed results", async () => {
+    using tempDir = new TestTempDir("test-task-await-tool-report-settings");
+    const baseConfig = createTestToolConfig(tempDir.path, { workspaceId: "parent-workspace" });
+
+    const waitForAgentReport = mock(() =>
+      Promise.resolve({
+        reportMarkdown: "final report",
+        model: "anthropic:claude-opus-5",
+        thinkingLevel: "high" as const,
+      })
+    );
+    const taskService = {
+      listActiveDescendantAgentTaskIds: mock(() => ["t1"]),
+      isDescendantAgentTask: mock(() => Promise.resolve(true)),
+      waitForAgentReport,
+    } as unknown as TaskService;
+
+    const tool = createTaskAwaitTool({ ...baseConfig, taskService });
+
+    const result: unknown = await Promise.resolve(
+      tool.execute!({ task_ids: ["t1"] }, mockToolCallOptions)
+    );
+
+    expect(result).toEqual({
+      results: [
+        {
+          status: "completed",
+          taskId: "t1",
+          reportMarkdown: "final report",
+          modelString: "anthropic:claude-opus-5",
+          thinkingLevel: "high",
+          note: COMPLETED_REPORT_REFETCH_NOTE,
+        },
+      ],
+    });
+  });
+
   it("includes elapsed_ms for completed agent task results when timestamps are available", async () => {
     using tempDir = new TestTempDir("test-task-await-tool-agent-elapsed-completed");
     const baseConfig = createTestToolConfig(tempDir.path, { workspaceId: "parent-workspace" });
diff --git a/src/node/services/tools/task_await.ts b/src/node/services/tools/task_await.ts
index 4ba6b129cc..dfccbd6114 100644
--- a/src/node/services/tools/task_await.ts
+++ b/src/node/services/tools/task_await.ts
@@ -793,6 +793,8 @@ export const createTaskAwaitTool: ToolFactory = (config: ToolConfiguration) => {
               reportMarkdown: report.reportMarkdown,
               structuredOutput: report.structuredOutput,
               title: report.title,
+              ...(report.model != null ? { modelString: report.model } : {}),
+              ...(report.thinkingLevel != null ? { thinkingLevel: report.thinkingLevel } : {}),
               ...getAgentTaskElapsedField(taskId),
               ...(gitFormatPatch ? { artifacts: { gitFormatPatch } } : {}),
               note: COMPLETED_REPORT_REFETCH_NOTE,
@@ -821,6 +823,8 @@ export const createTaskAwaitTool: ToolFactory = (config: ToolConfiguration) => {
             reportMarkdown: report.reportMarkdown,
             structuredOutput: report.structuredOutput,
             title: report.title,
+            ...(report.model != null ? { modelString: report.model } : {}),
+            ...(report.thinkingLevel != null ? { thinkingLevel: report.thinkingLevel } : {}),
             ...getAgentTaskElapsedField(taskId),
             ...(gitFormatPatch ? { artifacts: { gitFormatPatch } } : {}),
             note: COMPLETED_REPORT_REFETCH_NOTE,