Method dispatch

src/node/services/agentStatusService.ts:166–223

(tickStartedAt: number)

  }

  private async dispatch(tickStartedAt: number): Promise<void> {
    const focused = this.windowService.isFocused();
    // One disk read per tick for streaming state across all workspaces.
    // Cheap, and avoids N reads inside the inner loop.
    const snapshots = await this.extensionMetadata.getAllSnapshots();

    // Sort eligible workspaces by lastRanAt ascending. With MAX_CONCURRENT=1,
    // a fixed iteration order would let the first workspace starve the rest;
    // least-recently-run gives fair round-robin without an explicit queue.
    const eligible: Array<{
      id: string;
      lastRanAt: number;
      recency: number | null;
      recencyAdvanced: boolean;
    }> = [];
    for (const [, projectConfig] of this.config.loadConfigOrDefault().projects) {
      for (const ws of projectConfig.workspaces) {
        const id = ws.id ?? ws.name;
        if (typeof id !== "string" || id.length === 0) continue;
        if (isWorkspaceArchived(ws.archivedAt, ws.unarchivedAt)) continue;
        const state = this.tracked.get(id);
        if (state?.inFlight) continue;
        const snapshot = snapshots.get(id);
        const recency = typeof snapshot?.recency === "number" ? snapshot.recency : null;
        const recencyAdvanced = hasRecencyAdvanced(state, recency);
        const interval = pickInterval(snapshot?.streaming === true, focused);
        if (state && !recencyAdvanced && tickStartedAt - state.lastRanAt < interval) continue;
        eligible.push({ id, lastRanAt: state?.lastRanAt ?? 0, recency, recencyAdvanced });
      }
    }
    eligible.sort((a, b) => {
      if (a.recencyAdvanced !== b.recencyAdvanced) {
        // A user message is usually a task pivot. Put those workspaces ahead
        // of ordinary cadence refreshes so stale pre-pivot statuses don't
        // linger behind background idle work.
        return a.recencyAdvanced ? -1 : 1;
      }
      return a.lastRanAt - b.lastRanAt;
    });

    for (const { id, recency } of eligible) {
      if (this.stopped || this.inFlightPromises.size >= AGENT_STATUS_MAX_CONCURRENT) return;
      const state = this.ensureState(id);
      state.inFlight = true;
      // Set lastRanAt at dispatch time (not after the async transcript
      // build) so cadence is anchored to tick boundaries — see runTick.
      state.lastRanAt = tickStartedAt;
      // Forward the live streaming bit so the prompt can lock in
      // present-progressive tense when the assistant is mid-response.
      // Snapshots were already read once per tick above.
      const streaming = snapshots.get(id)?.streaming === true;
      const promise = this.runForWorkspace(id, recency, streaming).finally(() => {
        state.inFlight = false;
        this.inFlightPromises.delete(promise);
      });
      this.inFlightPromises.add(promise);
    }
  }