Method updateStreamingStatus

src/node/services/workspaceService.ts:2449–2513

(
    workspaceId: string,
    streaming: boolean,
    update: ExtensionMetadataStreamingUpdate = {}
  )

  }

  private async updateStreamingStatus(
    workspaceId: string,
    streaming: boolean,
    update: ExtensionMetadataStreamingUpdate = {}
  ): Promise<void> {
    const streamGeneration = update.generation ?? this.streamingGenerations.get(workspaceId) ?? 0;
    try {
      let { hasTodos, todoStatus } = update;
      if (!streaming && (hasTodos === undefined || todoStatus === undefined)) {
        // Stop snapshots need an authoritative todo summary even for background workspaces,
        // and centralizing the read here preserves the fire-and-forget abort/error handlers.
        const sessionDir = this.config.getSessionDir(workspaceId);
        const todos = await readTodosForSessionDir(sessionDir);
        hasTodos ??= todos.length > 0;
        // When there are no todos to derive from, leave `todoStatus` undefined
        // so setStreaming doesn't touch the slot. AgentStatusService writes
        // its AI-generated summary into the same `todoStatus` field — passing
        // `null` here would clobber a freshly generated summary every time a
        // free-form (no-todo) turn ends. Explicit clears still happen via
        // setTodoStatus(null) when the agent calls `todo_write([])`.
        todoStatus ??= deriveTodoStatus(todos);
      }
      if (
        !streaming &&
        update.generation !== undefined &&
        update.generation !== (this.streamingGenerations.get(workspaceId) ?? 0)
      ) {
        // A newer stream has started since this stop was initiated, so dropping the stale
        // streaming=false write preserves the active stream's metadata snapshot.
        return;
      }

      const snapshot = await this.extensionMetadata.setStreaming(workspaceId, streaming, {
        ...update,
        ...(todoStatus !== undefined ? { todoStatus } : {}),
        ...(hasTodos !== undefined ? { hasTodos } : {}),
      });
      // Compaction tagging is stop-snapshot only. Never tag streaming=true updates,
      // otherwise fast follow-up turns can inherit stale compaction metadata before cleanup runs.
      const shouldTagCompaction =
        !streaming && this.compactionStreamGenerations.get(workspaceId) === streamGeneration;
      const shouldTagIdleCompaction = !streaming && this.idleCompactingWorkspaces.has(workspaceId);
      this.emitWorkspaceActivity(
        workspaceId,
        await this.mergeCurrentActiveWorkflowRunCount(workspaceId, {
          ...snapshot,
          ...(shouldTagCompaction ? { isCompaction: true } : {}),
          ...(shouldTagIdleCompaction ? { isIdleCompaction: true } : {}),
        })
      );
    } catch (error) {
      log.error("Failed to update workspace streaming status", { workspaceId, error });
    } finally {
      // Compaction markers are turn-scoped. Always clear matching streaming=false
      // transitions, even when metadata writes fail, so stale state cannot leak into
      // future user streams. Match by generation so an old stop cannot clear a newer
      // compaction that started while the stop snapshot was doing async work.
      if (!streaming) {