Method handleStreamEnd

src/node/services/taskService.ts:7918–8319

(event: StreamEndEvent)

  }

  private async handleStreamEnd(event: StreamEndEvent): Promise<void> {
    const workspaceId = event.workspaceId;

    // Ensure any in-flight notify_on_terminal persistence (from a just-detached foreground wait)
    // has settled so the config we read below reflects the durable non-blocking policy.
    if (this.pendingNotifyOnTerminalPersists.size > 0) {
      await Promise.all([...this.pendingNotifyOnTerminalPersists]);
    }

    // The owner's own stream ending is the signal to retry any terminal wake-ups that were deferred
    // while it was busy. Drain checks idle internally and leaves notifications pending otherwise.
    this.scheduleTerminalAttentionDrain(workspaceId);

    const cfg = this.config.loadConfigOrDefault();
    const entry = findWorkspaceEntry(cfg, workspaceId);
    if (!entry) return;
    const taskIndex = this.buildAgentTaskIndex(cfg);

    // Parent workspaces must not end while they have active background tasks/workflows.
    // Enforce by auto-resuming the stream with a directive to await outstanding work.
    if (!entry.workspace.parentWorkspaceId) {
      const hasActiveDescendants = this.hasActiveDescendantAgentTasksUsingIndex(
        taskIndex,
        workspaceId
      );
      const referencedWorkflowRunIds = await this.listAgentReferencedWorkflowRunIds(
        workspaceId,
        event.parts,
        event.messageId
      );
      let activeWorkflowRunIds = await this.listActiveBackgroundWorkflowRunIds(
        workspaceId,
        referencedWorkflowRunIds
      );
      let activeWorkspaceTurnIds = await this.listActiveWorkspaceTurnTaskIdsForOwner(workspaceId);
      if (!hasActiveDescendants) {
        // Foreground best-of children can finish while the parent task tool call is still pending,
        // which temporarily blocks their leaf cleanup and may defer synthetic fallback delivery.
        // Recheck both once the parent stream reaches a descendant-free stream-end.
        await this.deliverDeferredBestOfReportsForParent(workspaceId);
        await this.requestReportedChildCleanupRechecks(workspaceId);
        if (activeWorkflowRunIds.length === 0 && activeWorkspaceTurnIds.length === 0) {
          if (await this.finalizeWorkspaceTurnFromStreamEnd(event)) {
            return;
          }
          this.consecutiveAutoResumes.delete(workspaceId);
          return;
        }
      }

      // Workflow-owned descendants report through the workflow runner; parent nudges must not
      // bypass that journal/final-result path by asking the model to task_await those child tasks
      // directly. Instead, await the owning workflow run when one is still active.
      // Foreground waits can also be backgrounded at runtime when users queue another message.
      const listBlockingDescendantTaskIds = () =>
        this.listBlockingActiveDescendantAgentTaskIdsUsingIndex(taskIndex, workspaceId, {
          excludeWorkflowTasks: true,
        });