Class TaskService

src/node/services/taskService.ts:1081–10400

}

export class TaskService {
  // Serialize stream-end processing per workspace to avoid races when
  // finalizing reported tasks and cleanup state transitions.
  private readonly workspaceEventLocks = new MutexMap<string>();
  // Separate parent-scoped lock for deferred best-of fallback/finalization. This path can run
  // concurrently from multiple child stream-end handlers for the same parent, and it must remain
  // safe even when the parent stream-end already holds workspaceEventLocks for the parent itself.
  private readonly deferredBestOfLocks = new MutexMap<string>();
  // Serialize lifecycle actions per resolved child workspace: a batch may include both the
  // created handle and later existing-mode handles for the same workspace.
  private readonly workspaceLifecycleLocks = new MutexMap<string>();
  // Serialize terminal writes per workspace-turn handle so late completions/interruptions cannot
  // overwrite an already-settled handle.
  private readonly workspaceTurnSettlementLocks = new MutexMap<string>();
  private readonly mutex = new AsyncMutex();
  private maybeStartQueuedTasksInFlight: Promise<void> | undefined;
  private maybeStartQueuedTasksRerunRequested = false;
  // Git worktree creation touches per-repository metadata; serialize that narrow phase per project
  // while allowing post-fork init/send startup work for sibling tasks to overlap.
  private readonly reservedTaskLaunchByProjectPath = new Map<string, Promise<void>>();
  // In-flight durable persistence of notify_on_terminal policy for backgrounded foreground waits.
  // Awaited at the start of handleStreamEnd so a just-detached wait is treated as non-blocking.
  private readonly pendingNotifyOnTerminalPersists = new Set<Promise<void>>();
  // In-flight terminal attention drains (workspace-turn / sub-agent terminal wake-ups). Tracked so
  // tests and shutdown can await them; drains are idempotent and re-triggered on owner idle events.
  private readonly pendingTerminalAttentionDrainsByOwner = new Map<string, Promise<void>>();
  private readonly pendingTerminalAttentionDrains = new Set<Promise<void>>();
  private readonly pendingWaitersByTaskId = new Map<string, PendingTaskWaiter[]>();
  private readonly pendingStartWaitersByTaskId = new Map<string, PendingTaskStartWaiter[]>();
  // Tracks workspaces currently blocked in a foreground wait (e.g. a task tool call awaiting
  // agent_report). Used to avoid scheduler deadlocks when maxParallelAgentTasks is low and tasks
  // spawn nested tasks in the foreground.
  private readonly foregroundAwaitCountByWorkspaceId = new Map<string, number>();
  private readonly backgroundableForegroundWaitersByWorkspaceId = new Map<
    string,
    Set<BackgroundableForegroundWaiter>
  >();
  private readonly pendingWorkspaceTurnWaitersByHandleId = new Map<string, WorkspaceTurnWaiter[]>();
  private readonly activeWorkspaceTurnHandleByWorkspaceId = new Map<
    string,
    { handleId: string; ownerWorkspaceId: string }
  >();
  private readonly taskHandleStore: TaskHandleStore;
  private readonly terminalAttentionStore: TerminalAttentionStore;
  private readonly userBackgroundedTaskIds = new Set<string>();

  // Cache completed reports so callers can retrieve them without re-reading disk.
  // Bounded by max entries; disk persistence is the source of truth for restart-safety.
  private readonly completedReportsByTaskId = new Map<string, CompletedAgentReportCacheEntry>();
  private readonly gitPatchArtifactService: GitPatchArtifactService;
  private readonly handoffInProgress = new Set<string>();
  /**
   * Hard-interrupted parent workspaces must not auto-resume until the next user message.
   * This closes races where descendants could report between parent interrupt and cascade cleanup.
   */
  private interruptedParentWorkspaceIds = new Set<string>();
  /** Tracks consecutive auto-resumes per workspace. Reset when a user message is sent. */
  private consecutiveAutoResumes = new Map<string, number>();