merge master

Author: SDSLeon

.github/workflows/ci.yml

@@ -77,12 +77,17 @@ jobs:
       - name: Format check
         run: pnpm run fmt:check
 
-  test:
-    name: Test
+  test_shard:
+    name: Test shard (${{ matrix.shard }}/4)
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [1, 2, 3, 4]
     # Unit tests run via vitest in node/jsdom and never launch the Electron
-    # runtime, so skip the flaky Chromium binary download. Native node modules
-    # (better-sqlite3, node-pty) are still built by the install scripts below.
+    # runtime, so skip the flaky Chromium binary download and the root
+    # postinstall, which rebuilds better-sqlite3 for Electron. The database
+    # tests need Node-ABI better-sqlite3 and node-pty bindings rebuilt below.
     # ELECTRON_OVERRIDE_DIST_PATH lets `require("electron")` resolve to a path
     # string without the binary present, so suites that import the module (but
     # never spawn it) load instead of throwing from electron/index.js.
@@ -103,19 +108,19 @@ jobs:
           cache: pnpm
 
       - name: Install dependencies
-        run: |
-          for attempt in 1 2 3; do
-            if pnpm install --frozen-lockfile; then
-              exit 0
-            fi
-            echo "::warning::pnpm install failed on attempt $attempt; retrying in 15s"
-            sleep 15
-          done
-          echo "::error::pnpm install failed after 3 attempts"
-          exit 1
-
-      - name: Ensure native dependencies
-        run: node scripts/ensure-native-deps.mjs
-
-      - name: Test
-        run: pnpm run test
+        run: pnpm install --frozen-lockfile --ignore-scripts
+
+      - name: Build test native dependencies
+        run: pnpm rebuild better-sqlite3 node-pty
+
+      - name: Test shard
+        run: pnpm run test --shard=${{ matrix.shard }}/4
+
+  test:
+    name: Test
+    if: ${{ always() }}
+    needs: test_shard
+    runs-on: ubuntu-latest
+    steps:
+      - name: Verify test shards
+        run: test "${{ needs.test_shard.result }}" = "success"

packages/agents-usage/src/collectors/cursor.test.ts

@@ -74,11 +74,10 @@ describe("parseCursorUsage", () => {
     expect(api.resetsAt).toBe(1_719_600_000_000);
   });
 
-  it("treats breakdown.total as real spend and derives the allowance from the percent", () => {
-    // Live payload shape: used/limit/remaining clamp at the included $20 while
-    // breakdown.total carries the real spend ($20 included + $8.75 bonus
-    // consumed = $28.75). The authoritative 55.07% then implies a ~$52.21
-    // allowance (28.75 / 0.5507), keeping the dollars consistent with the bar.
+  it("treats breakdown.total as real spend against the vendor plan limit", () => {
+    // Live payload: used/limit clamp at included $20 while breakdown.total is
+    // real spend ($20 included + $8.75 bonus = $28.75). API % is a separate
+    // meter — do not invent limit = spend / percent ($28.75 / 55% ≈ $52).
     const body = {
       membershipType: "pro",
       individualUsage: {
@@ -96,12 +95,11 @@ describe("parseCursorUsage", () => {
     const api = snap.windows.find((w) => w.id === "cursor-api")!;
     expect(api.usedPercent).toBeCloseTo(55.07);
     expect(api.used).toBeCloseTo(28.75);
-    expect(api.limit).toBeCloseTo(52.21, 1);
+    expect(api.limit).toBeCloseTo(20);
   });
 
-  it("derives the allowance when the clamped dollars disagree with the percent (no breakdown)", () => {
-    // Older payloads without a breakdown: used/limit cap at the plan price
-    // ($20/$20) while the percent says 44% consumed → allowance ≈ $45.45.
+  it("keeps plan dollars when they disagree with API percent (no breakdown)", () => {
+    // Clamped plan price $20/$20; API bar can still be 44% of a different pool.
     const body = {
       membershipType: "pro",
       individualUsage: {
@@ -112,7 +110,29 @@ describe("parseCursorUsage", () => {
     const api = snap.windows.find((w) => w.id === "cursor-api")!;
     expect(api.usedPercent).toBe(44);
     expect(api.used).toBeCloseTo(20);
-    expect(api.limit).toBeCloseTo(45.45, 1);
+    expect(api.limit).toBeCloseTo(20);
+  });
+
+  it("shows overspend past the plan limit without inventing a percent-derived ceiling", () => {
+    // User case: ~$35.61 total cost, $20 Pro included, API bar ~4.5%.
+    // Old math: $35.61 / 0.04555 ≈ $782 nonsense allowance.
+    const body = {
+      membershipType: "pro",
+      individualUsage: {
+        plan: {
+          used: 2000,
+          limit: 2000,
+          breakdown: { included: 2000, bonus: 1561, total: 3561 },
+          autoPercentUsed: 22.37,
+          apiPercentUsed: 4.555,
+        },
+      },
+    };
+    const snap = parseCursorUsage(body, {}, NOW);
+    const api = snap.windows.find((w) => w.id === "cursor-api")!;
+    expect(api.usedPercent).toBeCloseTo(4.555);
+    expect(api.used).toBeCloseTo(35.61);
+    expect(api.limit).toBeCloseTo(20);
   });
 
   it("keeps the vendor limit when the dollars already agree with the percent", () => {

packages/agents-usage/src/collectors/cursor.ts

@@ -12,9 +12,8 @@ import type { UsageSnapshot, UsageWindow } from "../types";
  * Schema (per codexbar) of GET /api/usage-summary → individualUsage.plan:
  *   { used (cents), limit (cents), breakdown { included, bonus, total },
  *     totalPercentUsed, autoPercentUsed, apiPercentUsed } + billingCycleEnd +
- *   membershipType. Surfaced as Auto and API breakdown windows. The dollar
- *   allowance belongs to API usage; see `apiDollars` for how the clamped
- *   dollar fields are reconciled with the authoritative percents.
+ *   membershipType. Surfaced as Auto and API windows. API dollars use real
+ *   spend over the vendor plan limit; the bar uses apiPercentUsed separately.
  */
 
 export const CURSOR_USAGE_ENDPOINT = "https://cursor.com/api/usage-summary";
@@ -63,21 +62,22 @@ function clampPercent(value: number | undefined): number | undefined {
 }
 
 /**
- * Cursor's plan dollar fields need reconciliation (verified against the live
- * payload and CodexBar's Cursor probe, which scrapes the same endpoint):
+ * Cursor plan dollars vs API percent are different meters:
  *
- * - `used`/`limit`/`remaining` clamp at the nominal plan price (e.g. $20/$20
- *   while the percent says 55%), so they understate real spend.
- * - `breakdown.total` is the total credits *consumed* (included + bonus spend),
- *   not the allowance — treating it as the limit was CodexBar regression #240.
- *   Prefer it as the real spend when it exceeds the clamped `used`.
- * - `apiPercentUsed` is the authoritative consumed fraction (it's what
- *   Cursor's own dashboard messages report). When the dollar pair disagrees
- *   with it, keep the spend and derive the allowance as `spend / percent` so
- *   the dollar text always matches the bar (e.g. $28.75 / $52.21 at 55%,
- *   instead of a clamped, full-looking $20 / $20).
+ * - `used`/`limit` clamp at the nominal plan price (e.g. $20/$20) and can
+ *   understate real spend once bonus credit is consumed.
+ * - `breakdown.total` is credits *consumed* (included + bonus spend), not the
+ *   allowance — treating it as the limit was CodexBar regression #240.
+ * - `apiPercentUsed` drives the bar / "% by reset" pace; it is not a fraction
+ *   of the plan dollar cap. Deriving `limit = spend / apiPercent` invents a
+ *   nonsense ceiling (e.g. $35.61 / $775 at 4.5%) that is neither spend nor
+ *   the Pro included allowance.
+ *
+ * Surface honest money: real spend over the vendor plan limit. The bar may
+ * then disagree with the dollar ratio — that is correct; they measure different
+ * things.
  */
-function apiDollars(plan: CursorPlanUsage, percent: number): { used?: number; limit?: number } {
+function apiDollars(plan: CursorPlanUsage): { used?: number; limit?: number } {
   const reportedUsed = centsToUsd(plan.used);
   const reportedLimit = centsToUsd(plan.limit);
   const breakdownTotal = centsToUsd(plan.breakdown?.total);
@@ -89,15 +89,6 @@ function apiDollars(plan: CursorPlanUsage, percent: number): { used?: number; li
   if (spend === undefined) {
     return reportedLimit !== undefined && reportedLimit > 0 ? { limit: reportedLimit } : {};
   }
-  if (spend > 0 && percent > 0) {
-    const impliedPercent =
-      reportedLimit !== undefined && reportedLimit > 0 ? (spend / reportedLimit) * 100 : undefined;
-    // 1-point tolerance so ordinary rounding drift in the reported percent
-    // doesn't override a limit the spend already agrees with.
-    if (impliedPercent === undefined || Math.abs(impliedPercent - percent) > 1) {
-      return { used: spend, limit: spend / (percent / 100) };
-    }
-  }
   return {
     used: spend,
     ...(reportedLimit !== undefined && reportedLimit > 0 ? { limit: reportedLimit } : {}),
@@ -146,7 +137,7 @@ export function parseCursorUsage(
       usedPercent: apiPercent,
       unit: "percent",
       currency: "USD",
-      ...apiDollars(plan, apiPercent),
+      ...apiDollars(plan),
       ...withReset,
     });
   }

src/renderer/components/thread/ChatPane/ChatPane.test.tsx

@@ -985,6 +985,21 @@ describe("ChatPane", () => {
     ).not.toBeInTheDocument();
   });
 
+  it("renders selected skills in user messages as skill badges", async () => {
+    const thread = makeThread();
+    seedUserMessageContent(thread.id, [
+      { kind: "skill", name: "simplify", invocation: "$simplify" },
+    ]);
+
+    const { container } = renderChatPane(thread);
+    await waitFor(() => expect(hydrateThreadRuntimeItems).toHaveBeenCalledWith(thread.id));
+
+    const badge = container.querySelector('[data-skill-name="simplify"]');
+    expect(badge).toHaveTextContent("simplify");
+    expect(badge?.querySelector("svg")).toBeInTheDocument();
+    expect(screen.queryByText("$simplify")).not.toBeInTheDocument();
+  });
+
   it("copies user message text from the inline action", async () => {
     const thread = makeThread();
     seedUserMessage(thread.id, "Copy this prompt");

src/renderer/components/thread/ChatPane/parts/items/Reasoning.test.tsx

@@ -55,8 +55,22 @@ describe("Reasoning", () => {
     MockResizeObserver.reset();
   });
 
+  it("shows the last streamed line as the collapsed Thinking preview", () => {
+    const { container } = renderReasoning(
+      makeReasoningItem("Inspecting logs\nChecking the tail output now"),
+    );
+
+    const toggle = container.querySelector("button");
+    if (!toggle) throw new Error("missing Thinking toggle");
+    expect(toggle.textContent).toContain("Thinking");
+    expect(toggle.textContent).toContain("Checking the tail output now");
+    // Collapsed: no live viewport mounted until the row is expanded.
+    expect(container.querySelector(".overflow-y-auto")).toBeNull();
+  });
+
   it("keeps live reasoning pinned to the bottom while new content streams in", async () => {
     const { container, rerender } = renderReasoning(makeReasoningItem("Inspecting logs"));
+    expandReasoning(container);
     const viewport = getReasoningViewport(container);
     const content = getReasoningContent(viewport);
     const metrics = installScrollMetrics(viewport, {
@@ -102,6 +116,7 @@ describe("Reasoning", () => {
 
   it("stops auto-scrolling once the user scrolls up inside the live reasoning block", async () => {
     const { container, rerender } = renderReasoning(makeReasoningItem("Inspecting logs"));
+    expandReasoning(container);
     const viewport = getReasoningViewport(container);
     const content = getReasoningContent(viewport);
     const metrics = installScrollMetrics(viewport, {
@@ -158,6 +173,12 @@ function makeReasoningItem(text: string): RuntimeChatItem {
   };
 }
 
+function expandReasoning(container: HTMLElement) {
+  const toggle = container.querySelector("button");
+  if (!toggle) throw new Error("missing reasoning toggle");
+  fireEvent.click(toggle);
+}
+
 function getReasoningViewport(container: HTMLElement): HTMLDivElement {
   const element = container.querySelector(".overflow-y-auto");
   if (!(element instanceof HTMLDivElement)) {

src/renderer/components/thread/ChatPane/parts/items/Reasoning.tsx

@@ -1,12 +1,10 @@
 import { memo, useState } from "react";
-import { Surface } from "@heroui/react";
 import { Trans, useLingui } from "@lingui/react/macro";
 import { Brain, ChevronDown } from "lucide-react";
 import type { RuntimeChatItem } from "@/renderer/state/slices/runtimeEventSlice";
 import { useChatPaneActions } from "../../chatPaneActionsContext";
 import { useBrainThinking, useShimmer } from "@/renderer/thinkingAnimator";
-import { chatMessageSurfaceClass } from "./chatMessageSurface";
-import { getReasoningPreview } from "./reasoningPreview";
+import { getReasoningLastLine, getReasoningPreview } from "./reasoningPreview";
 import { ReasoningExpandedBody, ReasoningStreamViewport } from "./ReasoningStreamViewport";
 
 interface ReasoningProps {
@@ -24,55 +22,55 @@ export const Reasoning = memo(function Reasoning({ item }: ReasoningProps) {
   const thinkingTextRef = useShimmer<HTMLSpanElement>(isStreaming);
   const brainRef = useBrainThinking(isStreaming);
 
-  if (!isStreaming) {
-    const preview = isOpen ? "" : getReasoningPreview(rawText);
-    // Compact toggle — visually distinct from tool-call accordions: no border
-    // tile, dotted left rule when expanded, italic body. Equal vertical
-    // padding so it doesn't visually bias toward the message above or below.
-    return (
-      <div className="flex w-full flex-col items-stretch justify-center py-2 pl-6 pr-3 text-[length:var(--lc-chat-font-size-meta)] text-foreground-muted">
-        <button
-          type="button"
-          onClick={() => {
-            setIsOpen((v) => !v);
-            actions?.onContentHeightChange();
-          }}
-          aria-expanded={isOpen}
-          className="group inline-flex min-w-0 max-w-full items-center gap-1.5 self-start leading-none italic opacity-80 hover:text-foreground hover:opacity-100"
-        >
-          <Brain className="size-3 shrink-0" />
-          <span className="shrink-0">
-            <Trans>Thought</Trans>
-          </span>
-          {preview ? <span className="min-w-0 truncate opacity-70">{preview}</span> : null}
-          <ChevronDown
-            className={`size-3 shrink-0 opacity-100 transition-[transform,opacity] [@media(hover:hover)]:opacity-0 [@media(hover:hover)]:group-hover:opacity-100 [@media(hover:hover)]:group-focus-visible:opacity-100 ${isOpen ? "rotate-180" : ""}`}
-          />
-        </button>
-        {isOpen ? <ReasoningExpandedBody text={rawText} className="mt-2" /> : null}
-      </div>
-    );
-  }
+  // Collapsed row is identical while thinking and after: only the label, the
+  // brain/shimmer animation, and the preview source differ. While streaming the
+  // trailing meta tracks the model's current line (streamed in line by line);
+  // on completion it settles into the flattened whole-block preview.
+  const preview = isOpen
+    ? ""
+    : isStreaming
+      ? getReasoningLastLine(rawText)
+      : getReasoningPreview(rawText);
 
+  // Compact toggle — visually distinct from tool-call accordions: no border
+  // tile, dotted left rule when expanded, italic body. Equal vertical padding so
+  // it doesn't visually bias toward the message above or below. Expanding while
+  // streaming reveals the live pinned viewport; after completion, the static body.
   return (
-    <Surface variant="transparent" className={`${chatMessageSurfaceClass} pl-6`}>
-      <div className="flex min-w-0 flex-col gap-1.5 text-[length:var(--lc-chat-font-size-meta)] text-foreground-muted">
-        <div className="inline-flex items-center gap-1.5">
-          <Brain
-            ref={brainRef}
-            className="poracode-brain-thinking size-3 shrink-0"
-            aria-label={t`Thinking`}
-          />
-          <span
-            ref={thinkingTextRef}
-            className="poracode-thinking-text"
-            data-poracode-shimmer-text={t`Thinking`}
-          >
-            <Trans>Thinking</Trans>
-          </span>
-        </div>
-        {hasText ? <ReasoningStreamViewport text={rawText} className="pl-4" /> : null}
-      </div>
-    </Surface>
+    <div className="flex w-full flex-col items-stretch justify-center py-2 pl-6 pr-3 text-[length:var(--lc-chat-font-size-meta)] text-foreground-muted">
+      <button
+        type="button"
+        onClick={() => {
+          setIsOpen((v) => !v);
+          actions?.onContentHeightChange();
+        }}
+        aria-expanded={isOpen}
+        className="group inline-flex min-w-0 max-w-full items-center gap-1.5 self-start leading-none italic opacity-80 hover:text-foreground hover:opacity-100"
+      >
+        <Brain
+          ref={brainRef}
+          className={`size-3 shrink-0 ${isStreaming ? "poracode-brain-thinking" : ""}`}
+          {...(isStreaming ? { "aria-label": t`Thinking` } : {})}
+        />
+        <span
+          ref={thinkingTextRef}
+          className={`shrink-0 ${isStreaming ? "poracode-thinking-text" : ""}`}
+          {...(isStreaming ? { "data-poracode-shimmer-text": t`Thinking` } : {})}
+        >
+          {isStreaming ? <Trans>Thinking</Trans> : <Trans>Thought</Trans>}
+        </span>
+        {preview ? <span className="min-w-0 truncate opacity-70">{preview}</span> : null}
+        <ChevronDown
+          className={`size-3 shrink-0 opacity-100 transition-[transform,opacity] [@media(hover:hover)]:opacity-0 [@media(hover:hover)]:group-hover:opacity-100 [@media(hover:hover)]:group-focus-visible:opacity-100 ${isOpen ? "rotate-180" : ""}`}
+        />
+      </button>
+      {isOpen && hasText ? (
+        isStreaming ? (
+          <ReasoningStreamViewport text={rawText} className="mt-2" />
+        ) : (
+          <ReasoningExpandedBody text={rawText} className="mt-2" />
+        )
+      ) : null}
+    </div>
   );
 });