bermudis-pi-goodies 0.28.0 → 0.29.0

package/README.md

@@ -14,7 +14,7 @@ extensions. One entry point, thirteen independent features.
 | `clean-tui`         | tool overrides (no command)   | Collapse built-in tool output for a cleaner TUI: back-to-back same-tool calls share one block (e.g. `read ×2`) until a boundary — visible text (assistant prose or a typed user message) or a thinking block (even an empty one, as OpenAI emits between tool calls) — so reasoning-per-call models render one block per call. Images stay visible without expanding, expand a row with ctrl+o to see the full command and results/diffs. Long bash commands get an AI-generated summary once you pick a model with `/goodies summary-model <provider/model>` (see "Smart summaries" below) — expanding a row swaps the summary back out for the raw command. While enabled, also flips `@bermudi/pi-codex`'s `apply_patch`/`web_search` into the same burst style. Long thinking runs can show a live plain-English line above the editor (`/goodies thinking-summaries on`) instead of a static `Thinking...` — see "Smart summaries". |
 | `review`            | `/review`, `/end-review`      | Code review workflow: review uncommitted changes, a branch, a commit, a commit range (`A..B`/`A...B`), a GitHub PR, or folders. Prioritized findings with actionable follow-ups. Targets tab-complete. Works in the terminal and in RPC hosts like T3 Code (plain selectors replace the search-as-you-type ones outside the TUI).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | `kilo`              | provider                      | Access Kilo Gateway models via `/login kilo` or `KILO_API_KEY`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `provider-balance`  | footer (no command)           | Show remaining Kilo, OpenRouter, or CommandCode credits, z.ai token-plan quota, or OpenAI Codex quota on the right side of the working-directory footer line.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `provider-balance`  | footer (no command)           | Show remaining Kilo, OpenRouter, or CommandCode credits, z.ai token-plan quota, Anthropic Pro/Max subscription usage (including `claude-code`), or OpenAI Codex quota on the right side of the working-directory footer line.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `tps`               | hook (no command)             | Notify tokens/sec and in/out/cache token usage at the end of each agent turn.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
 | `vision`            | `vision` tool, `/vision`      | Ask a vision model targeted questions about an image file and get a text answer — for models that can't see images. Follow-ups via `followUp: true`. Self-hides when the active model has image input.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
 | `side`              | `/side`, `/end-side-session`         | Consult a second model alongside the session. `/side [provider/model-id]` parks the main agent (branch tip + model recorded in a marker entry) and opens a side conversation on its own tree limb; the side model sees the main conversation as one attributed quote — “a transcript of a session you were not part of”, untrusted evidence, not its own history — via a per-request context lens. `/end-side-session [trajectory\|summary\|nothing]` picks the handoff at exit: full transcript quote, a summary written by the side model, or nothing; the main branch stays clean either way. Arguments tab-complete.                                                                                                                                                                                                                                                                                                                        |
@@ -25,7 +25,7 @@ extensions. One entry point, thirteen independent features.
 First install, pinned to a published version:
 
 ```bash
-pi install npm:bermudis-pi-goodies@0.28.0
+pi install npm:bermudis-pi-goodies@0.29.0
 ```
 
 Picking up a new release on an existing install (`pi install` is not the
@@ -301,6 +301,23 @@ OpenAI Codex's ChatGPT subscription quota when using `openai-codex` OAuth, and
 CommandCode credit balance plus 5-hour/weekly usage windows for
 `commandcode` and `commandcode-anthropic` (same account, same key);
 it skips platform API-key auth because that has no ChatGPT subscription quota.
+For `anthropic` OAuth (the `/login anthropic` Claude Pro/Max subscription), the
+footer shows the same two windows Claude Code's `/usage` panel renders —
+`Current session` (5-hour) and `This week` — plus per-model weekly windows
+(Opus/Sonnet, and newer model-scoped plans) and remaining usage credits when
+extra usage is enabled with a cap. Anthropic API-key auth has no subscription
+quota, so nothing is shown or fetched without the OAuth login.
+The same read backs the **`claude-code`** provider from
+`@earendil-works/pi-claude-code` (models named `claude-code/claude-*`). That
+provider holds no token of its own — it deliberately resolves auth to the
+sentinel string `external-process` because the Claude Code CLI owns the login —
+so the footer reads Claude Code's ambient credential instead:
+`CLAUDE_CODE_OAUTH_TOKEN` when set, otherwise
+`claudeAiOauth.accessToken` in `<config dir>/.credentials.json`, where the
+config dir is `PI_CLAUDE_CODE_CONFIG_DIR`, then `CLAUDE_CONFIG_DIR`, then
+`~/.claude`. The token is used only to sign that one request; it is never
+logged or cached. It is gated on OAuth too, and the provider reports `oauth`
+only for a subscription login, so an API-key Claude Code install is skipped.
 For `openai` OAuth (Sign in with ChatGPT), OpenAI rejects the new token on its
 usage endpoints (`401 rejected_by_access_enforcement`), so the footer reads the
 plan windows through a companion `openai-codex` login on the same ChatGPT
@@ -312,7 +329,12 @@ OpenRouter uses `GET /api/v1/credits`; z.ai uses
 `GET /api/monitor/usage/quota/limit`; Codex and OpenAI use `GET /wham/usage`
 (plus `/chatpass/apps` for OpenAI); CommandCode uses
 `GET /alpha/billing/credits` (a private endpoint its CLI
-also uses; `COMMANDCODE_API_URL` can override the base URL). z.ai, Codex, and
+also uses; `COMMANDCODE_API_URL` can override the base URL); Anthropic and
+Claude Code both use
+`GET /api/oauth/usage` on `api.anthropic.com` — the endpoint Claude Code's own
+`/usage` panel reads (`ANTHROPIC_USAGE_URL` overrides the base URL, and is
+deliberately independent of `ANTHROPIC_BASE_URL`: a proxy base URL carries no
+subscription quota). z.ai, Codex, and
 CommandCode show both each quota's window length and its `nextResetTime`/`reset_at`
 countdown (when supplied), and `CODEX_API_URL` or `CHATGPT_BASE_URL` can
 override the Codex base URL.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bermudis-pi-goodies",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bermudi/agent-extensions.git",

package/provider-balance.ts

@@ -24,6 +24,7 @@ import {
   unlinkSync,
 } from "node:fs";
 import { join } from "node:path";
+import { homedir } from "node:os";
 import {
   writeJsonFileAtomic,
   describeError,
@@ -64,6 +65,16 @@ const COMMANDCODE_API_BASE = (
   process.env.COMMANDCODE_API_URL || "https://api.commandcode.ai"
 ).replace(/\/+$/, "");
 const COMMANDCODE_CREDITS_ENDPOINT = `${COMMANDCODE_API_BASE}/alpha/billing/credits`;
+/**
+ * Subscription usage for Anthropic Pro/Max plans. Same host and bearer as the
+ * chat completions pi already sends to api.anthropic.com, and the endpoint
+ * Claude Code's own /usage panel reads. Deliberately NOT derived from
+ * ANTHROPIC_BASE_URL: proxy/gateway base URLs carry no subscription quota, so
+ * only the dedicated override moves this read.
+ */
+const ANTHROPIC_USAGE_ENDPOINT = `${(
+  process.env.ANTHROPIC_USAGE_URL || "https://api.anthropic.com"
+).replace(/\/+$/, "")}/api/oauth/usage`;
 const BALANCE_FETCH_TIMEOUT_MS = 5_000;
 /**
  * While Pi is waiting for input, periodically adopt another session's fresh
@@ -759,7 +770,7 @@ export interface CommandcodeBalance {
 const COMMANDCODE_FIVE_HOUR_SECONDS = 5 * 60 * 60;
 const COMMANDCODE_WEEK_SECONDS = 7 * 24 * 60 * 60;
 
-function parseCommandcodeResetAtSeconds(value: unknown): number | undefined {
+function parseResetAtSeconds(value: unknown): number | undefined {
   let millis: number | null = null;
   if (typeof value === "number" && Number.isFinite(value)) {
     // Millisecond epochs are ~1e12 and up; second epochs are ~1e9.
@@ -768,7 +779,10 @@ function parseCommandcodeResetAtSeconds(value: unknown): number | undefined {
     const parsed = Date.parse(value.trim());
     millis = Number.isNaN(parsed) ? null : parsed;
   }
-  return millis !== null && millis > 0 ? millis / 1000 : undefined;
+  // Whole seconds: ISO inputs carry sub-second precision (the live Claude
+  // endpoint returns microseconds), but every consumer compares these against
+  // second-granular countdowns and caches them as numbers.
+  return millis !== null && millis > 0 ? Math.floor(millis / 1000) : undefined;
 }
 
 function parseCommandcodeWindow(
@@ -778,7 +792,7 @@ function parseCommandcodeWindow(
   const used = numericProperty(value, "used");
   const cap = numericProperty(value, "cap");
   if (used === null || cap === null || cap <= 0) return null;
-  const resetAt = parseCommandcodeResetAtSeconds(asRecord(value)?.resetAt);
+  const resetAt = parseResetAtSeconds(asRecord(value)?.resetAt);
   return {
     usedPercent: (used / cap) * 100,
     windowSeconds,
@@ -855,6 +869,246 @@ async function fetchCommandcodeBalance(
   return commandcodeBalanceToBalance(balance);
 }
 
+// --- Claude (Anthropic Pro/Max subscription) ------------------------------
+// Anthropic exposes subscription usage at GET /api/oauth/usage on
+// api.anthropic.com — the same host and bearer Claude Code's /usage panel
+// reads. The response body is the utilization object itself (verified live
+// 2026-10-31 against Claude Code 2.1.314): window utilization is 0–100
+// "percent used" and resets_at is an ISO-8601 string. The panel renders
+// "Current session" (five_hour) and "This week" (seven_day) from it; Max
+// plans can add per-model weekly windows (seven_day_opus/seven_day_sonnet
+// and limits[] rows with kind "weekly_scoped"), which get segment labels.
+// API-key auth has no subscription quota, so the adapter is OAuth-gated.
+
+export interface ClaudeUsageWindow {
+  usedPercent: number;
+  windowSeconds: number;
+  /** Unix timestamp in seconds, from the API's ISO `resets_at`. */
+  resetAt?: number;
+}
+
+export interface ClaudeUsage {
+  fiveHour: ClaudeUsageWindow | null;
+  sevenDay: ClaudeUsageWindow | null;
+  /** Per-model weekly windows ("Opus", "Sonnet", or a model display name). */
+  scoped: Array<ClaudeUsageWindow & { label: string }>;
+  /** Remaining usage-credit dollars when extra usage is enabled with a cap. */
+  credits: number | null;
+}
+
+const CLAUDE_FIVE_HOUR_SECONDS = 5 * 60 * 60;
+const CLAUDE_WEEK_SECONDS = 7 * 24 * 60 * 60;
+
+function parseClaudeUsageWindow(
+  value: unknown,
+  windowSeconds: number,
+): ClaudeUsageWindow | null {
+  const record = asRecord(value);
+  if (!record) return null;
+  const usedPercent = numericProperty(record, "utilization");
+  if (usedPercent === null) return null;
+  const resetAt = parseResetAtSeconds(record.resets_at);
+  return {
+    usedPercent,
+    windowSeconds,
+    ...(resetAt !== undefined ? { resetAt } : {}),
+  };
+}
+
+export function parseClaudeUsage(value: unknown): ClaudeUsage | null {
+  const payload = asRecord(value);
+  if (!payload) return null;
+
+  const fiveHour = parseClaudeUsageWindow(
+    payload.five_hour,
+    CLAUDE_FIVE_HOUR_SECONDS,
+  );
+  const sevenDay = parseClaudeUsageWindow(
+    payload.seven_day,
+    CLAUDE_WEEK_SECONDS,
+  );
+
+  // Per-model weekly windows. The explicit fields cover Opus/Sonnet on Max
+  // plans; limits[] rows with kind "weekly_scoped" carry newer model-scoped
+  // windows (Claude Code renders those as "Current week (<model>)").
+  const scoped: Array<ClaudeUsageWindow & { label: string }> = [];
+  for (const [field, label] of [
+    ["seven_day_opus", "Opus"],
+    ["seven_day_sonnet", "Sonnet"],
+  ] as const) {
+    const window = parseClaudeUsageWindow(payload[field], CLAUDE_WEEK_SECONDS);
+    if (window) scoped.push({ label, ...window });
+  }
+  if (Array.isArray(payload.limits)) {
+    for (const candidate of payload.limits) {
+      if (stringProperty(candidate, "kind") !== "weekly_scoped") continue;
+      const displayName = stringProperty(
+        objectProperty(objectProperty(candidate, "scope"), "model"),
+        "display_name",
+      );
+      if (!displayName) continue;
+      const usedPercent = numericProperty(candidate, "percent");
+      if (usedPercent === null) continue;
+      const resetAt = parseResetAtSeconds(asRecord(candidate)?.resets_at);
+      scoped.push({
+        label: displayName,
+        usedPercent,
+        windowSeconds: CLAUDE_WEEK_SECONDS,
+        ...(resetAt !== undefined ? { resetAt } : {}),
+      });
+    }
+  }
+
+  // Usage credits (extra usage): a monthly dollar cap, not a prepaid pool
+  // balance — show remaining-to-cap only when the feature is on.
+  const extraUsage = asRecord(payload.extra_usage);
+  let credits: number | null = null;
+  if (extraUsage?.is_enabled === true) {
+    const monthlyLimit = numericProperty(extraUsage, "monthly_limit");
+    const usedCredits = numericProperty(extraUsage, "used_credits");
+    if (monthlyLimit !== null && usedCredits !== null) {
+      credits = Math.max(0, monthlyLimit - usedCredits);
+    }
+  }
+
+  if (!fiveHour && !sevenDay && scoped.length === 0 && credits === null) {
+    return null;
+  }
+  return { fiveHour, sevenDay, scoped, credits };
+}
+
+export function claudeUsageToBalance(usage: ClaudeUsage): Balance {
+  const segments: BalanceSegment[] = [];
+  for (const window of [usage.fiveHour, usage.sevenDay]) {
+    if (window) segments.push({ quota: windowToQuota(window) });
+  }
+  for (const window of usage.scoped) {
+    segments.push({ label: window.label, quota: windowToQuota(window) });
+  }
+  if (usage.credits !== null) segments.push({ credits: usage.credits });
+  return segments;
+}
+
+export function formatClaudeUsage(
+  usage: ClaudeUsage,
+  nowMs = Date.now(),
+): string {
+  return formatBalance(claudeUsageToBalance(usage), nowMs);
+}
+
+export async function fetchClaudeUsage(
+  token: string,
+  signal: AbortSignal,
+): Promise<Balance> {
+  const response = await fetch(ANTHROPIC_USAGE_ENDPOINT, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+    },
+    signal: timeoutSignal(BALANCE_FETCH_TIMEOUT_MS, signal),
+  });
+  if (!response.ok) {
+    throw new Error(`Claude usage request failed: ${response.status}`);
+  }
+  const usage = parseClaudeUsage(await response.json());
+  if (usage === null) {
+    throw new Error("Claude usage response was invalid");
+  }
+  return claudeUsageToBalance(usage);
+}
+
+// --- Claude Code provider (pi-claude-code) ---------------------------------
+// The `claude-code` provider (@earendil-works/pi-claude-code) does NOT hold a
+// token: its auth resolves to the sentinel string "external-process" because
+// the Claude Code CLI owns the login and performs the requests itself. Pi's
+// registry therefore cannot hand this adapter a usable bearer, so the read
+// resolves Claude Code's own ambient credential instead.
+//
+// That credential is only ever read into this process to become one
+// Authorization header: it is never logged, echoed, cached, or returned. Failing
+// to find it is an expected, reported condition (the session simply shows no
+// Claude balance) — never a silently wrong number.
+
+export function claudeCodeConfigDir(
+  env: Record<string, string | undefined> = process.env,
+): string {
+  // Mirrors the provider's own resolution order (see provider.ts
+  // PROVIDER_ENV_NAMES): PI_CLAUDE_CODE_CONFIG_DIR, then CLAUDE_CONFIG_DIR,
+  // then Claude Code's default.
+  return (
+    env.PI_CLAUDE_CODE_CONFIG_DIR ||
+    env.CLAUDE_CONFIG_DIR ||
+    join(homedir(), ".claude")
+  );
+}
+
+interface ClaudeCodeCredentials {
+  accessToken: string;
+  /** Epoch milliseconds, as Claude Code stores it. */
+  expiresAt?: number;
+}
+
+/**
+ * Claude Code's ambient OAuth credential. `CLAUDE_CODE_OAUTH_TOKEN` (a token
+ * minted by `claude setup-token`) wins when set; otherwise the credential file
+ * Claude Code maintains in its config directory is used.
+ */
+export function readClaudeCodeCredentials(
+  env: Record<string, string | undefined> = process.env,
+): ClaudeCodeCredentials {
+  const fromEnv = env.CLAUDE_CODE_OAUTH_TOKEN?.trim();
+  if (fromEnv) return { accessToken: fromEnv };
+
+  const path = join(claudeCodeConfigDir(env), ".credentials.json");
+  const raw = readRegularJsonFile(path);
+  if (raw === null) {
+    throw new Error(
+      `Claude Code has no readable credential file at ${path}; run \`claude auth login\``,
+    );
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Claude Code credential file at ${path} is not valid JSON`);
+  }
+  const oauth = objectProperty(parsed, "claudeAiOauth");
+  const accessToken = stringProperty(oauth, "accessToken");
+  if (!accessToken) {
+    throw new Error(
+      `Claude Code credential file at ${path} has no subscription token; run \`claude auth login\``,
+    );
+  }
+  const expiresAt = numericProperty(oauth, "expiresAt");
+  return {
+    accessToken,
+    ...(expiresAt !== null ? { expiresAt } : {}),
+  };
+}
+
+/**
+ * Balance for the `claude-code` provider. The `token` argument is the registry
+ * sentinel and is deliberately ignored: the real credential comes from Claude
+ * Code, which owns the login.
+ */
+export async function fetchClaudeCodeUsage(
+  _token: string,
+  signal: AbortSignal,
+): Promise<Balance> {
+  const credentials = readClaudeCodeCredentials();
+  // Claude Code refreshes this token itself on its next run. Reporting the
+  // expiry beats sending a stale bearer that can only answer 401.
+  if (
+    credentials.expiresAt !== undefined &&
+    credentials.expiresAt <= Date.now()
+  ) {
+    throw new Error(
+      `Claude Code's OAuth token expired at ${new Date(credentials.expiresAt).toISOString()}; it refreshes on Claude Code's next run`,
+    );
+  }
+  return fetchClaudeUsage(credentials.accessToken, signal);
+}
+
 const BALANCE_ADAPTERS: Readonly<Record<string, BalanceAdapter>> = {
   kilo: { fetch: fetchKiloBalance },
   openrouter: { fetch: fetchOpenRouterBalance },
@@ -869,6 +1123,15 @@ const BALANCE_ADAPTERS: Readonly<Record<string, BalanceAdapter>> = {
   // Both CommandCode transports share one account and one key.
   commandcode: { fetch: fetchCommandcodeBalance },
   "commandcode-anthropic": { fetch: fetchCommandcodeBalance },
+  // Anthropic Pro/Max subscription windows ("Current session", "This week").
+  // API-key auth has no subscription quota, so never fetch it without OAuth.
+  anthropic: { fetch: fetchClaudeUsage, requiresOAuth: true },
+  // The pi-claude-code provider delegates login to the Claude Code CLI and
+  // resolves its own auth to a sentinel, so this adapter reads Claude Code's
+  // ambient credential itself. Pi still gates it on OAuth: the provider
+  // reports "oauth" only for a Claude subscription login, so an API-key
+  // Claude Code setup is skipped.
+  "claude-code": { fetch: fetchClaudeCodeUsage, requiresOAuth: true },
 };
 
 // --- Shared balance cache ---------------------------------------------------
@@ -915,7 +1178,9 @@ export function balanceCacheKey(
               : provider === "commandcode" ||
                   provider === "commandcode-anthropic"
                 ? COMMANDCODE_CREDITS_ENDPOINT
-                : provider;
+                : provider === "anthropic" || provider === "claude-code"
+                  ? ANTHROPIC_USAGE_ENDPOINT
+                  : provider;
   const fingerprint = createHash("sha256").update(identity).digest("hex");
   return `v2:${provider}:${endpoint}:${fingerprint}`;
 }

package/review.ts

@@ -302,7 +302,7 @@ const COMMIT_PROMPT =
   "Review the code changes introduced by commit {sha}. Provide prioritized, actionable findings.";
 
 const COMMIT_RANGE_PROMPT =
-  "Review the code changes introduced by the commit range {range}. Run `git log --oneline {range}` to see the commits in the range, then run `git diff {range}` to inspect the combined diff. Provide prioritized, actionable findings.";
+  "Review the code changes introduced by the commit range {range}. Run `git log --oneline {logRange}` to see the commits in the range, then run `git diff {range}` to inspect the combined diff. Provide prioritized, actionable findings.";
 
 const COMMIT_RANGE_THREE_DOT_NOTE =
   " The three-dot form diffs the second endpoint against the merge base of the two endpoints.";
@@ -310,6 +310,12 @@ const COMMIT_RANGE_THREE_DOT_NOTE =
 const COMMIT_RANGE_PROMPT_WITH_COMMITS =
   "Review the code changes introduced by the commit range {range}. The commits in the range are:\n\n{commits}\n\nRun `git diff {range}` to inspect the combined diff. Provide prioritized, actionable findings.";
 
+/** Max commits embedded in the review prompt; the rest is noted as truncated. */
+export const COMMIT_RANGE_COMMIT_LIMIT = 100;
+
+const COMMIT_RANGE_TRUNCATED_NOTE =
+  "\n\n(Commit list truncated to the first {limit} commits — run `git log --oneline {logRange}` for the full list.)";
+
 const PULL_REQUEST_PROMPT =
   "Review pull request #{prNumber} (\"{title}\") against the base branch '{baseBranch}'. The merge base commit for this comparison is {mergeBaseSha}. Run `git diff {mergeBaseSha}` to inspect the changes that would be merged. Provide prioritized, actionable findings.";
 
@@ -723,7 +729,11 @@ export function parseReviewPaths(tokens: string[]): string[] {
  * against the merge base of A and B, like a PR). Endpoints are any git rev
  * (SHA, branch, tag, `HEAD~3`, …). Open-ended ranges (`A..`, `..B`) and
  * option-like endpoints (`-x`) are rejected so a malformed range fails here
- * instead of as a confusing git error in the review prompt.
+ * instead of as a confusing git error in the review prompt. Endpoints are
+ * also restricted to a git-ref character set: the range is interpolated
+ * verbatim into the prompt's `git log`/`git diff` instructions, which the
+ * reviewing agent runs through a shell, so shell metacharacters (`;`, `$()`,
+ * backticks, `|`, …) must never reach it.
  */
 export function parseCommitRange(value: string): {
   from: string;
@@ -741,6 +751,7 @@ export function parseCommitRange(value: string): {
     if (!endpoint) return null;
     if (endpoint.includes("..") || /\s/.test(endpoint)) return null;
     if (endpoint.startsWith("-") || endpoint.startsWith(".")) return null;
+    if (!/^[A-Za-z0-9._/~^@{}-]+$/.test(endpoint)) return null;
   }
   return { from, to, threeDot, range: trimmed };
 }
@@ -1018,24 +1029,51 @@ export async function buildReviewPrompt(
       return COMMIT_PROMPT.replace("{sha}", () => target.sha);
 
     case "commitRange": {
-      const { range, threeDot, title } = target;
+      const { range, from, to, threeDot, title } = target;
       const note = threeDot ? COMMIT_RANGE_THREE_DOT_NOTE : "";
+      // Always list with the two-dot range: `git log A...B` is a symmetric
+      // difference and would include A-only commits on diverged endpoints,
+      // while the reviewed `git diff A...B` contains exactly A..B's commits.
+      const logRange = `${from}..${to}`;
+      const fallbackPrompt = () =>
+        COMMIT_RANGE_PROMPT.replace(/{range}/g, () => range).replace(
+          /{logRange}/g,
+          () => logRange,
+        );
       let prompt: string;
       try {
         const { stdout, code } = await pi.exec("git", [
           "log",
           "--oneline",
-          range,
+          "-n",
+          `${COMMIT_RANGE_COMMIT_LIMIT + 1}`,
+          logRange,
         ]);
-        const commits = code === 0 ? stdout.trim() : "";
-        prompt = commits
-          ? COMMIT_RANGE_PROMPT_WITH_COMMITS.replace(
-              /{range}/g,
-              () => range,
-            ).replace("{commits}", () => commits)
-          : COMMIT_RANGE_PROMPT.replace(/{range}/g, () => range);
+        const lines =
+          code === 0
+            ? stdout
+                .trim()
+                .split("\n")
+                .filter((line) => line.trim())
+            : [];
+        if (lines.length === 0) {
+          prompt = fallbackPrompt();
+        } else {
+          const truncated = lines.length > COMMIT_RANGE_COMMIT_LIMIT;
+          const commits = lines.slice(0, COMMIT_RANGE_COMMIT_LIMIT).join("\n");
+          prompt = COMMIT_RANGE_PROMPT_WITH_COMMITS.replace(
+            /{range}/g,
+            () => range,
+          ).replace("{commits}", () => commits);
+          if (truncated) {
+            prompt += COMMIT_RANGE_TRUNCATED_NOTE.replace(
+              "{limit}",
+              String(COMMIT_RANGE_COMMIT_LIMIT),
+            ).replace(/{logRange}/g, () => logRange);
+          }
+        }
       } catch {
-        prompt = COMMIT_RANGE_PROMPT.replace(/{range}/g, () => range);
+        prompt = fallbackPrompt();
       }
       if (title) prompt += ` The range is described as: "${title}".`;
       return prompt + note;