🤖 Add Storybook story for Tasks settings section

- Add Tasks story to App.settings.stories.tsx
- Add getTaskSettings/setTaskSettings mock endpoints
- Fix lint errors in taskService.test.ts (use return instead of async/await)
- Fix taskId passed to injectToolOutputToParent (use child ID, not parent)
- Include tool args in ask_user_question tool-call-end events

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

Author: ThomasK33

.storybook/mocks/orpc.ts

@@ -152,6 +152,11 @@ export function createMockORPCClient(options: MockORPCClientOptions = {}): APICl
       tick: async function* () {
         // No-op generator
       },
+      getTaskSettings: async () => ({
+        maxParallelAgentTasks: 3,
+        maxTaskNestingDepth: 3,
+      }),
+      setTaskSettings: async () => undefined,
     },
     projects: {
       list: async () => Array.from(projects.entries()),

src/browser/stories/App.settings.stories.tsx

@@ -200,3 +200,11 @@ export const ExperimentsToggleOff: AppStory = {
     // Default state is OFF - no clicks needed
   },
 };
+
+/** Tasks section - shows agent task limits configuration */
+export const Tasks: AppStory = {
+  render: () => <AppWithMocks setup={() => setupSettingsStory({})} />,
+  play: async ({ canvasElement }: { canvasElement: HTMLElement }) => {
+    await openSettingsToSection(canvasElement, "tasks");
+  },
+};

src/browser/utils/messages/retryEligibility.ts

@@ -110,7 +110,11 @@ export function hasInterruptedStream(
   // restart, which drops the unfinished tool call from the prompt and can lead
   // to duplicate task spawns. TaskService injects the tool output and auto-resumes
   // the parent once the subagent reports.
-  if (lastMessage.type === "tool" && lastMessage.toolName === "task" && lastMessage.status === "executing") {
+  if (
+    lastMessage.type === "tool" &&
+    lastMessage.toolName === "task" &&
+    lastMessage.status === "executing"
+  ) {
     return false;
   }
 

src/node/services/taskService.test.ts

@@ -15,19 +15,19 @@ import type { SendMessageError } from "@/common/types/errors";
 import { Err, Ok, type Result } from "@/common/types/result";
 import assert from "@/common/utils/assert";
 
-type SendMessageCall = {
+interface SendMessageCall {
   workspaceId: string;
   message: string;
   options: SendMessageOptions | undefined;
-};
+}
 
-type CreateCall = {
+interface CreateCall {
   projectPath: string;
   branchName: string;
   trunkBranch: string | undefined;
   title: string | undefined;
   runtimeConfig: RuntimeConfig | undefined;
-};
+}
 
 class FakeAIService extends EventEmitter {
   private readonly streaming = new Set<string>();
@@ -49,11 +49,9 @@ class FakeAIService extends EventEmitter {
     this.metadataById.set(metadata.id, metadata);
   }
 
-  async getWorkspaceMetadata(
-    workspaceId: string
-  ): Promise<Result<FrontendWorkspaceMetadata, string>> {
+  getWorkspaceMetadata(workspaceId: string): Promise<Result<FrontendWorkspaceMetadata, string>> {
     const metadata = this.metadataById.get(workspaceId);
-    return metadata ? Ok(metadata) : Err(`Workspace ${workspaceId} not found`);
+    return Promise.resolve(metadata ? Ok(metadata) : Err(`Workspace ${workspaceId} not found`));
   }
 }
 
@@ -96,7 +94,7 @@ class FakeConfig {
     return this.taskStateById.get(workspaceId);
   }
 
-  async setWorkspaceTaskState(workspaceId: string, taskState: TaskState): Promise<void> {
+  setWorkspaceTaskState(workspaceId: string, taskState: TaskState): Promise<void> {
     this.taskStateById.set(workspaceId, taskState);
 
     const existing = this.metadataById.get(workspaceId);
@@ -108,6 +106,7 @@ class FakeConfig {
         taskState,
       });
     }
+    return Promise.resolve();
   }
 
   countRunningAgentTasks(): number {
@@ -156,8 +155,8 @@ class FakeConfig {
     return result;
   }
 
-  async getAllWorkspaceMetadata(): Promise<FrontendWorkspaceMetadata[]> {
-    return [...this.metadataById.values()];
+  getAllWorkspaceMetadata(): Promise<FrontendWorkspaceMetadata[]> {
+    return Promise.resolve([...this.metadataById.values()]);
   }
 }
 
@@ -168,13 +167,13 @@ class FakePartialService {
     this.partialByWorkspaceId.set(workspaceId, partial);
   }
 
-  async readPartial(workspaceId: string): Promise<MuxMessage | null> {
-    return this.partialByWorkspaceId.get(workspaceId) ?? null;
+  readPartial(workspaceId: string): Promise<MuxMessage | null> {
+    return Promise.resolve(this.partialByWorkspaceId.get(workspaceId) ?? null);
   }
 
-  async writePartial(workspaceId: string, msg: MuxMessage): Promise<Result<void, string>> {
+  writePartial(workspaceId: string, msg: MuxMessage): Promise<Result<void, string>> {
     this.partialByWorkspaceId.set(workspaceId, msg);
-    return Ok(undefined);
+    return Promise.resolve(Ok(undefined));
   }
 }
 
@@ -185,29 +184,31 @@ class FakeHistoryService {
     this.historyByWorkspaceId.set(workspaceId, history);
   }
 
-  async getHistory(workspaceId: string): Promise<Result<MuxMessage[], string>> {
-    return Ok(this.historyByWorkspaceId.get(workspaceId) ?? []);
+  getHistory(workspaceId: string): Promise<Result<MuxMessage[], string>> {
+    return Promise.resolve(Ok(this.historyByWorkspaceId.get(workspaceId) ?? []));
   }
 
-  async updateHistory(workspaceId: string, msg: MuxMessage): Promise<Result<void, string>> {
+  updateHistory(workspaceId: string, msg: MuxMessage): Promise<Result<void, string>> {
     const existing = this.historyByWorkspaceId.get(workspaceId) ?? [];
     const idx = existing.findIndex((m) => m.id === msg.id);
     if (idx === -1) {
-      return Err(`Message ${msg.id} not found`);
+      return Promise.resolve(Err(`Message ${msg.id} not found`));
     }
     const updated = [...existing];
     updated[idx] = msg;
     this.historyByWorkspaceId.set(workspaceId, updated);
-    return Ok(undefined);
+    return Promise.resolve(Ok(undefined));
   }
 }
 
 class FakeWorkspaceService {
   private nextWorkspaceId = 1;
   readonly createCalls: CreateCall[] = [];
   readonly sendMessageCalls: SendMessageCall[] = [];
-  readonly resumeStreamCalls: Array<{ workspaceId: string; options: SendMessageOptions | undefined }> =
-    [];
+  readonly resumeStreamCalls: Array<{
+    workspaceId: string;
+    options: SendMessageOptions | undefined;
+  }> = [];
   readonly removedWorkspaceIds: string[] = [];
   readonly appendedMessages: Array<{ workspaceId: string; message: MuxMessage }> = [];
 
@@ -218,7 +219,7 @@ class FakeWorkspaceService {
     private readonly aiService: FakeAIService
   ) {}
 
-  async create(
+  create(
     projectPath: string,
     branchName: string,
     trunkBranch: string | undefined,
@@ -240,38 +241,38 @@ class FakeWorkspaceService {
     this.config.addWorkspace(metadata, metadata.namedWorkspacePath);
     this.aiService.setWorkspaceMetadata(metadata);
 
-    return Ok({ metadata });
+    return Promise.resolve(Ok({ metadata }));
   }
 
-  async sendMessage(
+  sendMessage(
     workspaceId: string,
     message: string,
     options: SendMessageOptions | undefined = undefined
   ): Promise<Result<void, SendMessageError>> {
     this.sendMessageCalls.push({ workspaceId, message, options });
-    return this.sendMessageResult;
+    return Promise.resolve(this.sendMessageResult);
   }
 
-  async resumeStream(
+  resumeStream(
     workspaceId: string,
     options: SendMessageOptions | undefined = undefined
   ): Promise<Result<void, SendMessageError>> {
     this.resumeStreamCalls.push({ workspaceId, options });
-    return Ok(undefined);
+    return Promise.resolve(Ok(undefined));
   }
 
-  async remove(workspaceId: string): Promise<Result<void, string>> {
+  remove(workspaceId: string): Promise<Result<void, string>> {
     this.removedWorkspaceIds.push(workspaceId);
     this.config.removeWorkspace(workspaceId);
-    return Ok(undefined);
+    return Promise.resolve(Ok(undefined));
   }
 
-  async appendToHistoryAndEmit(
+  appendToHistoryAndEmit(
     workspaceId: string,
     muxMessage: MuxMessage
   ): Promise<Result<void, string>> {
     this.appendedMessages.push({ workspaceId, message: muxMessage });
-    return Ok(undefined);
+    return Promise.resolve(Ok(undefined));
   }
 }
 
@@ -346,7 +347,7 @@ describe("TaskService", () => {
     globalThis.setTimeout = realSetTimeout;
   });
 
-  it("throws if parent workspace not found", async () => {
+  it("throws if parent workspace not found", () => {
     const config = new FakeConfig();
     const aiService = new FakeAIService();
     const workspaceService = new FakeWorkspaceService(config, aiService);
@@ -361,7 +362,7 @@ describe("TaskService", () => {
       aiService as unknown as AIService
     );
 
-    await expect(
+    return expect(
       taskService.createTask({
         parentWorkspaceId: "missing",
         agentType: "research",
@@ -371,7 +372,7 @@ describe("TaskService", () => {
     ).rejects.toThrow("Parent workspace missing not found");
   });
 
-  it("enforces maxTaskNestingDepth", async () => {
+  it("enforces maxTaskNestingDepth", () => {
     const config = new FakeConfig();
     config.setTaskSettings({ maxTaskNestingDepth: 1 });
 
@@ -395,7 +396,7 @@ describe("TaskService", () => {
       aiService as unknown as AIService
     );
 
-    await expect(
+    return expect(
       taskService.createTask({
         parentWorkspaceId: "child",
         agentType: "research",
@@ -565,7 +566,7 @@ describe("TaskService", () => {
     const taskPart = parentPartialAfter.parts.find(
       (p) => p.type === "dynamic-tool" && p.toolName === "task" && p.toolCallId === "call_1"
     );
-    assert(taskPart && taskPart.type === "dynamic-tool", "expected dynamic tool part");
+    assert(taskPart?.type === "dynamic-tool", "expected dynamic tool part");
     expect(taskPart.state).toBe("output-available");
 
     // Synthetic tool-call-end for the task tool should be emitted for UI update.

src/node/services/taskService.ts

@@ -428,7 +428,11 @@ export class TaskService extends EventEmitter {
     }
   }
 
-  private async postFailureToParent(taskId: string, taskState: TaskState, error: string): Promise<void> {
+  private async postFailureToParent(
+    taskId: string,
+    taskState: TaskState,
+    error: string
+  ): Promise<void> {
     try {
       const preset = getAgentPreset(taskState.agentType);
       const title = `${preset.name} Task Failed`;
@@ -476,7 +480,10 @@ export class TaskService extends EventEmitter {
       if (partial) {
         const finalized = this.tryFinalizeTaskToolCall(partial, parentToolCallId, toolOutput);
         if (finalized) {
-          const writeResult = await this.partialService.writePartial(parentWorkspaceId, finalized.updated);
+          const writeResult = await this.partialService.writePartial(
+            parentWorkspaceId,
+            finalized.updated
+          );
           if (!writeResult.success) {
             throw new Error(writeResult.error);
           }
@@ -624,7 +631,11 @@ export class TaskService extends EventEmitter {
 
     // Re-check state
     const updatedState = this.config.getWorkspaceTaskState(workspaceId);
-    if (!updatedState || updatedState.taskStatus === "reported" || updatedState.taskStatus === "failed") {
+    if (
+      !updatedState ||
+      updatedState.taskStatus === "reported" ||
+      updatedState.taskStatus === "failed"
+    ) {
       return;
     }
 
@@ -673,7 +684,9 @@ export class TaskService extends EventEmitter {
 
     if (updatedState.taskStatus === "awaiting_report") {
       // Reminder stream ended and agent_report still wasn't called. Fall back to best-effort report.
-      log.warn(`Task ${workspaceId} still missing agent_report after reminder, using fallback report`);
+      log.warn(
+        `Task ${workspaceId} still missing agent_report after reminder, using fallback report`
+      );
       const fallback = await this.synthesizeFallbackReportMarkdown(workspaceId);
       await this.handleAgentReport(workspaceId, {
         reportMarkdown: fallback,
@@ -857,7 +870,10 @@ export class TaskService extends EventEmitter {
 
       // If the parent is also a completed task workspace, it might now be eligible for cleanup.
       const parentTaskState = this.config.getWorkspaceTaskState(taskState.parentWorkspaceId);
-      if (parentTaskState && (parentTaskState.taskStatus === "reported" || parentTaskState.taskStatus === "failed")) {
+      if (
+        parentTaskState &&
+        (parentTaskState.taskStatus === "reported" || parentTaskState.taskStatus === "failed")
+      ) {
         await this.cleanupTaskSubtree(taskState.parentWorkspaceId, seen);
       }
     } catch (error) {
@@ -943,7 +959,9 @@ export class TaskService extends EventEmitter {
       const allMetadata = await this.config.getAllWorkspaceMetadata();
       const completedTaskIds = allMetadata
         .filter(
-          (m) => m.taskState && (m.taskState.taskStatus === "reported" || m.taskState.taskStatus === "failed")
+          (m) =>
+            m.taskState &&
+            (m.taskState.taskStatus === "reported" || m.taskState.taskStatus === "failed")
         )
         .map((m) => m.id);
 
@@ -980,7 +998,8 @@ export class TaskService extends EventEmitter {
       }
 
       // Prefer resuming with the model used for the interrupted assistant message.
-      const modelFromPartial = typeof partial.metadata?.model === "string" ? partial.metadata.model : "";
+      const modelFromPartial =
+        typeof partial.metadata?.model === "string" ? partial.metadata.model : "";
 
       const metadataResult = await this.aiService.getWorkspaceMetadata(parentWorkspaceId);
       const aiSettings = metadataResult.success ? metadataResult.data.aiSettings : undefined;
@@ -997,7 +1016,10 @@ export class TaskService extends EventEmitter {
         ...(normalizedMode ? { mode: normalizedMode } : {}),
       });
       if (!resumeResult.success) {
-        log.error(`Failed to auto-resume parent workspace ${parentWorkspaceId}:`, resumeResult.error);
+        log.error(
+          `Failed to auto-resume parent workspace ${parentWorkspaceId}:`,
+          resumeResult.error
+        );
       }
     } catch (error) {
       log.error(`Failed to auto-resume parent workspace ${parentWorkspaceId}:`, error);

src/node/services/workspaceService.ts

@@ -1146,7 +1146,10 @@ export class WorkspaceService extends EventEmitter {
       // If this workspace has a pending `task` tool call in partial.json and isn't currently
       // streaming, starting a new stream would drop the unfinished tool call from the prompt
       // (ignoreIncompleteToolCalls=true) and can lead to duplicate task spawns.
-      if (!this.aiService.isStreaming(workspaceId) && (await this.hasPendingTaskToolCalls(workspaceId))) {
+      if (
+        !this.aiService.isStreaming(workspaceId) &&
+        (await this.hasPendingTaskToolCalls(workspaceId))
+      ) {
         return Err({
           type: "unknown",
           raw: "Workspace is awaiting a subagent task. Please wait for it to complete; it will auto-resume when ready.",
@@ -1275,7 +1278,8 @@ export class WorkspaceService extends EventEmitter {
     }
 
     return partial.parts.some(
-      (part) => isDynamicToolPart(part) && part.toolName === "task" && part.state !== "output-available"
+      (part) =>
+        isDynamicToolPart(part) && part.toolName === "task" && part.state !== "output-available"
     );
   }
 
@@ -1756,9 +1760,15 @@ export class WorkspaceService extends EventEmitter {
     }
   }
 
-  async appendToHistoryAndEmit(workspaceId: string, muxMessage: MuxMessage): Promise<Result<void, string>> {
+  async appendToHistoryAndEmit(
+    workspaceId: string,
+    muxMessage: MuxMessage
+  ): Promise<Result<void, string>> {
     try {
-      assert(workspaceId && workspaceId.trim().length > 0, "appendToHistoryAndEmit requires workspaceId");
+      assert(
+        workspaceId && workspaceId.trim().length > 0,
+        "appendToHistoryAndEmit requires workspaceId"
+      );
 
       const appendResult = await this.historyService.appendToHistory(workspaceId, muxMessage);
       if (!appendResult.success) {