Preserve task cancel, auth, and abort contracts through the fleet wrapper

Director task() now routes through spawn_agent + wait_agents, which was
misclassifying AbortError as failed:aborted, dropping Re-authenticate
auth wording, and leaving the child running when the parent tool aborted.
Map those outcomes back to the legacy fused-task parent contract and
prettier the inherited agent-progress tip.

Author: TheGreatAxios

src/subagent/agent-fleet.ts

@@ -63,7 +63,7 @@ import type { Settings } from "../config/settings.js";
 import { resolveEffortForRole } from "../provider/reasoning-effort.js";
 import { isCodexProviderName } from "../config/codex-providers.js";
 import { buildDispatchBrief, type TaskIntent } from "./report.js";
-import type { SubAgentSessionStore } from "./session-store.js";
+import { DEFAULT_CANCEL_REASON, type SubAgentSessionStore } from "./session-store.js";
 import type {
   NestedDispatchDeps,
   RunSubAgentParams,
@@ -75,6 +75,8 @@ import { cleanupSubAgentWorktree, createSubAgentWorktree, WorktreeError } from "
 import { NOOP_TELEMETRY, type Telemetry } from "../telemetry/index.js";
 import { classifyAgentName } from "../telemetry/classify.js";
 import type { DirectorPackage } from "../agent/directors/types.js";
+import { formatSubAgentTaskAuthFailureMessage } from "./inference-auth-failure.js";
+import { isSubAgentCancelError } from "./dispose.js";
 
 const log = getLogger([LOG_NAMESPACE_ROOT, "subagent", "agent-fleet"]);
 
@@ -718,11 +720,24 @@ export function createSpawnAgentTool(deps: AgentFleetDeps): AgentTool {
         })
         .catch((err) => {
           // Always terminalize fleetRecords — including pre-progress cancel that
-          // rethrows with no salvage — so wait_agents does not hang. fail()
-          // no-ops when cancel already flipped the strip status.
-          const message = err instanceof Error ? err.message : String(err);
-          deps.fleetRecords.reject(session.id, message);
-          deps.sessions.fail(session.id, message);
+          // rethrows with no salvage — so wait_agents does not hang. Prefer
+          // cancel semantics over fail when the strip already cancelled or the
+          // throw is an AbortError (legacy task() parent contract).
+          const alreadyCancelled = deps.sessions.get(session.id)?.status === "cancelled";
+          if (alreadyCancelled || isSubAgentCancelError(err, childCtl.signal)) {
+            if (!alreadyCancelled) {
+              deps.sessions.cancel(session.id, DEFAULT_CANCEL_REASON);
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            deps.fleetRecords.reject(session.id, message);
+            return;
+          }
+          // Auth failures keep the actionable Re-authenticate wording that
+          // task()'s fused path surfaces via formatSubAgentTaskAuthFailureMessage.
+          const authMessage = formatSubAgentTaskAuthFailureMessage(description, err);
+          const failReason = authMessage ?? (err instanceof Error ? err.message : String(err));
+          deps.fleetRecords.reject(session.id, failReason);
+          deps.sessions.fail(session.id, failReason);
         })
         .finally(() => {
           telemetry.capture("subagent_end", {

src/subagent/task-tool.ts

@@ -397,16 +397,54 @@ async function runTaskViaFleet(input: {
     if (result === undefined) {
       return taskToolResult(input.callId, `Error: wait_agents returned no result for ${agentId}.`);
     }
+    // Cancel must not be misclassified as failed:abort — strip cancel /
+    // AbortError leaves fleetRecords as failed with "aborted" while the
+    // session store holds cancelled + the operator reason. A cancel that
+    // still resolved a salvage body (fleet status done) keeps the report,
+    // matching the fused task() race contract.
+    const session = input.sessions.get(agentId);
+    if (session?.status === "cancelled") {
+      if (
+        (result.status === "done" || result.status === "interrupted") &&
+        typeof result.report === "string" &&
+        result.report.length > 0
+      ) {
+        return taskToolResult(
+          input.callId,
+          `Sub-agent "${input.description}" reported:\n\n${result.report}`,
+        );
+      }
+      return taskToolResult(
+        input.callId,
+        cancelledSubAgentMessage(input.description, session.error),
+      );
+    }
     if (result.status === "failed") {
+      const errText = result.error ?? "unknown error";
+      // Auth failures already carry the actionable Re-authenticate wording
+      // from formatSubAgentTaskAuthFailureMessage (baked in spawn catch).
+      if (errText.includes("Re-authenticate")) {
+        return taskToolResult(input.callId, `Error: ${errText}`);
+      }
       return taskToolResult(
         input.callId,
-        `Error: sub-agent "${input.description}" failed: ${result.error ?? "unknown error"}`,
+        `Error: sub-agent "${input.description}" failed: ${errText}`,
       );
     }
     const report = result.report ?? "";
     return taskToolResult(input.callId, `Sub-agent "${input.description}" reported:\n\n${report}`);
   }
-  return taskToolResult(input.callId, `Sub-agent "${input.description}" cancelled by operator.`);
+  // Parent tool abort must cancel the child — wait_agents itself has no
+  // abort side effects (workers stay waitable), so task()'s fused contract
+  // owns the cancel here.
+  if (input.sessions.get(agentId)?.status === "running") {
+    input.sessions.cancel(agentId);
+  }
+  const cancelled = input.sessions.get(agentId);
+  return taskToolResult(
+    input.callId,
+    cancelledSubAgentMessage(input.description, cancelled?.error),
+  );
 }
 
 export function createTaskTool(deps: TaskToolDeps): AgentTool {