gloomberb 0.12.0 → 0.13.2

package/src/components/chart/composite/scene.ts

@@ -16,9 +16,11 @@ import type {
 } from "./types";
 import {
   buildCompositeTimeScale,
+  COMPOSITE_RIGHT_OFFSET_RATIO,
   projectCompositeTimestamp,
+  unprojectCompositeTimestamp,
 } from "./time-scale";
-import type { CompositeTimeScale } from "./types";
+import type { CompositeLastPriceMarker, CompositeTimeScale } from "./types";
 
 const DAY_MS = 24 * 60 * 60 * 1000;
 
@@ -331,7 +333,8 @@ function projectSeries(
   series: ResolvedSeries,
   domain: CompositeAxisDomain,
   startTime: number,
-  endTime: number,
+  /** Where a step series holds its last level to, never past the newest bar. */
+  stepEndTime: number,
   timeScale: CompositeTimeScale,
 ): CompositeProjectedPoint[] {
   const projected: CompositeProjectedPoint[] = [];
@@ -372,16 +375,74 @@ function projectSeries(
   if (stepSeries && projected.length > 0) {
     const last = projected.at(-1)!;
     const trailingGap = normalizedSourcePoints(series, timeScale).some(({ timestamp, value }) => (
-      timestamp > last.timestamp && timestamp <= endTime
+      timestamp > last.timestamp && timestamp <= stepEndTime
       && (value === null || projectCompositeValue(value, domain) === null)
     ));
-    if (last.timestamp < endTime && !trailingGap) {
-      projected.push({ ...last, timestamp: endTime, xRatio: 1, breakBefore: false });
+    // The synthetic tail is a level, not an observation, so it lands on its own
+    // timestamp rather than snapping forward to the next trading slot.
+    const trailingRatio = projectCompositeTimestamp(timeScale, stepEndTime)?.ratio;
+    if (last.timestamp < stepEndTime && !trailingGap && trailingRatio !== undefined) {
+      projected.push({
+        ...last,
+        timestamp: stepEndTime,
+        xRatio: Math.min(trailingRatio, 1),
+        xSlot: undefined,
+        breakBefore: false,
+      });
     }
   }
   return projected;
 }
 
+/**
+ * Unit groups a price can wear, raw or transformed. Volume, oscillators and
+ * other derived study outputs are deliberately absent: a level line there
+ * would mark a quantity that has no last price to read.
+ */
+const PRICE_UNIT_GROUPS = /^(?:price|currency|percent|index|log)(?::|$)/;
+
+/**
+ * The chart's primary price series: the first exchange-traded price, in
+ * authored order. Study outputs are appended after the series they derive
+ * from, so an overlay indicator never wins over the price it follows.
+ */
+function primaryPriceSeries(series: readonly ResolvedSeries[]): ResolvedSeries | null {
+  return series.find((entry) => (
+    entry.timeBasis?.kind === "market"
+    && PRICE_UNIT_GROUPS.test(entry.unitGroup.toLowerCase())
+  )) ?? null;
+}
+
+function lastCloseOf(points: readonly CompositeProjectedPoint[]): number | null {
+  const last = points.at(-1);
+  if (!last) return null;
+  return finiteNumber(last.point.close) ? last.point.close : last.value;
+}
+
+/** Marks the newest close of the primary price series on the panel that draws it. */
+function attachLastPriceMarker(
+  panels: CompositePanelScene[],
+  series: readonly ResolvedSeries[],
+): void {
+  const primary = primaryPriceSeries(series);
+  if (!primary) return;
+  const panel = panels.find((entry) => entry.id === primary.panelId);
+  const projected = panel?.series.find((entry) => entry.source.id === primary.id);
+  const domain = panel?.axes[primary.axis];
+  if (!panel || !projected || !domain) return;
+  const value = lastCloseOf(projected.points);
+  if (value === null) return;
+  const yRatio = projectCompositeValue(value, domain);
+  if (yRatio === null) return;
+  panel.lastPrice = {
+    seriesId: primary.id,
+    color: primary.color,
+    axis: primary.axis,
+    value,
+    yRatio,
+  };
+}
+
 function nearestDate(dates: Date[], requested: Date): Date | null {
   const target = requested.getTime();
   if (!Number.isFinite(target) || dates.length === 0) return null;
@@ -483,7 +544,16 @@ export function buildCompositeChartScene(
     timelineSeries,
     startTime,
     endTime,
+    options.rightOffsetRatio ?? COMPOSITE_RIGHT_OFFSET_RATIO,
   );
+  // The plot reaches past the viewport by the reserved right offset. Panned
+  // back into history that space holds real observations, so navigation and
+  // the cursor follow the drawn edge rather than the viewport end.
+  const plotEndTime = Math.max(endTime, unprojectCompositeTimestamp(timeScale, 1));
+  // A step holds its level to the newest observation and no further: the space
+  // reserved after it stays empty. With data still ahead of the window, the
+  // level runs to the drawn edge instead.
+  const stepTrailingTime = Math.min(plotEndTime, Math.max(lastTime, endTime));
   const scopedSeries = viewport
     ? dataSeries.flatMap((entry) => scopeSeriesToViewport(entry, startTime, endTime, timeScale) ?? [])
     : dataSeries;
@@ -493,11 +563,11 @@ export function buildCompositeChartScene(
   const usableSeries = emptyRange
     ? dataSeries.map((entry) => ({ ...entry, points: [] }))
     : scopedSeries;
-  const visibleTimes = uniqueTimes.filter((time) => time >= startTime && time <= endTime);
+  const visibleTimes = uniqueTimes.filter((time) => time >= startTime && time <= plotEndTime);
   const marketTimes = timeScale.kind === "market"
     ? timeScale.anchors
       .map(({ timestamp }) => timestamp)
-      .filter((time) => time >= startTime && time <= endTime)
+      .filter((time) => time >= startTime && time <= plotEndTime)
     : [];
   const cursorTimes = timeScale.kind === "market" ? marketTimes : visibleTimes;
   const dates = (cursorTimes.length > 0
@@ -514,22 +584,24 @@ export function buildCompositeChartScene(
   const cursorXRatio = cursorDate
     ? projectCompositeTimestamp(timeScale, cursorDate.getTime())?.ratio ?? null
     : null;
-  const orderedPanels = panelSpecsForSeries(usableSeries, panels);
+  // Panels belong to the authored series, not to whichever of them happen to
+  // hold observations right now. A panel that disappears while its data loads
+  // reflows every other panel, and the chart jumps again when it comes back.
+  const orderedPanels = panelSpecsForSeries(series, panels);
   const panelHeights = allocateCompositePanelHeights(orderedPanels, options.height);
 
-  const panelScenes: CompositePanelScene[] = orderedPanels.flatMap((panel) => {
+  const panelScenes: CompositePanelScene[] = orderedPanels.map((panel) => {
     const panelSeries = usableSeries.filter((entry) => entry.panelId === panel.id);
-    if (panelSeries.length === 0) return [];
     const scale = panel.scale ?? "linear";
-    // An empty range has no in-view values, so scale its axes to the loaded
-    // history rather than the meaningless 0..1 fallback.
-    const domainSeries = emptyRange
+    // With no in-view values, scale the axes to the loaded history rather than
+    // the meaningless 0..1 fallback, so the panel keeps its gutter and grid.
+    const domainSeries = emptyRange || panelSeries.length === 0
       ? dataSeries.filter((entry) => entry.panelId === panel.id)
       : panelSeries;
     const left = buildAxisDomain("left", domainSeries, scale);
     const right = buildAxisDomain("right", domainSeries, scale);
     const axes: Partial<Record<CompositeAxisSide, CompositeAxisDomain>> = { left, right };
-    return [{
+    return {
       id: panel.id,
       label: panel.label,
       height: panelHeights.get(panel.id) ?? 1,
@@ -538,11 +610,15 @@ export function buildCompositeChartScene(
       series: panelSeries.flatMap((entry) => {
         const domain = axes[entry.axis];
         return domain
-          ? [{ source: entry, points: projectSeries(entry, domain, startTime, endTime, timeScale) }]
+          ? [{
+            source: entry,
+            points: projectSeries(entry, domain, startTime, stepTrailingTime, timeScale),
+          }]
           : [];
       }),
-    }];
+    };
   });
+  attachLastPriceMarker(panelScenes, usableSeries);
 
   return {
     width: Math.max(1, Math.floor(options.width)),

package/src/components/chart/composite/text-renderer.ts

@@ -251,6 +251,19 @@ export function renderCompositePanelText(
     }
   }
 
+  // Blank cells only, so the dashed level reads as if it ran under the marks.
+  if (panel.lastPrice) {
+    const row = clamp(
+      Math.round(panel.lastPrice.yRatio * Math.max(height - 1, 0)),
+      0,
+      Math.max(height - 1, 0),
+    );
+    for (let x = 0; x < plotWidth; x += 1) {
+      const current = rows[row]?.[x];
+      if (current === " " || current === "·") setCell(rows, x, row, "╌");
+    }
+  }
+
   if (cursorXRatio !== null) {
     const cursorX = clamp(Math.round(cursorXRatio * Math.max(plotWidth - 1, 0)), 0, Math.max(plotWidth - 1, 0));
     for (let y = 0; y < height; y += 1) {

package/src/components/chart/composite/time-scale.ts

@@ -3,6 +3,14 @@ import type { CompositeTimeScale } from "./types";
 
 const DAY_MS = 24 * 60 * 60 * 1_000;
 const QUARTER_HOUR_MS = 15 * 60 * 1_000;
+/**
+ * Empty space kept after the newest observation, as a fraction of the visible
+ * span, so the last bar is drawn whole with air after it instead of hugging the
+ * value axis. Six percent is three to five bar slots on the windows these
+ * charts show, and because it scales with the plot it reads the same in a
+ * narrow terminal pane and at desktop pixel widths.
+ */
+export const COMPOSITE_RIGHT_OFFSET_RATIO = 0.06;
 const MINIMUM_SLOT_FRACTION = 0.25;
 const dateFormatters = new Map<string, Intl.DateTimeFormat>();
 // Session dates are looked up once per quarter hour, not once per bar: a day
@@ -202,11 +210,13 @@ export function buildCompositeTimeScale(
   timelineSeries: readonly ResolvedSeries[],
   startTime: number,
   endTime: number,
+  rightOffsetRatio = 0,
 ): CompositeTimeScale {
+  const offset = Number.isFinite(rightOffsetRatio) && rightOffsetRatio > 0 ? rightOffsetRatio : 0;
   const anchorSeries = timelineSeries.find((series) => series.timeBasis?.kind === "market");
   const resolved = anchorSeries ? resolveMarketAnchors(anchorSeries) : null;
   if (!anchorSeries || !resolved || resolved.anchors.length === 0) {
-    return { kind: "calendar", startTime, endTime };
+    return { kind: "calendar", startTime, endTime, rightOffsetRatio: offset };
   }
   const { cadenceMs, anchors } = resolved;
   const startPosition = positionForTimestamp({ anchors, cadenceMs }, startTime);
@@ -220,9 +230,24 @@ export function buildCompositeTimeScale(
     anchors,
     startPosition,
     endPosition: endPosition > startPosition ? endPosition : startPosition + 1,
+    rightOffsetRatio: offset,
   };
 }
 
+/** Fraction of the visible span held empty after the newest observation. */
+export function compositeRightOffsetRatio(scale: CompositeTimeScale): number {
+  const ratio = scale.rightOffsetRatio ?? 0;
+  return Number.isFinite(ratio) && ratio > 0 ? ratio : 0;
+}
+
+/** Span the plot's full width covers, viewport plus reserved right offset. */
+function projectionSpan(scale: CompositeTimeScale): number {
+  const viewportSpan = scale.kind === "calendar"
+    ? Math.max(scale.endTime - scale.startTime, 1)
+    : Math.max(scale.endPosition - scale.startPosition, Number.EPSILON);
+  return viewportSpan * (1 + compositeRightOffsetRatio(scale));
+}
+
 /** Slot position of a timestamp on a market scale, or wall-clock time on a calendar scale. */
 export function compositeTimePosition(scale: CompositeTimeScale, timestamp: number): number {
   return scale.kind === "calendar" ? timestamp : positionForTimestamp(scale, timestamp);
@@ -261,8 +286,7 @@ export function projectCompositeTimestamp(
 ): { ratio: number; xSlot?: number } | null {
   if (!Number.isFinite(timestamp)) return null;
   if (scale.kind === "calendar") {
-    const span = Math.max(scale.endTime - scale.startTime, 1);
-    return { ratio: (timestamp - scale.startTime) / span };
+    return { ratio: (timestamp - scale.startTime) / projectionSpan(scale) };
   }
 
   let position: number;
@@ -279,8 +303,7 @@ export function projectCompositeTimestamp(
     position = positionForTimestamp(scale, timestamp);
     if (exact?.timestamp === timestamp) xSlot = index;
   }
-  const span = Math.max(scale.endPosition - scale.startPosition, Number.EPSILON);
-  return { ratio: (position - scale.startPosition) / span, xSlot };
+  return { ratio: (position - scale.startPosition) / projectionSpan(scale), xSlot };
 }
 
 export function unprojectCompositeTimestamp(
@@ -289,10 +312,7 @@ export function unprojectCompositeTimestamp(
 ): number {
   const safeRatio = Math.max(0, Math.min(1, ratio));
   if (scale.kind === "calendar") {
-    return scale.startTime + (scale.endTime - scale.startTime) * safeRatio;
+    return scale.startTime + projectionSpan(scale) * safeRatio;
   }
-  return compositeTimeAtPosition(
-    scale,
-    scale.startPosition + (scale.endPosition - scale.startPosition) * safeRatio,
-  );
+  return compositeTimeAtPosition(scale, scale.startPosition + projectionSpan(scale) * safeRatio);
 }

package/src/components/chart/composite/types.ts

@@ -43,6 +43,12 @@ export interface CompositeCalendarTimeScale {
   kind: "calendar";
   startTime: number;
   endTime: number;
+  /**
+   * Empty space reserved after `endTime`, as a fraction of the visible span.
+   * The 0..1 projection covers `startTime` to `endTime` plus that space, so
+   * the newest observation is drawn whole with air after it. Absent means none.
+   */
+  rightOffsetRatio?: number;
 }
 
 export interface CompositeMarketTimeScale {
@@ -56,7 +62,10 @@ export interface CompositeMarketTimeScale {
     position: number;
   }>;
   startPosition: number;
+  /** Slot of `endTime`; the reserved right offset extends past it. */
   endPosition: number;
+  /** Empty slots reserved after `endPosition`, as a fraction of the visible span. */
+  rightOffsetRatio?: number;
 }
 
 export type CompositeTimeScale = CompositeCalendarTimeScale | CompositeMarketTimeScale;
@@ -66,6 +75,15 @@ export interface CompositeProjectedSeries {
   points: CompositeProjectedPoint[];
 }
 
+/** Level line at the newest close of the chart's primary price series. */
+export interface CompositeLastPriceMarker {
+  seriesId: string;
+  color: string;
+  axis: CompositeAxisSide;
+  value: number;
+  yRatio: number;
+}
+
 export interface CompositePanelScene {
   id: string;
   label?: string;
@@ -73,6 +91,8 @@ export interface CompositePanelScene {
   scale: PanelScale;
   axes: Partial<Record<CompositeAxisSide, CompositeAxisDomain>>;
   series: CompositeProjectedSeries[];
+  /** Present only on the panel that holds the primary price series. */
+  lastPrice?: CompositeLastPriceMarker;
 }
 
 export interface CompositeCursorValue {
@@ -109,6 +129,12 @@ export interface BuildCompositeChartSceneOptions {
   };
   /** Authored series order retained even when the primary anchor is hidden. */
   timelineSeries?: ResolvedSeries[];
+  /**
+   * Empty space kept after the newest observation, as a fraction of the visible
+   * span. Defaults to `COMPOSITE_RIGHT_OFFSET_RATIO`; pass 0 for charts whose x
+   * is not time, where the last observation belongs at the right edge.
+   */
+  rightOffsetRatio?: number;
 }
 
 export interface CompositeChartXMarker {

package/src/components/command-bar/assist/runtime.ts

@@ -42,17 +42,21 @@ export function useCommandBarAssist({
   askAssist: () => void;
   resetAssist: () => boolean;
 } {
-  const [assistState, setAssistState] = useState<AssistRequestState>({ status: "idle" });
+  const [assistState, setRenderedAssistState] = useState<AssistRequestState>({ status: "idle" });
   const assistStateRef = useRef(assistState);
-  assistStateRef.current = assistState;
+  /**
+   * Event handlers can run again before React commits the state they just
+   * queued. Keep their read model current synchronously so repeated Enter
+   * claims one request instead of aborting it and starting another.
+   */
+  const updateAssistState = useCallback((next: AssistRequestState) => {
+    assistStateRef.current = next;
+    setRenderedAssistState(next);
+  }, []);
   const abortRef = useRef<AbortController | null>(null);
   const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   const answersRef = useRef(new Map<string, AssistCommandCandidate[]>());
-  /**
-   * The query the runtime has already acted on, updated the moment a request
-   * starts. Rendered state lags a tick behind, and reading it instead would let
-   * a re-render slip a second debounce past an ask that is already in flight.
-   */
+  /** Query the runtime has already acted on, updated when a request starts. */
   const handledQueryRef = useRef<string | null>(null);
   /** Query the user dismissed with Esc; the section stays gone until it changes. */
   const dismissedQueryRef = useRef<string | null>(null);
@@ -65,12 +69,13 @@ export function useCommandBarAssist({
   getInventoryRef.current = getInventory;
 
   const cancelPending = useCallback(() => {
-    if (debounceRef.current) {
-      clearTimeout(debounceRef.current);
-      debounceRef.current = null;
-    }
-    abortRef.current?.abort();
+    const debounce = debounceRef.current;
+    debounceRef.current = null;
+    if (debounce !== null) clearTimeout(debounce);
+
+    const controller = abortRef.current;
     abortRef.current = null;
+    controller?.abort();
   }, []);
 
   const resetAssist = useCallback((): boolean => {
@@ -79,9 +84,9 @@ export function useCommandBarAssist({
     if (active.status === "idle" || active.source === "auto") return false;
     cancelPending();
     dismissedQueryRef.current = active.query;
-    setAssistState({ status: "idle" });
+    updateAssistState({ status: "idle" });
     return true;
-  }, [cancelPending]);
+  }, [cancelPending, updateAssistState]);
 
   const runAssist = useCallback((query: string, source: AssistRequestSource) => {
     const trimmed = query.trim();
@@ -96,35 +101,35 @@ export function useCommandBarAssist({
 
     const cached = answersRef.current.get(trimmed);
     if (cached) {
-      setAssistState({ status: "answered", query: trimmed, source: resolveSource(), candidates: cached });
+      updateAssistState({ status: "answered", query: trimmed, source: resolveSource(), candidates: cached });
       return;
     }
 
     const controller = new AbortController();
     abortRef.current = controller;
-    setAssistState({ status: "loading", query: trimmed, source: resolveSource() });
+    updateAssistState({ status: "loading", query: trimmed, source: resolveSource() });
 
     void (async () => {
       try {
         const response = await apiClient.assistCommand(trimmed, getInventoryRef.current(), {
           signal: controller.signal,
         });
-        if (controller.signal.aborted) return;
+        if (controller.signal.aborted || abortRef.current !== controller) return;
         const candidates = response?.candidates ?? [];
         answersRef.current.set(trimmed, candidates);
-        setAssistState({ status: "answered", query: trimmed, source: resolveSource(), candidates });
+        updateAssistState({ status: "answered", query: trimmed, source: resolveSource(), candidates });
       } catch (error) {
-        if (controller.signal.aborted) return;
+        if (controller.signal.aborted || abortRef.current !== controller) return;
         const kind = classifyAssistError(error);
         if (kind === "rate-limited") {
           rateLimitedUntilRef.current = Date.now() + ASSIST_RATE_LIMIT_BACKOFF_MS;
         }
-        setAssistState({ status: "error", query: trimmed, source: resolveSource(), kind });
+        updateAssistState({ status: "error", query: trimmed, source: resolveSource(), kind });
       } finally {
         if (abortRef.current === controller) abortRef.current = null;
       }
     })();
-  }, [cancelPending]);
+  }, [cancelPending, updateAssistState]);
 
   const askAssist = useCallback(() => {
     const trimmed = rootQueryRef.current.trim();
@@ -134,17 +139,17 @@ export function useCommandBarAssist({
     // The background ask already on the wire asks this exact question; asking
     // again would only abort it and start the wait over.
     if (active.status === "loading" && active.query === trimmed) {
-      setAssistState({ ...active, source: "explicit" });
+      updateAssistState({ ...active, source: "explicit" });
       return;
     }
     runAssist(trimmed, "explicit");
-  }, [runAssist]);
+  }, [runAssist, updateAssistState]);
 
   useEffect(() => {
     const trimmed = rootQuery.trim();
     const active = assistStateRef.current;
     if (active.status !== "idle" && active.query !== trimmed) {
-      setAssistState({ status: "idle" });
+      updateAssistState({ status: "idle" });
     }
     if (handledQueryRef.current !== null && handledQueryRef.current !== trimmed) {
       // Whatever is in flight describes text the user has already moved past.
@@ -158,21 +163,24 @@ export function useCommandBarAssist({
     const cached = answersRef.current.get(trimmed);
     if (cached) {
       handledQueryRef.current = trimmed;
-      setAssistState({ status: "answered", query: trimmed, source: "auto", candidates: cached });
+      updateAssistState({ status: "answered", query: trimmed, source: "auto", candidates: cached });
       return;
     }
     if (Date.now() < rateLimitedUntilRef.current) return;
 
-    debounceRef.current = setTimeout(() => {
+    const debounce = setTimeout(() => {
+      // A cleared timer can already be queued. Only the timer still owned by
+      // this effect may start a request.
+      if (debounceRef.current !== debounce) return;
       debounceRef.current = null;
       runAssist(trimmed, "auto");
     }, ASSIST_DEBOUNCE_MS);
+    debounceRef.current = debounce;
     return () => {
-      if (!debounceRef.current) return;
-      clearTimeout(debounceRef.current);
-      debounceRef.current = null;
+      clearTimeout(debounce);
+      if (debounceRef.current === debounce) debounceRef.current = null;
     };
-  }, [autoAsk, cancelPending, rootQuery, runAssist]);
+  }, [autoAsk, cancelPending, rootQuery, runAssist, updateAssistState]);
 
   useEffect(() => cancelPending, [cancelPending]);
 

package/src/components/command-bar/surface/assist.test.tsx

@@ -1,4 +1,5 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { act } from "react";
 import { apiClient, setCloudApiFetchTransport } from "../../../api-client";
 import { testRender } from "../../../renderers/opentui/test-utils";
 import type { PluginRegistry } from "../../../plugins/registry";
@@ -7,9 +8,22 @@ import {
   CommandBarHarness,
   createCommandBarTestControls,
   emitKeypress,
+  settleFrame,
 } from "./test-harness";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
+const originalWebSocket = globalThis.WebSocket;
+
+beforeEach(() => {
+  apiClient.dispose();
+  // The header subscribes to SPY. A real socket rejects this test's fake token
+  // and can mark the account unverified before the assist debounce completes.
+  globalThis.WebSocket = class {
+    static readonly OPEN = 1;
+    readyState = 0;
+    close() { this.readyState = 3; }
+  } as unknown as typeof WebSocket;
+});
 
 afterEach(() => {
   setCloudApiFetchTransport(null);
@@ -18,6 +32,8 @@ afterEach(() => {
     testSetup.renderer.destroy();
     testSetup = undefined;
   }
+  apiClient.dispose();
+  globalThis.WebSocket = originalWebSocket;
 });
 
 const { waitForFrameToContain } = createCommandBarTestControls(() => testSetup!);
@@ -84,8 +100,7 @@ const ASSIST_WAIT_ATTEMPTS = 40;
 async function waitForRequest(requests: string[]): Promise<void> {
   for (let attempt = 0; attempt < ASSIST_WAIT_ATTEMPTS; attempt++) {
     if (requests.length > 0) return;
-    await Bun.sleep(50);
-    await testSetup!.renderOnce();
+    await settleFrame(testSetup!);
   }
   throw new Error("Timed out waiting for the assist request.");
 }
@@ -94,8 +109,7 @@ async function waitForFrameWithout(text: string): Promise<string> {
   for (let attempt = 0; attempt < ASSIST_WAIT_ATTEMPTS; attempt++) {
     const frame = testSetup!.captureCharFrame();
     if (!frame.includes(text)) return frame;
-    await Bun.sleep(50);
-    await testSetup!.renderOnce();
+    await settleFrame(testSetup!);
   }
   throw new Error(`Timed out waiting for "${text}" to disappear.`);
 }
@@ -236,13 +250,54 @@ describe("CommandBar AI assist", () => {
 
     releaseResponse();
     for (let attempt = 0; attempt < ASSIST_WAIT_ATTEMPTS && created.length === 0; attempt++) {
-      await Bun.sleep(50);
-      await testSetup.renderOnce();
+      await settleFrame(testSetup);
     }
     expect(created).toEqual([{ templateId: "new-chat-pane", options: { arg: "#general" } }]);
     expect(requests).toHaveLength(1);
   });
 
+  test("does not restart an ask when Enter repeats before loading renders", async () => {
+    signInVerified();
+    let releaseResponse = () => {};
+    const held = new Promise<void>((resolve) => { releaseResponse = resolve; });
+    const requests = mockAssistTransport(async () => {
+      await held;
+      return jsonResponse({
+        candidates: [{ input: "CHAT #general", title: "Open the general channel", prefix: "CHAT", confidence: 0.9 }],
+      });
+    });
+
+    testSetup = await testRender(
+      <CommandBarHarness query="new chat pane" />,
+      { width: 120, height: 20 },
+    );
+
+    await testSetup.renderOnce();
+    expect(testSetup.captureCharFrame()).toContain("Thinking…");
+
+    await act(async () => {
+      for (let press = 0; press < 2; press += 1) {
+        testSetup!.renderer.keyInput.emit("keypress", {
+          ctrl: false,
+          meta: false,
+          option: false,
+          shift: false,
+          eventType: "press",
+          name: "return",
+          sequence: "\r",
+          repeated: press > 0,
+          stopPropagation: () => {},
+          preventDefault: () => {},
+        } as any);
+      }
+      await testSetup!.renderOnce();
+    });
+
+    expect(requests).toHaveLength(1);
+    releaseResponse();
+    await waitForFrameToContain("#general · Open the general channel", ASSIST_WAIT_ATTEMPTS);
+  });
+
   test("drops the section when a background ask fails", async () => {
     signInVerified();
     const requests = mockAssistTransport(() => jsonResponse({ error: "assist-unavailable" }, 503));
@@ -275,8 +330,7 @@ describe("CommandBar AI assist", () => {
     await testSetup.renderOnce();
     expect(testSetup.captureCharFrame()).toContain("Ask AI — sign up to enable");
 
-    await Bun.sleep(700);
-    await testSetup.renderOnce();
+    await settleFrame(testSetup, 700);
     expect(requests).toEqual([]);
 
     // The offer sits under the list and never takes the Enter that belongs to

package/src/components/command-bar/surface/test-harness.tsx

@@ -41,6 +41,24 @@ export async function emitKeypress(
   });
 }
 
+/**
+ * Advances one polling step: sleeps, then renders. Both happen inside `act` so
+ * that anything a resolving promise queued during the sleep is flushed before
+ * the next frame is captured. Polling outside `act` leaves the update to
+ * React's scheduler, which is why a loaded CI box could time out waiting for a
+ * frame the app had already produced.
+ */
+export async function settleFrame(
+  renderer: Awaited<ReturnType<typeof testRender>>,
+  delayMs = 50,
+): Promise<void> {
+  await act(async () => {
+    await Bun.sleep(delayMs);
+  });
+  // Paint after React has committed the updates collected by act.
+  await renderer.renderOnce();
+}
+
 export function createCommandBarTestControls(
   getRenderer: () => Awaited<ReturnType<typeof testRender>>,
 ) {
@@ -51,10 +69,9 @@ export function createCommandBarTestControls(
       if (frame.includes(text)) {
         return frame;
       }
-      await Bun.sleep(delayMs);
-      await renderer.renderOnce();
+      await settleFrame(renderer, delayMs);
     }
-    throw new Error(`Timed out waiting for frame to contain "${text}".`);
+    throw new Error(`Timed out waiting for frame to contain "${text}".\n${renderer.captureCharFrame()}`);
   };
 
   const clickFrameText = async (text: string): Promise<void> => {
@@ -76,7 +93,9 @@ export function createCommandBarTestControls(
   const renderFrames = async (count = 2): Promise<void> => {
     const renderer = getRenderer();
     for (let index = 0; index < count; index += 1) {
-      await renderer.renderOnce();
+      await act(async () => {
+        await renderer.renderOnce();
+      });
     }
   };