@ilya-lesikov/pi-pi 0.6.0 → 0.8.0

package/extensions/orchestrator/rate-limit-fallback.ts

@@ -0,0 +1,243 @@
+import type { Orchestrator } from "./orchestrator.js";
+import { getLogger } from "./log.js";
+import { isSubscriptionRouted } from "./usage-tracker.js";
+import { setSubscriptionFallbackActive, toNonSubSpec } from "./model-registry.js";
+import { loadFlantSettings, probeSubscriptionCleared } from "./flant-infra.js";
+import { askUser, isCancel } from "../../3p/pi-ask-user/index.js";
+
+// Recognise a rate-limit / 429 error from a turn's or subagent's error message.
+export function isRateLimitError(message?: string): boolean {
+  if (typeof message !== "string") return false;
+  return /\b429\b|rate.?limit|too many requests|exceed your account/i.test(message);
+}
+
+// Mirror of the SDK's AgentSession._isRetryableError classifier
+// (agent-session.js: overloaded/rate-limit/5xx/network/stream-ended/timeout/...).
+// When true, the SDK auto-retries the SAME turn itself (abortable backoff bound
+// to ESC, visible countdown). pi-pi must NOT ALSO schedule its own post-error
+// retry for these: a second, independent retry races the SDK's continue() and
+// reproduces "Agent is already processing", and re-nudges a futile sub-429. This
+// list is kept in sync with the SDK regex; if they drift, pi-pi at worst falls
+// back to its own idle-gated retry (still safe, just not unified).
+export function isSdkRetryableError(message?: string): boolean {
+  if (typeof message !== "string" || !message) return false;
+  return /overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|network.?error|connection.?error|connection.?refused|connection.?lost|websocket.?closed|websocket.?error|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|ended without|stream ended before message_stop|http2 request did not get a response|timed? out|timeout|terminated|retry delay/i.test(
+    message,
+  );
+}
+
+const SWITCH_DIALOG_CONTEXT =
+  "Switching between the personal subscription and regular flant Claude changes the provider/endpoint, " +
+  "so the prompt cache is LOST and the full conversation context is re-sent on the next call. " +
+  "Regular (non-subscription) flant Claude is billed PER TOKEN (paid).";
+
+// Handle a subscription-routed 429 on the MAIN turn. Stops futile retries on the
+// still-limited sub model, then (once, session-sticky) asks the user whether to
+// fall back to non-sub Claude. On confirm: activates the session-scoped override,
+// switches the active model, arms the switch-back probe, and nudges to continue.
+export async function handleMainRateLimit(
+  orchestrator: Orchestrator,
+  ctx: any,
+  modelId: string | undefined,
+  provider: string | undefined,
+): Promise<void> {
+  const log = getLogger();
+  if (!isSubscriptionRouted(modelId, provider)) return;
+
+  // Stop the futile same-model retry (SDK backoff + pi-pi's own timer): retrying
+  // the sub model against an account-level limit cannot succeed.
+  ctx?.abort?.();
+  orchestrator.cancelPendingRetry();
+
+  if (orchestrator.subFallbackActive) return; // sticky — already on non-sub
+  await offerFallback(orchestrator, ctx, modelId ?? orchestrator.subFallbackModelId ?? "", "main");
+}
+
+// Handle a subscription-routed 429 reported via subagents:failed. Uses ONE
+// global dialogue (never per-subagent) — the same offerFallback path as the
+// main turn, guarded so only one dialogue is open at a time.
+export async function handleSubagentRateLimit(
+  orchestrator: Orchestrator,
+  ctx: any,
+  modelId: string | undefined,
+): Promise<void> {
+  if (!isSubscriptionRouted(modelId)) return;
+  if (orchestrator.subFallbackActive) return; // sticky
+  await offerFallback(orchestrator, ctx, modelId ?? "", "subagent");
+}
+
+async function offerFallback(
+  orchestrator: Orchestrator,
+  ctx: any,
+  subModelId: string,
+  origin: "main" | "subagent",
+): Promise<void> {
+  const log = getLogger();
+  if (orchestrator.subFallbackDialogPending) return;
+  if (!ctx?.hasUI) {
+    // No UI to ask — leave sub routing in place; the error is surfaced elsewhere.
+    log.debug({ s: "ratelimit" }, "no UI available to offer subscription fallback");
+    return;
+  }
+  orchestrator.subFallbackDialogPending = true;
+  const taskToken = orchestrator.activeTaskToken;
+  try {
+    const result = await askUser(ctx, {
+      question: "Personal Claude subscription is rate-limited. Switch to regular (paid) flant Claude?",
+      context: SWITCH_DIALOG_CONTEXT,
+      options: [
+        { title: "Switch to non-sub Claude", description: "Continue on regular flant Claude (paid per token) until you switch back." },
+        { title: "Stay on subscription", description: "Do not switch. Work stays paused until the limit clears." },
+      ],
+      allowFreeform: false,
+      allowComment: false,
+      allowMultiple: false,
+    });
+    if (orchestrator.activeTaskToken !== taskToken || !orchestrator.active) return;
+    const chose = result && !isCancel(result) && result.kind === "selection" ? result.selections[0] : undefined;
+    if (chose !== "Switch to non-sub Claude") {
+      ctx.ui?.notify?.("Staying on subscription. Auto-continuation paused until you resume or the limit clears.", "info");
+      return;
+    }
+    await activateFallback(orchestrator, ctx, subModelId, origin);
+  } finally {
+    orchestrator.subFallbackDialogPending = false;
+    orchestrator.subFallbackPendingDecision = false;
+  }
+}
+
+async function activateFallback(
+  orchestrator: Orchestrator,
+  ctx: any,
+  subModelId: string,
+  origin: "main" | "subagent",
+): Promise<void> {
+  const log = getLogger();
+  orchestrator.subFallbackActive = true;
+  orchestrator.subFallbackModelId = subModelId || orchestrator.subFallbackModelId;
+  // Activate the session-scoped override so EVERY future model resolution
+  // (phase switches, new subagents, planner/reviewer specs) rewrites sub→non-sub.
+  // This is what actually re-routes future subagent spawns, regardless of origin.
+  setSubscriptionFallbackActive(true);
+
+  // Switch the CURRENT main model to the non-sub equivalent ONLY when the 429 was
+  // on the main turn. For a SUBAGENT 429 the failing model is the subagent's, not
+  // the main session's — switching the main model here would change the active
+  // orchestrator model the user never touched (e.g. debug's GPT -> Claude). The
+  // session override above already re-routes the retried/next subagent.
+  if (origin === "main" && subModelId) {
+    const nonSub = toNonSubSpec(subModelId);
+    const ok = await orchestrator.switchModel(ctx, nonSub, currentThinking(orchestrator));
+    if (!ok) log.warn({ s: "ratelimit", nonSub }, "failed to switch main model to non-sub");
+  }
+
+  ctx.ui?.notify?.("Switched to regular flant Claude (paid per token). Will periodically check if the subscription limit has cleared.", "info");
+
+  armSwitchBackProbe(orchestrator);
+
+  // Nudge to continue — retries were cancelled, so the turn is stopped. Idle-gated
+  // (same guard as the post-error nudge) so it never races the SDK into an
+  // "Agent is already processing" error.
+  const phase = orchestrator.active?.state.phase ?? "current";
+  orchestrator.sendUserMessageWhenIdle(
+    `[PI-PI] Switched to regular (non-subscription) flant Claude after a rate limit. Continue working on the current phase (${phase}).`,
+    orchestrator.activeTaskToken,
+  );
+}
+
+function currentThinking(orchestrator: Orchestrator): string {
+  const phase = orchestrator.active?.state.phase;
+  const orchestrators = orchestrator.config?.agents?.orchestrators as Record<string, { thinking?: string }> | undefined;
+  const key = phase === "debug" || phase === "brainstorm" || phase === "review" || phase === "quick" ? phase : "implement";
+  return orchestrators?.[key]?.thinking ?? "high";
+}
+
+// Arm the fixed-interval switch-back probe. On each interval an out-of-band probe
+// checks whether the sub limit cleared; a 429/failure silently re-arms, a success
+// opens the switch-back dialogue. Only one timer runs at a time.
+export function armSwitchBackProbe(orchestrator: Orchestrator): void {
+  if (orchestrator.subSwitchBackTimer) clearTimeout(orchestrator.subSwitchBackTimer);
+  const minutes = Math.max(1, loadFlantSettings().switchBackIntervalMinutes || 30);
+  const taskToken = orchestrator.activeTaskToken;
+  orchestrator.subSwitchBackTimer = setTimeout(() => {
+    orchestrator.subSwitchBackTimer = null;
+    void runSwitchBackProbe(orchestrator, taskToken);
+  }, minutes * 60 * 1000);
+}
+
+async function runSwitchBackProbe(orchestrator: Orchestrator, taskToken: number): Promise<void> {
+  const log = getLogger();
+  if (orchestrator.activeTaskToken !== taskToken || !orchestrator.active || !orchestrator.subFallbackActive) {
+    return;
+  }
+  const modelId = orchestrator.subFallbackModelId;
+  if (!modelId) {
+    armSwitchBackProbe(orchestrator);
+    return;
+  }
+  const outcome = await probeSubscriptionCleared(modelId);
+  if (orchestrator.activeTaskToken !== taskToken || !orchestrator.active || !orchestrator.subFallbackActive) {
+    return;
+  }
+  if (outcome !== "ok") {
+    // Still limited (or transient error) — stay on non-sub, silently re-arm.
+    log.debug({ s: "ratelimit", outcome }, "switch-back probe: not cleared, re-arming");
+    armSwitchBackProbe(orchestrator);
+    return;
+  }
+  await offerSwitchBack(orchestrator, modelId);
+}
+
+async function offerSwitchBack(orchestrator: Orchestrator, subModelId: string): Promise<void> {
+  const log = getLogger();
+  const ctx = orchestrator.lastCtx;
+  if (orchestrator.subFallbackDialogPending || !ctx?.hasUI) {
+    armSwitchBackProbe(orchestrator);
+    return;
+  }
+  orchestrator.subFallbackDialogPending = true;
+  const taskToken = orchestrator.activeTaskToken;
+  try {
+    const result = await askUser(ctx, {
+      question: "Your Claude subscription limit appears to have cleared. Switch back to the subscription?",
+      context: SWITCH_DIALOG_CONTEXT,
+      options: [
+        { title: "Switch back to subscription", description: "Resume on the personal Claude subscription (flat-rate)." },
+        { title: "Stay on non-sub Claude", description: "Keep using regular flant Claude; check again later." },
+      ],
+      allowFreeform: false,
+      allowComment: false,
+      allowMultiple: false,
+    });
+    if (orchestrator.activeTaskToken !== taskToken || !orchestrator.active) return;
+    const chose = result && !isCancel(result) && result.kind === "selection" ? result.selections[0] : undefined;
+    if (chose !== "Switch back to subscription") {
+      // Stay on non-sub; re-arm so we check again after the interval.
+      armSwitchBackProbe(orchestrator);
+      return;
+    }
+    await switchBackToSub(orchestrator, ctx, subModelId);
+  } finally {
+    orchestrator.subFallbackDialogPending = false;
+  }
+}
+
+async function switchBackToSub(orchestrator: Orchestrator, ctx: any, subModelId: string): Promise<void> {
+  const log = getLogger();
+  // Clear the override FIRST so switchModel resolves the sub spec unrewritten.
+  orchestrator.subFallbackActive = false;
+  setSubscriptionFallbackActive(false);
+  if (orchestrator.subSwitchBackTimer) {
+    clearTimeout(orchestrator.subSwitchBackTimer);
+    orchestrator.subSwitchBackTimer = null;
+  }
+  const ok = await orchestrator.switchModel(ctx, subModelId, currentThinking(orchestrator));
+  if (!ok) log.warn({ s: "ratelimit", subModelId }, "failed to switch back to sub model");
+  orchestrator.subFallbackModelId = null;
+  ctx.ui?.notify?.("Switched back to the personal Claude subscription.", "info");
+  const phase = orchestrator.active?.state.phase ?? "current";
+  orchestrator.sendUserMessageWhenIdle(
+    `[PI-PI] Switched back to the personal Claude subscription. Continue working on the current phase (${phase}).`,
+    orchestrator.activeTaskToken,
+  );
+}

package/extensions/orchestrator/state.ts

@@ -262,30 +262,51 @@ export function validateFromPath(cwd: string, fromPath: string): { ok: true; dir
 
 export function taskName(taskDir: string): string {
   try {
-    const state = loadTask(taskDir);
-    let desc = state.description ?? "";
-
-    if (["implement", "debug", "brainstorm", "review", "quick"].includes(desc)) {
-      const urPath = join(taskDir, "USER_REQUEST.md");
-      if (existsSync(urPath)) {
-        const content = readFileSync(urPath, "utf-8");
-        const lines = content.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
-        const firstContent = lines.find((l) => !l.startsWith("#"));
-        if (firstContent) desc = firstContent;
-      }
-    }
-
-    if (desc) {
-      desc = desc.replace(/\s+/g, " ").trim();
-      if (desc.length > 60) desc = desc.slice(0, 57) + "...";
-      return desc;
-    }
+    return taskNameFromState(taskDir, loadTask(taskDir));
   } catch {
     getLogger().warn({ s: "state", taskDir }, "failed to read task name");
+    return dirSlugName(taskDir);
+  }
+}
+
+// Same as taskName but reuses an already-loaded TaskState (avoids re-reading
+// state.json per resume-menu entry). The only per-entry disk read is the
+// USER_REQUEST.md fallback, which is unavoidable for generic descriptions.
+export function taskNameFromState(taskDir: string, state: TaskState): string {
+  let desc = state.description ?? "";
+
+  if (["implement", "debug", "brainstorm", "review", "quick"].includes(desc)) {
+    const urPath = join(taskDir, "USER_REQUEST.md");
+    if (existsSync(urPath)) {
+      const content = readFileSync(urPath, "utf-8");
+      const lines = content.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
+      const firstContent = lines.find((l) => !l.startsWith("#"));
+      if (firstContent) desc = firstContent;
+    }
   }
+
+  if (desc) {
+    desc = desc.replace(/\s+/g, " ").trim();
+    if (desc.length > 60) desc = desc.slice(0, 57) + "...";
+    return desc;
+  }
+  return dirSlugName(taskDir);
+}
+
+function dirSlugName(taskDir: string): string {
+  const dir = basename(taskDir);
+  const idx = dir.indexOf("_");
+  const slug = idx >= 0 ? dir.slice(idx + 1) : dir;
+  return slug.replace(/-/g, " ");
+}
+
+// The task's short id is the leading segment of its dir name (`${id}_${slug}`),
+// where id is a 12-char uuid slice from createTask. Used to disambiguate
+// otherwise-identical resume-menu titles.
+export function taskShortId(taskDir: string): string {
   const dir = basename(taskDir);
-  const match = dir.match(/^\d+_(.+)$/);
-  return match ? match[1].replace(/-/g, " ") : dir;
+  const idPart = dir.split("_", 1)[0] ?? dir;
+  return idPart.slice(0, 6);
 }
 
 export function taskAge(state: TaskState): string {

package/extensions/orchestrator/test-helpers.ts

@@ -9,7 +9,10 @@ export interface MenuExpectation {
     include?: TextMatch[];
     exclude?: TextMatch[];
   };
-  choose: TextMatch | ((options: string[]) => string);
+  // When set, the harness returns a cancel (as askUser/isCancel would on ESC)
+  // instead of choosing an option. `choose` is ignored in that case.
+  cancel?: "user" | "timeout" | "signal";
+  choose?: TextMatch | ((options: string[]) => string);
 }
 
 export interface MenuTranscriptEntry {
@@ -21,7 +24,7 @@ export interface MenuTranscriptEntry {
 export interface AskUserHarness {
   transcript: MenuTranscriptEntry[];
   expect(step: MenuExpectation): AskUserHarness;
-  handle(opts: any): Promise<{ kind: "selection"; selections: [string] }>;
+  handle(opts: any): Promise<{ kind: "selection"; selections: [string] } | { __cancel: true; reason: "user" | "timeout" | "signal" }>;
   assertDone(): void;
 }
 
@@ -123,6 +126,15 @@ export function createAskUserHarness(): AskUserHarness {
         }
       }
 
+      if (expected.cancel) {
+        transcript.push({ question, options, chosen: `<cancel:${expected.cancel}>` });
+        return { __cancel: true, reason: expected.cancel };
+      }
+
+      if (expected.choose === undefined) {
+        throw new Error(`Menu expectation is missing a chooser\n${renderMenu(question, options)}`);
+      }
+
       let chosen: string;
       if (typeof expected.choose === "function") {
         const maybeChoice = (expected.choose as (options: string[]) => unknown)(titles);
@@ -203,9 +215,12 @@ export function expectReviewAuto(menu: AskUserHarness, preset = "regular"): void
   menu.expect({ question: "Review preset", options: { include: [m.preset(preset), "Back"] }, choose: m.preset(preset) });
 }
 
-export function expectReviewOnMyOwn(menu: AskUserHarness): void {
+export function expectReviewOnMyOwn(menu: AskUserHarness, editorGate?: "Done" | "Skip markers"): void {
   menu.expect({ question: m.anyTaskMenu, options: { include: ["Review"] }, choose: "Review" });
   menu.expect({ question: "Review", options: { include: ["Review on my own"] }, choose: "Review on my own" });
+  if (editorGate) {
+    menu.expect({ question: "Editor review", options: { include: [editorGate] }, choose: editorGate });
+  }
 }
 
 export function expectPpStartImplementAutonomous(menu: AskUserHarness): void {

package/extensions/orchestrator/usage-tracker.test.ts

@@ -96,6 +96,7 @@ describe("usage-tracker", () => {
         cacheWriteTokens: 0,
         cacheSupported: false,
         turns: 1,
+        subscription: false,
       },
       "anthropic/claude-opus-4-6": {
         inputTokens: 7,
@@ -104,6 +105,7 @@ describe("usage-tracker", () => {
         cacheWriteTokens: 0,
         cacheSupported: false,
         turns: 1,
+        subscription: false,
       },
     });
   });
@@ -186,6 +188,7 @@ describe("usage-tracker", () => {
         cost: 0.2,
         durationMs: 900,
         toolUses: 3,
+        subscription: false,
       },
     ]);
   });
@@ -226,12 +229,21 @@ describe("usage-tracker", () => {
     expect(tracker.getTotalCost()).toBe(2);
   });
 
-  it("getCacheHitRate calculates ratio", () => {
+  it("getCacheHitRate is cacheRead over processed input (uncached + read + write)", () => {
     const tracker = createUsageTracker();
 
-    tracker.recordTurn("openai/gpt-5", "openai", 30, 0, 10, 0, 0, true);
+    // uncached 30, cacheRead 10, cacheWrite 10 → 10 / (30+10+10) = 0.2
+    tracker.recordTurn("openai/gpt-5", "openai", 30, 0, 10, 10, 0, true);
 
-    expect(tracker.getCacheHitRate()).toBeCloseTo(10 / 40);
+    expect(tracker.getCacheHitRate()).toBeCloseTo(10 / 50);
+  });
+
+  it("getCacheHitRate includes subagent cache tokens", () => {
+    const tracker = createUsageTracker();
+    tracker.recordTurn("openai/gpt-5", "openai", 10, 0, 0, 0, 0, true);
+    tracker.recordSubagentCompletion({ input: 0, output: 0, cacheRead: 30, cacheWrite: 10 } as any);
+    // cacheRead 30 / processed (10 + 30 + 10) = 0.6
+    expect(tracker.getCacheHitRate()).toBeCloseTo(30 / 50);
   });
 
   it("getCacheHitRate returns zero when denominator is zero", () => {
@@ -239,6 +251,22 @@ describe("usage-tracker", () => {
     expect(tracker.getCacheHitRate()).toBe(0);
   });
 
+  it("getTotalProcessedInputTokens sums uncached + cache read + cache write across main and subagents", () => {
+    const tracker = createUsageTracker();
+    tracker.recordTurn("openai/gpt-5", "openai", 10, 0, 20, 5, 0, true);
+    tracker.recordSubagentCompletion({ input: 3, output: 0, cacheRead: 7, cacheWrite: 2 } as any);
+    // main: 10+20+5=35, subagent: 3+7+2=12 → 47
+    expect(tracker.getTotalProcessedInputTokens()).toBe(47);
+  });
+
+  it("getTotalCacheReadTokens and getTotalCacheWriteTokens include subagents", () => {
+    const tracker = createUsageTracker();
+    tracker.recordTurn("openai/gpt-5", "openai", 0, 0, 20, 5, 0, true);
+    tracker.recordSubagentCompletion({ input: 0, output: 0, cacheRead: 7, cacheWrite: 2 } as any);
+    expect(tracker.getTotalCacheReadTokens()).toBe(27);
+    expect(tracker.getTotalCacheWriteTokens()).toBe(7);
+  });
+
   it("isCacheSupported true when any model or subagent has cache", () => {
     const tracker = createUsageTracker();
     expect(tracker.isCacheSupported()).toBe(false);
@@ -382,6 +410,106 @@ describe("usage-tracker", () => {
     expect(roundTrip.subagents).toEqual((mid as any).subagents);
   });
 
+  it("subscription main turns count tokens but contribute zero cost", () => {
+    const tracker = createUsageTracker();
+
+    // Detected via the sub/ model id prefix...
+    tracker.recordTurn("sub/claude-opus-4-6", "anthropic", 100, 50, 10, 5, 1.23, true);
+    // ...or via the subscription provider with a bare id (keyed under sub/).
+    tracker.recordTurn("claude-opus-4-6", "pp-flant-anthropic-sub", 20, 10, 0, 0, 0.5, true);
+
+    expect(tracker.getMainInputTokens()).toBe(120);
+    expect(tracker.getMainOutputTokens()).toBe(60);
+    expect(tracker.getMainCacheReadTokens()).toBe(10);
+    expect(tracker.getMainCost()).toBe(0);
+    expect(tracker.getTotalCost()).toBe(0);
+    expect(tracker.getPerModelUsage()["sub/claude-opus-4-6"]?.subscription).toBe(true);
+  });
+
+  it("provider-detected subscription turns key under sub/ so paid rows stay separate", () => {
+    const tracker = createUsageTracker();
+
+    // Same underlying model id: one paid, one subscription (provider-only).
+    tracker.recordTurn("claude-opus-4-6", "pp-flant-anthropic", 10, 5, 0, 0, 0.4, false);
+    tracker.recordTurn("claude-opus-4-6", "pp-flant-anthropic-sub", 20, 10, 0, 0, 2.0, false);
+
+    const usage = tracker.getPerModelUsage();
+    expect(usage["claude-opus-4-6"]).toMatchObject({ inputTokens: 10, outputTokens: 5, subscription: false });
+    expect(usage["sub/claude-opus-4-6"]).toMatchObject({ inputTokens: 20, outputTokens: 10, subscription: true });
+    expect(tracker.getMainCost()).toBeCloseTo(0.4);
+  });
+
+  it("subscription subagents count tokens but contribute zero cost", () => {
+    const tracker = createUsageTracker();
+
+    tracker.recordSubagentCompletion({ input: 30, output: 15 } as any, 0.9, {
+      description: "Explore", agentType: "explore", modelId: "sub/claude-haiku-4-5",
+    });
+
+    expect(tracker.getSubagentTotals()).toEqual({ inputTokens: 30, outputTokens: 15, cost: 0 });
+    expect(tracker.getSubagentList()[0]?.subscription).toBe(true);
+    expect(tracker.getSubagentList()[0]?.cost).toBe(0);
+  });
+
+  it("mixed paid and subscription session totals only the paid portion", () => {
+    const tracker = createUsageTracker();
+
+    tracker.recordTurn("openai/gpt-5", "openai", 10, 5, 0, 0, 0.4, false);
+    tracker.recordTurn("sub/claude-opus-4-6", "pp-flant-anthropic-sub", 10, 5, 0, 0, 2.0, false);
+    tracker.recordSubagentCompletion({ input: 5, output: 2 } as any, 0.1, { modelId: "openai/gpt-5" });
+    tracker.recordSubagentCompletion({ input: 5, output: 2 } as any, 3.0, { modelId: "sub/claude-haiku-4-5" });
+
+    expect(tracker.getMainCost()).toBeCloseTo(0.4);
+    expect(tracker.getSubagentTotals().cost).toBeCloseTo(0.1);
+    expect(tracker.getTotalCost()).toBeCloseTo(0.5);
+  });
+
+  it("subscription marker survives JSON round-trip and stays paid-only", () => {
+    const source = createUsageTracker();
+    source.recordTurn("sub/claude-opus-4-6", "pp-flant-anthropic-sub", 10, 5, 0, 0, 2.0, true);
+    source.recordSubagentCompletion({ input: 5, output: 2 } as any, 3.0, { modelId: "sub/claude-haiku-4-5" });
+
+    const mid = source.toSummary() as Record<string, unknown>;
+    const restored = createUsageTracker();
+    restored.loadFromSummary(mid);
+
+    const roundTrip = restored.toSummary() as any;
+    expect(restored.getTotalCost()).toBe(0);
+    expect(restored.getPerModelUsage()["sub/claude-opus-4-6"]?.subscription).toBe(true);
+    expect(restored.getSubagentList()[0]?.subscription).toBe(true);
+    expect(roundTrip.totals).toEqual((mid as any).totals);
+    expect(roundTrip.models).toEqual((mid as any).models);
+    expect(roundTrip.subagents).toEqual((mid as any).subagents);
+  });
+
+  it("legacy summaries without subscription field default to non-subscription", () => {
+    const tracker = createUsageTracker();
+    tracker.loadFromSummary({
+      totals: { inputTokens: 10, outputTokens: 5, cost: 1.5, turns: 1 },
+      models: { "openai/gpt-5": { inputTokens: 10, outputTokens: 5, turns: 1 } },
+      subagents: [{ description: "a", agentType: "x", modelId: "m", inputTokens: 3, outputTokens: 1, cost: 0.2 }],
+    });
+
+    expect(tracker.getPerModelUsage()["openai/gpt-5"]?.subscription).toBe(false);
+    expect(tracker.getSubagentList()[0]?.subscription).toBe(false);
+    expect(tracker.getMainCost()).toBe(1.5);
+    expect(tracker.getSubagentTotals().cost).toBeCloseTo(0.2);
+  });
+
+  it("loadFromSummary recovers subscription from sub/ prefix when flag is absent", () => {
+    const tracker = createUsageTracker();
+    tracker.loadFromSummary({
+      totals: { inputTokens: 10, outputTokens: 5, cost: 0, turns: 1 },
+      models: { "sub/claude-opus-4-6": { inputTokens: 10, outputTokens: 5, turns: 1 } },
+      subagents: [{ description: "a", agentType: "x", modelId: "sub/claude-haiku-4-5", inputTokens: 3, outputTokens: 1, cost: 2.5 }],
+    });
+
+    expect(tracker.getPerModelUsage()["sub/claude-opus-4-6"]?.subscription).toBe(true);
+    expect(tracker.getSubagentList()[0]?.subscription).toBe(true);
+    expect(tracker.getSubagentList()[0]?.cost).toBe(0);
+    expect(tracker.getSubagentTotals().cost).toBe(0);
+  });
+
   it("reset clears all state", () => {
     const tracker = createUsageTracker();
     tracker.recordTurn("openai/gpt-5", "openai", 1, 2, 3, 4, 0.2, true);