squad-kit 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.2] - 2026-04-22
+
+### Fixed
+
+- **Rate-limit retry no longer burns a doomed request.** 0.2.1 capped the auto-retry wait at 30 s. When a provider asked for longer than that (common on Anthropic Tier 1, which regularly asks for 60–180 s), squad-kit would retry *inside the same throttle window* and fail a second time. 0.2.2:
+  - Raises the retry cap from 30 s to **90 s**, which comfortably covers the provider-suggested wait for most Tier 1 / free-tier 429s.
+  - **Skips the retry entirely** when `Retry-After` is longer than the 90 s cap, and surfaces a dedicated message explaining the decision (`squad-kit did not auto-retry: the provider's 132s wait is longer than our 90s cap, so retrying would just burn another request inside the same throttle window.`) instead of wasting a request and showing the "already retried" variant.
+
+### Added
+
+- **`squad doctor` now reports planner tier vs. model awareness** (check id `planner-tier`). When `planner.provider === 'anthropic'` and the resolved plan model id contains `opus`, the check emits a **warn** with a fix hint suggesting `squad config set planner` to pick Sonnet or Haiku, which live in separate per-model rate-limit buckets on Anthropic Tier 1 (10 k input tokens / minute). For non-Anthropic providers and non-Opus models, the check is `skip` or `ok` — no noise for users who aren't affected.
+- `rateLimitMessage` gained a `retrySkippedReason` + `maxRetrySec` field, so the error text can distinguish "we retried and got throttled again" (firm over-quota) from "we did not retry because your wait is longer than our cap" (retry would be pointless). Both cases still surface the same four recovery options.
+
 ## [0.2.1] - 2026-04-22
 
 ### Fixed

package/dist/cli.js

@@ -2437,7 +2437,8 @@ function rateLimitMessage(err) {
     google: "https://aistudio.google.com/app/plan_information"
   };
   const headline = err.retryAfterSec ? `${err.provider} rate limit hit \u2014 provider asked us to wait ${err.retryAfterSec}s before retrying.` : `${err.provider} rate limit hit.`;
-  const retried = err.retryAlreadyAttempted ? "squad-kit already retried once automatically and was throttled again \u2014 your org is firmly over its per-minute quota." : "squad-kit aborted before retrying.";
+  const cap = err.maxRetrySec ?? 90;
+  const retried = err.retrySkippedReason === "retry_after_too_long" ? `squad-kit did not auto-retry: the provider's ${err.retryAfterSec}s wait is longer than our ${cap}s cap, so retrying would just burn another request inside the same throttle window.` : err.retryAlreadyAttempted ? "squad-kit already retried once automatically and was throttled again \u2014 your org is firmly over its per-minute quota." : "squad-kit aborted before retrying.";
   return [
     headline,
     retried,
@@ -2455,7 +2456,7 @@ function rateLimitMessage(err) {
 }
 
 // src/planner/loop.ts
-var MAX_RATE_LIMIT_RETRY_SEC = 30;
+var MAX_RATE_LIMIT_RETRY_SEC = 90;
 var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function runPlanner(input6) {
   const maxIter = input6.maxIterations ?? 40;
@@ -2486,19 +2487,25 @@ async function runPlanner(input6) {
       input6.onUsage?.(response.usage);
     }
     let retriedRateLimit = false;
+    let retrySkippedReason;
     if (response.stopReason === "error" && response.errorKind === "rate_limit") {
-      const waitSec = Math.min(response.retryAfterSec ?? 10, MAX_RATE_LIMIT_RETRY_SEC);
-      input6.onRateLimit?.(waitSec);
-      await (input6.sleep ?? defaultSleep)(waitSec * 1e3);
-      response = await input6.provider.send(request);
-      if (response.usage) {
-        input6.budget.recordUsage(response.usage);
-        input6.onUsage?.(response.usage);
+      const asked = response.retryAfterSec;
+      if (asked !== void 0 && asked > MAX_RATE_LIMIT_RETRY_SEC) {
+        retrySkippedReason = "retry_after_too_long";
+      } else {
+        const waitSec = Math.min(asked ?? 10, MAX_RATE_LIMIT_RETRY_SEC);
+        input6.onRateLimit?.(waitSec);
+        await (input6.sleep ?? defaultSleep)(waitSec * 1e3);
+        response = await input6.provider.send(request);
+        if (response.usage) {
+          input6.budget.recordUsage(response.usage);
+          input6.onUsage?.(response.usage);
+        }
+        retriedRateLimit = true;
       }
-      retriedRateLimit = true;
     }
     if (response.stopReason === "error") {
-      throw composePlannerError(input6.provider.name, response, retriedRateLimit);
+      throw composePlannerError(input6.provider.name, response, retriedRateLimit, retrySkippedReason);
     }
     if (response.text) {
       accumulatedText += response.text;
@@ -2541,14 +2548,16 @@ async function runPlanner(input6) {
   }
   return { planText: accumulatedText, budgetExhausted, timedOut: false, finishedNormally: false, iterations };
 }
-function composePlannerError(providerName, response, retriedRateLimit) {
+function composePlannerError(providerName, response, retriedRateLimit, retrySkippedReason) {
   if (response.errorKind === "rate_limit") {
     return new Error(
       rateLimitMessage({
         provider: providerName,
         retryAfterSec: response.retryAfterSec,
         rawBody: response.rawError ?? "",
-        retryAlreadyAttempted: retriedRateLimit
+        retryAlreadyAttempted: retriedRateLimit,
+        retrySkippedReason,
+        maxRetrySec: MAX_RATE_LIMIT_RETRY_SEC
       })
     );
   }
@@ -3826,6 +3835,28 @@ async function checkPlannerModel(_paths, ctx) {
     };
   }
 }
+async function checkPlannerTierAwareness(_paths, ctx) {
+  const id = "planner-tier";
+  const name = "planner tier vs. model";
+  if (!ctx.config || ctx.config.planner?.enabled !== true) {
+    return { id, name, status: "skip", detail: "planner disabled" };
+  }
+  const provider = ctx.config.planner.provider;
+  if (provider !== "anthropic") {
+    return { id, name, status: "skip", detail: `not applicable for ${provider}` };
+  }
+  const planModel = modelFor(provider, "plan", ctx.config.planner.modelOverride);
+  if (!/opus/i.test(planModel)) {
+    return { id, name, status: "ok", detail: `${planModel} is comfortably under Tier 1` };
+  }
+  return {
+    id,
+    name,
+    status: "warn",
+    detail: `${planModel} on Anthropic Tier 1 (10k input tokens/min) is throttle-prone for plans over ~3 file reads`,
+    fixHint: "Run `squad config set planner` and pick a Sonnet or Haiku id for planner.modelOverride.anthropic, or upgrade tier at https://console.anthropic.com/settings/limits. squad-kit will auto-retry a 429 once (waiting up to 90s), but repeated throttling means the plan model is simply too big for your quota."
+  };
+}
 async function checkTrackerConfig(_paths, ctx) {
   if (!ctx.config) {
     return { id: "tracker-config", name: "tracker configuration", status: "skip", detail: "config unavailable" };
@@ -3947,6 +3978,7 @@ async function runAllChecks(paths, ctx, fix) {
   await add("planner configuration", () => checkPlannerConfig(paths, ctx));
   await add("planner credential resolves", () => checkPlannerCredential(paths, ctx));
   await add("planner model resolves at provider", () => checkPlannerModel(paths, ctx));
+  await add("planner tier vs. model", () => checkPlannerTierAwareness(paths, ctx));
   await add("tracker configuration", () => checkTrackerConfig(paths, ctx));
   await add("tracker credential resolves", () => checkTrackerCredential(paths, ctx));
   await add("tracker connectivity", () => checkTrackerConnectivity(paths, ctx));
@@ -4840,7 +4872,7 @@ async function runRmPlan(planPathOrSequence, opts = {}) {
 
 // src/cli.ts
 var program = new Command();
-program.name("squad").description("Plan once, execute cheap. A 3-step SDD workflow CLI.").version("0.2.1");
+program.name("squad").description("Plan once, execute cheap. A 3-step SDD workflow CLI.").version("0.2.2");
 program.command("init").description("Bootstrap .squad/ in the current directory").option("--agents <list>", "Comma-separated agent list: claude-code,cursor,copilot,gemini").option("--tracker <type>", "Tracker type: none|github|linear|jira|azure").option(
   "--tracker-workspace <hostOrOrg>",
   "Jira host or Azure org (non-interactive default; also written to config for jira/azure)"