Method getWorkspaceShellStatus

src/browser/stores/WorkspaceStore.ts:2014–2073

(workspaceId: string)

  }

  getWorkspaceShellStatus(workspaceId: string): WorkspaceShellStatus {
    const aggregator = this.assertGet(workspaceId);
    const transient = this.assertChatTransientState(workspaceId);
    const hasMessages = aggregator.hasMessages();
    const isActiveWorkspace = this.activeOnChatWorkspaceId === workspaceId;

    // Keep this selector lighter than getWorkspaceState(): the shell only needs enough
    // state to decide placeholder vs mounted chat. Avoid rebuilding the full displayed
    // transcript on every streaming delta unless init/hydration placeholder behavior needs it.
    const hasRunningInitMessage =
      !hasMessages || (isActiveWorkspace && transient.isHydratingTranscript && !transient.caughtUp)
        ? aggregator
            .getDisplayedMessages()
            .some((message) => message.type === "workspace-init" && message.status === "running")
        : false;

    const activity = this.workspaceActivity.get(workspaceId);
    const hasInterruptibleActiveStream = aggregator.hasInterruptibleActiveStream();
    const pendingStreamStartTime = aggregator.getPendingStreamStartTime();
    const streamLifecycle = aggregator.getStreamLifecycle();
    const bufferedActiveStreamStart =
      isActiveWorkspace && !transient.caughtUp
        ? getBufferedActiveStreamStart(
            transient.pendingStreamEvents,
            transient.historicalMessages,
            (messageId) => aggregator.isSideQuestionAnswerMessage(messageId)
          )
        : null;
    const useAggregatorState = isActiveWorkspace && transient.caughtUp;
    const canInterrupt = useAggregatorState
      ? hasInterruptibleActiveStream
      : bufferedActiveStreamStart !== null
        ? true
        : (activity?.streaming ?? hasInterruptibleActiveStream);
    const activePendingStreamStartTime = isActiveWorkspace ? pendingStreamStartTime : null;
    // Match getWorkspaceState so the shell does not flash between lifecycle and stream-start.
    const isStreamStarting =
      isActiveWorkspace &&
      !canInterrupt &&
      (streamLifecycle?.phase === "preparing" || activePendingStreamStartTime !== null);
    const isHydratingTranscript =
      isActiveWorkspace &&
      transient.isHydratingTranscript &&
      !transient.caughtUp &&
      !hasRunningInitMessage;
    const loading = !hasMessages && !hasRunningInitMessage && !transient.caughtUp;

    const cached = this.workspaceShellStatusCache.get(workspaceId);
    if (
      cached?.loading === loading &&
      cached.isHydratingTranscript === isHydratingTranscript &&
      cached.isStreamStarting === isStreamStarting
    ) {
      return cached;
    }

    const next = { loading, isHydratingTranscript, isStreamStarting };
    this.workspaceShellStatusCache.set(workspaceId, next);