🤖 fix: incorporate linter changes and improvements to task service

- Add guardrail to prevent spawning tasks after agent_report
- Improve trunk branch detection for worktree runtimes (use parent's current branch)
- Add fallback report synthesis when agent_report is missing
- Add proper failure handling with postFailureToParent
- Add maybeResumeParentStream for auto-resuming parent after task completion
- Add hasActiveDescendantTasks check before resuming
- Add cleanupTaskSubtree for proper cleanup of task hierarchies
- Add hasPendingTaskToolCalls guard in workspaceService
- Add appendToHistoryAndEmit helper method
- Various robustness improvements from linter suggestions

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

Author: ThomasK33

src/browser/utils/messages/retryEligibility.ts

@@ -103,6 +103,17 @@ export function hasInterruptedStream(
     return false;
   }
 
+  // task is also a special case: an unfinished tool call represents an intentional
+  // "waiting for subagent task completion" state, not a stream interruption.
+  //
+  // Treating it as interrupted causes RetryBarrier + auto-resume to fire on app
+  // 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") {
+    return false;
+  }
+
   return (
     lastMessage.type === "stream-error" || // Stream errored out (show UI for ALL error types)
     lastMessage.type === "user" || // No response received yet (app restart during slow model)

src/node/services/aiService.ts

@@ -49,6 +49,7 @@ import type { TelemetryService } from "@/node/services/telemetryService";
 import { getRuntimeTypeForTelemetry, roundToBase2 } from "@/common/telemetry/utils";
 import type { MCPServerManager, MCPWorkspaceStats } from "@/node/services/mcpServerManager";
 import type { TaskService } from "@/node/services/taskService";
+import { getAgentPreset, getAgentToolPolicy } from "@/common/constants/agentPresets";
 import { buildProviderOptions } from "@/common/utils/ai/providerOptions";
 import type { ThinkingLevel } from "@/common/types/thinking";
 import type {
@@ -1064,6 +1065,8 @@ export class AIService extends EventEmitter {
       // Construct plan mode instruction if in plan mode
       // This is done backend-side because we have access to the plan file path
       let effectiveAdditionalInstructions = additionalSystemInstructions;
+      let includeCustomInstructions = true;
+      let effectiveToolPolicy: ToolPolicy | undefined = toolPolicy;
       const planFilePath = getPlanFilePath(metadata.name, metadata.projectName);
 
       // Read plan file (handles legacy migration transparently)
@@ -1081,6 +1084,17 @@ export class AIService extends EventEmitter {
           : planModeInstruction;
       }
 
+      // Agent-task workspaces enforce preset tool policy + system prompt centrally.
+      // V1 uses "replace" semantics: ignore workspace/user custom instructions and use the preset prompt.
+      if (metadata.agentType) {
+        const preset = getAgentPreset(metadata.agentType);
+        effectiveToolPolicy = getAgentToolPolicy(metadata.agentType, toolPolicy);
+        includeCustomInstructions = false;
+        effectiveAdditionalInstructions = effectiveAdditionalInstructions
+          ? `${preset.systemPrompt}\n\n${effectiveAdditionalInstructions}`
+          : preset.systemPrompt;
+      }
+
       // Read plan content for mode transition (plan → exec)
       // Only read if switching to exec mode and last assistant was in plan mode
       let planContentForTransition: string | undefined;
@@ -1160,7 +1174,8 @@ export class AIService extends EventEmitter {
         mode,
         effectiveAdditionalInstructions,
         modelString,
-        mcpServers
+        mcpServers,
+        { includeCustomInstructions }
       );
 
       // Count system message tokens for cost tracking
@@ -1246,7 +1261,7 @@ export class AIService extends EventEmitter {
       );
 
       // Apply tool policy to filter tools (if policy provided)
-      const tools = applyToolPolicy(allTools, toolPolicy);
+      const tools = applyToolPolicy(allTools, effectiveToolPolicy);
 
       const effectiveMcpStats: MCPWorkspaceStats =
         mcpStats ??
@@ -1296,7 +1311,7 @@ export class AIService extends EventEmitter {
         workspaceId,
         model: modelString,
         toolNames: Object.keys(tools),
-        hasToolPolicy: Boolean(toolPolicy),
+        hasToolPolicy: Boolean(effectiveToolPolicy && effectiveToolPolicy.length > 0),
       });
 
       // Create assistant message placeholder with historySequence from backend

src/node/services/systemMessage.ts

@@ -251,47 +251,54 @@ export async function buildSystemMessage(
   mode?: string,
   additionalSystemInstructions?: string,
   modelString?: string,
-  mcpServers?: MCPServerMap
+  mcpServers?: MCPServerMap,
+  options?: { includeCustomInstructions?: boolean }
 ): Promise<string> {
   if (!metadata) throw new Error("Invalid workspace metadata: metadata is required");
   if (!workspacePath) throw new Error("Invalid workspace path: workspacePath is required");
 
-  // Read instruction sets
-  const [globalInstructions, contextInstructions] = await readInstructionSources(
-    metadata,
-    runtime,
-    workspacePath
-  );
-
-  // Combine: global + context (workspace takes precedence over project) after stripping scoped sections
-  const sanitizeScopedInstructions = (input?: string | null): string | undefined => {
-    if (!input) return undefined;
-    const stripped = stripScopedInstructionSections(input);
-    return stripped.trim().length > 0 ? stripped : undefined;
-  };
+  const includeCustomInstructions = options?.includeCustomInstructions ?? true;
 
-  const customInstructionSources = [
-    sanitizeScopedInstructions(globalInstructions),
-    sanitizeScopedInstructions(contextInstructions),
-  ].filter((value): value is string => Boolean(value));
-  const customInstructions = customInstructionSources.join("\n\n");
-
-  // Extract mode-specific section (context first, then global fallback)
+  let customInstructions = "";
   let modeContent: string | null = null;
-  if (mode) {
-    modeContent =
-      (contextInstructions && extractModeSection(contextInstructions, mode)) ??
-      (globalInstructions && extractModeSection(globalInstructions, mode)) ??
-      null;
-  }
-
-  // Extract model-specific section based on active model identifier (context first)
   let modelContent: string | null = null;
-  if (modelString) {
-    modelContent =
-      (contextInstructions && extractModelSection(contextInstructions, modelString)) ??
-      (globalInstructions && extractModelSection(globalInstructions, modelString)) ??
-      null;
+
+  if (includeCustomInstructions) {
+    // Read instruction sets
+    const [globalInstructions, contextInstructions] = await readInstructionSources(
+      metadata,
+      runtime,
+      workspacePath
+    );
+
+    // Combine: global + context (workspace takes precedence over project) after stripping scoped sections
+    const sanitizeScopedInstructions = (input?: string | null): string | undefined => {
+      if (!input) return undefined;
+      const stripped = stripScopedInstructionSections(input);
+      return stripped.trim().length > 0 ? stripped : undefined;
+    };
+
+    const customInstructionSources = [
+      sanitizeScopedInstructions(globalInstructions),
+      sanitizeScopedInstructions(contextInstructions),
+    ].filter((value): value is string => Boolean(value));
+    customInstructions = customInstructionSources.join("\n\n");
+
+    // Extract mode-specific section (context first, then global fallback)
+    if (mode) {
+      modeContent =
+        (contextInstructions && extractModeSection(contextInstructions, mode)) ??
+        (globalInstructions && extractModeSection(globalInstructions, mode)) ??
+        null;
+    }
+
+    // Extract model-specific section based on active model identifier (context first)
+    if (modelString) {
+      modelContent =
+        (contextInstructions && extractModelSection(contextInstructions, modelString)) ??
+        (globalInstructions && extractModelSection(globalInstructions, modelString)) ??
+        null;
+    }
   }
 
   // Get runtime type from metadata (defaults to "local" for legacy workspaces without runtimeConfig)