@hienlh/ppm 0.23.2 → 0.23.4

package/src/providers/codex-app-server/codex-provider.ts

@@ -167,9 +167,14 @@ interface LiveSession {
   /** A turn is running on the thread. Codex accepts exactly one at a time: a
    *  second `turn/start` resolves with the ALREADY-RUNNING turn (same id,
    *  status `inProgress`) and silently discards the new input — no error, so
-   *  nothing downstream can notice. Follow-ups therefore wait in `pendingTurns`
-   *  and are sent when the running turn reports `turn/completed`. */
+   *  nothing downstream can notice. A `next` follow-up is therefore handed to the
+   *  running turn with `turn/steer`; anything that cannot be steered waits in
+   *  `pendingTurns` and is sent when the running turn reports `turn/completed`. */
   turnInFlight?: boolean;
+  /** Follow-ups steered into the running turn. A rotation replays the turn on another
+   *  account from `lastTurnInput`, which knows nothing of these, so they are steered
+   *  into the replay again. Cleared when the turn ends. */
+  steeredInputs?: QueuedTurn[];
   /** A daily-guard usage read is in progress before the next turn starts. */
   checkingDailyGuard?: boolean;
   /** Id of the running turn — `turn/interrupt` needs it, `threadId` alone is rejected. */
@@ -201,6 +206,8 @@ interface QueuedTurn {
   opts?: SendMessageOpts;
   /** `later` sinks to the end of the queue; `now`/`next` go in front of it. */
   priority: "now" | "next" | "later";
+  /** Already in the transcript — being sent again on another account after a rotation. */
+  replay?: boolean;
 }
 
 interface EventChannel {
@@ -209,6 +216,16 @@ interface EventChannel {
   iterator: AsyncGenerator<ChatEvent, void, undefined>;
 }
 
+/** What a user message becomes on the wire, for `turn/start` and `turn/steer` alike.
+ *  Codex takes an image as a path, never as a payload, so the uploaded copy is what it
+ *  gets. Images lead: the text usually refers to them ("what is this?"). */
+function turnInput(message: string, opts?: SendMessageOpts): UserInput[] {
+  return [
+    ...(opts?.imagePaths ?? []).map((path) => ({ type: "localImage" as const, path })),
+    { type: "text" as const, text: withSharedContext(message, opts?.sharedContext), text_elements: [] },
+  ];
+}
+
 /** Next stable `rollout-N` id for a live message. Counts existing rollout-prefixed
  *  entries (history + live transcript) so numbering continues the persisted file's
  *  sequence and stays aligned even when a non-rollout compact-summary entry is present. */
@@ -461,11 +478,14 @@ export class CodexAppServerProvider implements AIProvider {
    */
   private async startTurn(live: LiveSession, message: string, opts?: SendMessageOpts, replay = false): Promise<void> {
     if (!live.threadId) return;
-    // One turn at a time — anything sent now would be dropped without a trace.
-    // `now` additionally cuts the running turn short so this one answers next.
+    // One turn at a time — a second `turn/start` would be dropped without a trace.
+    // `next` joins the running turn the way a Claude follow-up does; `now` cuts it
+    // short so this one answers next; `later` waits for it to finish.
     if (live.turnInFlight) {
       const priority = opts?.priority ?? "next";
-      this.enqueueTurn(live, { message, opts, priority });
+      const item: QueuedTurn = { message, opts, priority, ...(replay ? { replay } : {}) };
+      if (priority === "next" && this.canSteer(live)) { this.steerTurn(live, item); return; }
+      this.enqueueTurn(live, item);
       if (priority === "now") this.interruptActiveTurn(live);
       return;
     }
@@ -500,12 +520,7 @@ export class CodexAppServerProvider implements AIProvider {
     live.currentAssistant = "";
     live.currentEvents = [];
     live.lastUsage = undefined;
-    // Codex takes an image as a path, never as a payload, so the uploaded copy is what it
-    // gets. Images lead: the text usually refers to them ("what is this?").
-    const input: UserInput[] = [
-      ...(opts?.imagePaths ?? []).map((path) => ({ type: "localImage" as const, path })),
-      { type: "text" as const, text: withSharedContext(message, opts?.sharedContext), text_elements: [] },
-    ];
+    const input = turnInput(message, opts);
     const turnModel = codexModel(opts?.model);
     const turnEffort = opts?.effort ?? this.config?.effort;
     const configuredThinking = this.config?.thinking_budget_tokens;
@@ -568,9 +583,66 @@ export class CodexAppServerProvider implements AIProvider {
     if (live.interruptRequested) {
       live.interruptRequested = false;
       this.interruptActiveTurn(live);
+      return;
+    }
+    // Follow-ups that arrived before codex named the turn had nothing to steer into.
+    while (live.pendingTurns[0]?.priority === "next" && this.canSteer(live)) {
+      this.steerTurn(live, live.pendingTurns.shift()!);
     }
   }
 
+  /**
+   * Whether a follow-up may join the running turn. Not while the turn is unnamed
+   * (`turn/steer` requires its id), being interrupted for a `now` message (the input
+   * would land in a turn that is about to stop), being discarded or rotated away, or
+   * compacting — codex refuses to steer a compaction, and the refusal would only
+   * bounce the message back to the queue.
+   */
+  private canSteer(live: LiveSession): boolean {
+    return !!live.activeTurnId && !live.interruptRequested && !live.discardingTurn
+      && !live.rotating && !live.compactRequested
+      && !live.pendingTurns.some((q) => q.priority === "now");
+  }
+
+  /**
+   * Hand a follow-up to the running turn. `expectedTurnId` makes codex refuse it if that
+   * turn has already ended, so a refusal never loses the message: it is sent as a turn
+   * of its own instead, once whatever is running now finishes.
+   */
+  private steerTurn(live: LiveSession, item: QueuedTurn): void {
+    const turnId = live.activeTurnId!;
+    live.client.request("turn/steer", {
+      threadId: live.threadId,
+      expectedTurnId: turnId,
+      input: turnInput(item.message, item.opts),
+    }).then(() => {
+      live.steeredInputs = [...(live.steeredInputs ?? []), item];
+      if (item.replay) return;
+      // The answer so far belongs above the message, as it does in the rollout, which
+      // records the steered input as a user message between two agent messages.
+      if (live.currentAssistant || live.currentEvents.length) {
+        const events = live.currentEvents.length
+          ? [...live.currentEvents, ...(live.currentAssistant ? [{ type: "text", content: live.currentAssistant } as ChatEvent] : [])]
+          : undefined;
+        live.transcript.push({
+          id: nextRolloutId(live), role: "assistant", content: live.currentAssistant,
+          ...(events ? { events } : {}), timestamp: new Date().toISOString(),
+        });
+        live.currentAssistant = "";
+        live.currentEvents = [];
+      }
+      live.transcript.push({ id: nextRolloutId(live), role: "user", content: item.message, timestamp: new Date().toISOString() });
+    }).catch((err) => {
+      if (live.client.isClosed) return;
+      console.warn(`[codex] session=${live.threadId} steer refused, sending as its own turn: ${redactTruncate((err as Error)?.message ?? String(err), 200)}`);
+      const retry: QueuedTurn = { ...item, priority: "later" };
+      // `later` so it is not steered straight back into a turn that just refused it; the
+      // head of the queue because it was sent before anything waiting there.
+      if (live.turnInFlight) live.pendingTurns.unshift(retry);
+      else void this.startTurn(live, retry.message, retry.opts, retry.replay);
+    });
+  }
+
   /** Running turn is over: send the next follow-up, if one is waiting. */
   private endTurn(live: LiveSession): void {
     live.turnInFlight = false;
@@ -578,8 +650,9 @@ export class CodexAppServerProvider implements AIProvider {
     live.interruptRequested = false;
     live.discardingTurn = false;
     live.lastTurnInput = undefined;
+    live.steeredInputs = undefined;
     const next = live.pendingTurns.shift();
-    if (next) void this.startTurn(live, next.message, next.opts);
+    if (next) void this.startTurn(live, next.message, next.opts, next.replay);
   }
 
   // ── Usage-limit rotation ──
@@ -691,6 +764,10 @@ export class CodexAppServerProvider implements AIProvider {
     live.turnInFlight = false;
     live.activeTurnId = null;
     live.interruptRequested = false;
+    // What was steered into the refused turn is steered into its replay once that is named.
+    const steered = (live.steeredInputs ?? []).map((q) => ({ ...q, priority: "next" as const, replay: true }));
+    live.steeredInputs = undefined;
+    live.pendingTurns.unshift(...steered);
     if (pending) void this.startTurn(live, pending.message, pending.opts, true);
     else this.endTurn(live);
   }
@@ -880,9 +957,16 @@ export class CodexAppServerProvider implements AIProvider {
   }
 
   private handleNotification(live: LiveSession, notif: JsonRpcNotification): void {
+    // One app-server also streams spawned threads. Resolve ownership before any
+    // turn/account state changes, even if the child's launch card has not arrived.
+    const notificationThreadId = threadIdFromNotification(notif.params);
+    const isChild = !!notificationThreadId && (live.threadId
+      ? notificationThreadId !== live.threadId
+      : live.subagentThreadIds.has(notificationThreadId));
+    const parentToolUseId = isChild ? subagentCardId(notificationThreadId!) : undefined;
     // A quota refusal is an ordinary `error` notification, so it has to be recognised
     // before the mapper turns it into a plain error card in front of the user.
-    if (notif.method === "error" && !live.rotating && !live.discardingTurn) {
+    if (!isChild && notif.method === "error" && !live.rotating && !live.discardingTurn) {
       // Retry notices count too: the headline says only "Reconnecting... N/5", but their
       // details name the 401, and waiting for the final error costs the whole retry loop.
       const authText = codexErrorText(notif.params);
@@ -897,7 +981,7 @@ export class CodexAppServerProvider implements AIProvider {
     // A turn already reported as failed: swallow the rest of it, and let the queue move on
     // only once codex confirms it is over.
     if (live.discardingTurn) {
-      if (notif.method === "turn/completed") {
+      if (!isChild && notif.method === "turn/completed") {
         live.discardingTurn = false;
         live.currentAssistant = "";
         live.currentEvents = [];
@@ -905,26 +989,26 @@ export class CodexAppServerProvider implements AIProvider {
       }
       return;
     }
-    if (notif.method === "turn/completed"
+    if (!isChild && notif.method === "turn/completed"
         && (notif.params as { turn?: { status?: string } })?.turn?.status === "completed" && live.threadId) {
       // An answered turn is proof the login works, whatever was observed before.
       const accountId = getSessionCodexAccount(live.threadId);
       if (accountId) clearCodexAccountAuthFailure(accountId);
     }
-    if (notif.method === "item/agentMessage/delta") {
+    if (!isChild && notif.method === "item/agentMessage/delta") {
       const d = (notif.params as { delta?: string })?.delta;
       if (typeof d === "string") live.currentAssistant += d;
     }
-    if (notif.method === "thread/tokenUsage/updated") {
+    if (!isChild && notif.method === "thread/tokenUsage/updated") {
       const usage = parseTokenUsage(notif.params, live.model);
       if (usage) live.lastUsage = usage;
     }
-    const notificationThreadId = threadIdFromNotification(notif.params);
-    const parentToolUseId = notificationThreadId && live.subagentThreadIds.has(notificationThreadId)
-      ? subagentCardId(notificationThreadId)
-      : undefined;
     const events = mapCodexEvent(notif, live.threadId ?? "");
     for (const ev of events) {
+      // Child lifecycle notifications must never terminate or change the phase
+      // of the root stream. Keep only content and diagnostics under its card.
+      if (isChild && ev.type !== "text" && ev.type !== "thinking"
+          && ev.type !== "tool_use" && ev.type !== "tool_result" && ev.type !== "error") continue;
       // The counts arrive on their own notification just before the turn ends,
       // so `done` is where they become visible to a consumer.
       if (ev.type === "done" && live.lastUsage) {
@@ -934,13 +1018,13 @@ export class CodexAppServerProvider implements AIProvider {
       const nested = parentToolUseId ? { ...ev, parentToolUseId } as ChatEvent : ev;
       live.channel.push(nested);
       // Accumulate tool calls into the turn so getMessages (live) keeps them.
-      if (nested.type === "tool_use" || nested.type === "tool_result") live.currentEvents.push(nested);
+      if ((!isChild || live.turnInFlight) && (nested.type === "tool_use" || nested.type === "tool_result")) live.currentEvents.push(nested);
       if (nested.type === "tool_use" && nested.tool === "Agent" && typeof nested.toolUseId === "string"
           && nested.toolUseId.startsWith("subagent-")) {
         live.subagentThreadIds.add(nested.toolUseId.slice("subagent-".length));
       }
     }
-    if (notif.method === "turn/completed") {
+    if (!isChild && notif.method === "turn/completed") {
       if (live.currentAssistant || live.currentEvents.length) {
         const turnEvents = live.currentEvents.length
           ? [...live.currentEvents, ...(live.currentAssistant ? [{ type: "text", content: live.currentAssistant } as ChatEvent] : [])]
@@ -954,7 +1038,7 @@ export class CodexAppServerProvider implements AIProvider {
       live.currentEvents = [];
       this.endTurn(live);
     }
-    if (notif.method === "turn/started") {
+    if (!isChild && notif.method === "turn/started") {
       // Codex is the authority on whether the thread is busy — take the flag from
       // it rather than only from what this side believes it started.
       live.turnInFlight = true;
@@ -965,7 +1049,7 @@ export class CodexAppServerProvider implements AIProvider {
     // (the thread/compacted notification is deprecated). Surface the compact-summary
     // marker inline so the chat UI offers "load previous conversation". The turn's
     // own turn/completed provides the `done`.
-    if (notif.method === "item/completed" && live.compactRequested
+    if (!isChild && notif.method === "item/completed" && live.compactRequested
         && (notif.params as { item?: { type?: string } })?.item?.type === "contextCompaction") {
       live.compactRequested = false;
       const file = fromCodexSessionsDirs(live.threadId ?? undefined,

package/src/providers/codex-app-server/codex-usage-parser.ts

@@ -1,6 +1,7 @@
 import type { UsageInfo, LimitBucket } from "../provider.interface.ts";
 import type { GetAccountRateLimitsResponse, RateLimitWindow } from "./codex-protocol.ts";
 import { codexPlanLabel } from "../../shared/codex-plan-label.ts";
+import { parseCodexResetCredits } from "../../shared/usage-extra.ts";
 
 /** codex resetsAt is a unix timestamp; tolerate seconds or milliseconds. */
 function toIso(resetsAt: number | null | undefined): string | undefined {
@@ -67,5 +68,8 @@ export function parseCodexUsage(res: GetAccountRateLimitsResponse | null | undef
   });
   const planLabel = codexPlanLabel(snap.planType);
   if (planLabel) out.activeAccountLabel = planLabel;
+  // Free "reset my limits" grants sit beside the windows, not inside them.
+  const resetCredits = parseCodexResetCredits(res);
+  if (resetCredits) out.resetCredits = resetCredits;
   return out;
 }

package/src/server/index.ts

@@ -615,7 +615,13 @@ export async function startServer(options: {
       while (superviseArgs.length > 1 && superviseArgs[superviseArgs.length - 1] === "") superviseArgs.pop();
 
       const bunExe = process.execPath.replace(/\\/g, "\\\\");
-      const logEscaped = logFile.replace(/\\/g, "\\\\");
+      // Never ppm.log itself: `-RedirectStandardOutput` opens its target with
+      // truncate, not append, so every `ppm start` wiped the whole log since the
+      // last rotation — and the handle it holds writes at its own offset, over
+      // lines the supervisor and server append. The supervisor's `log()` and the
+      // descriptor it hands the server already append everything to ppm.log;
+      // this file only catches the supervisor's raw console output.
+      const outLog = logFile.replace(/\.log$/, ".out.log").replace(/\\/g, "\\\\");
       const errLog = logFile.replace(/\.log$/, ".err.log").replace(/\\/g, "\\\\");
       const winArgs = isCompiledBin ? superviseArgs : ["run", supervisorScript, ...superviseArgs];
       const argStr = winArgs.map((a) => `'${a || "_"}'`).join(",");
@@ -623,7 +629,7 @@ export async function startServer(options: {
         `$p = Start-Process -PassThru -WindowStyle Hidden`,
         `-FilePath '${bunExe}'`,
         `-ArgumentList ${argStr}`,
-        `-RedirectStandardOutput '${logEscaped}'`,
+        `-RedirectStandardOutput '${outLog}'`,
         `-RedirectStandardError '${errLog}'`,
         `; Write-Output $p.Id`,
       ].join(" ");

package/src/server/routes/chat.ts

@@ -158,6 +158,7 @@ chatRoutes.get("/usage", async (c) => {
     weekly: usage.weekly,
     weeklyOpus: usage.weeklyOpus,
     weeklySonnet: usage.weeklySonnet,
+    weeklyScoped: usage.weeklyScoped,
     totalCostUsd: usage.totalCostUsd,
     activeAccountId: usage.activeAccountId,
     activeAccountLabel: usage.activeAccountLabel,

package/src/server/ws/chat.ts

@@ -376,7 +376,7 @@ function bufferAndBroadcast(sessionId: string, event: unknown): void {
 }
 
 /**
- * Emit a nested-agent child read off disk. Buffered for reconnect replay only
+ * Emit a nested-agent child from the provider or disk. Buffered for reconnect replay only
  * while its turn is still in flight and under the nested budget; a background
  * agent that outlives the turn streams its children unbuffered, since the next
  * turn's replay is not the place for them and reload restores them from disk.
@@ -633,6 +633,20 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
       const ev = event as any;
       const evType = ev.type ?? "unknown";
 
+      // Child streams can outlive the root turn. Their content and terminal
+      // events belong to the Agent card, never to the root turn's lifecycle.
+      if (ev.parentToolUseId) {
+        emitNestedChild(sessionId, event);
+        continue;
+      }
+      // Codex's synthetic Agent card result has no parentToolUseId. A late
+      // completion still updates connected cards, but cannot start a root turn
+      // or create replay that would replace the completed assistant history.
+      if (evType === "tool_result" && ev.toolUseId?.startsWith("subagent-") && entry.phase === "idle") {
+        broadcast(sessionId, event);
+        continue;
+      }
+
       // System events → transition connecting → thinking, forward compact events
       if (evType === "system") {
         const sub = (ev as any).subtype;
@@ -929,6 +943,7 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
       // Consumer loop continues — query waits for next message in generator
       if (evType === "done") {
         entry.turnEvents = [];
+        entry.nestedBuffered = 0;
         entry.pendingApprovalEvent = undefined;
         // Clear stale compact status if turn ended without compact_boundary.
         // SDK may emit `status: compacting` without a matching boundary (deferred,

package/src/services/claude-usage.service.ts

@@ -15,6 +15,8 @@ import { startProviderUsagePolling, stopProviderUsagePolling, sweepUsageSource }
 import { refreshUsage as refreshProviderUsage } from "./provider-usage/usage-registry.ts";
 import { claudeUsageSource } from "./claude-usage-source.ts";
 import { resetUsageRuntimeState } from "./provider-usage/index.ts";
+import { deserializeUsageExtra, parseClaudeScopedLimits, scopedBucket } from "../shared/usage-extra.ts";
+import type { ScopedLimitBucket } from "../types/chat.ts";
 
 export interface LimitBucket {
   utilization: number;
@@ -30,6 +32,8 @@ export interface ClaudeUsage {
   weekly?: LimitBucket;
   weeklyOpus?: LimitBucket;
   weeklySonnet?: LimitBucket;
+  /** Per-model weekly limits ("Fable", …) — see `shared/usage-extra.ts`. */
+  weeklyScoped?: ScopedLimitBucket[];
   totalCostUsd?: number;
 }
 
@@ -93,6 +97,8 @@ function snapshotToUsage(row: LimitSnapshotRow): ClaudeUsage {
   if (row.weekly_util != null) result.weekly = dbBucketToLimitBucket(row.weekly_util, row.weekly_resets_at ?? "", 168);
   if (row.weekly_opus_util != null) result.weeklyOpus = dbBucketToLimitBucket(row.weekly_opus_util, row.weekly_opus_resets_at ?? "", 168);
   if (row.weekly_sonnet_util != null) result.weeklySonnet = dbBucketToLimitBucket(row.weekly_sonnet_util, row.weekly_sonnet_resets_at ?? "", 168);
+  const { weeklyScoped } = deserializeUsageExtra(row.extra_json);
+  if (weeklyScoped) result.weeklyScoped = weeklyScoped;
   return result;
 }
 
@@ -124,6 +130,13 @@ async function fetchUsageForToken(token: string): Promise<ClaudeUsage> {
   if (raw.seven_day) data.weekly = parseApiBucket(raw.seven_day, 168);
   if (raw.seven_day_opus) data.weeklyOpus = parseApiBucket(raw.seven_day_opus, 168);
   if (raw.seven_day_sonnet) data.weeklySonnet = parseApiBucket(raw.seven_day_sonnet, 168);
+  // A model with its own weekly cap (Fable) is reported only in `limits[]`. When the legacy
+  // opus/sonnet key is also present for the same model, keep the legacy bar and skip the
+  // duplicate rather than showing one limit twice.
+  const scoped = parseClaudeScopedLimits(raw)
+    .filter((s) => !(data.weeklyOpus && /^opus\b/i.test(s.label)) && !(data.weeklySonnet && /^sonnet\b/i.test(s.label)))
+    .map(scopedBucket);
+  if (scoped.length) data.weeklyScoped = scoped;
   return data;
 }
 

package/src/services/db.service.ts

@@ -8,7 +8,7 @@ import { backupDbSync } from "./db-backup/db-backup-sync.ts";
 import { CODEX_DEFAULT_MODEL } from "../types/config.ts";
 // Must equal the last `PRAGMA user_version` below: the pre-migration snapshot is skipped for
 // any database already at this version, so a stale value silently drops that backup.
-export const CURRENT_SCHEMA_VERSION = 50;
+export const CURRENT_SCHEMA_VERSION = 51;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -1147,6 +1147,14 @@ export function runMigrations(database: Database): void {
     try { database.exec("ALTER TABLE session_metadata ADD COLUMN permission_mode TEXT"); } catch { /* exists */ }
     database.exec(`PRAGMA user_version = 50;`);
   }
+
+  if (current < 51) {
+    // Usage details that have no fixed column: Claude's per-model weekly limits (Fable and
+    // whatever comes next arrive as `limits[]` entries, not as `seven_day_<model>` keys) and
+    // Codex's free rate-limit reset credits. JSON so a new model needs no migration of its own.
+    try { database.exec("ALTER TABLE claude_limit_snapshots ADD COLUMN extra_json TEXT"); } catch { /* exists */ }
+    database.exec(`PRAGMA user_version = 51;`);
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -1850,6 +1858,8 @@ export interface LimitSnapshotRow {
   weekly_opus_resets_at: string | null;
   weekly_sonnet_util: number | null;
   weekly_sonnet_resets_at: string | null;
+  /** JSON {@link import("../shared/usage-extra.ts").UsageExtra}: per-model weekly limits, reset credits. */
+  extra_json?: string | null;
   recorded_at: string;
 }
 
@@ -1859,8 +1869,8 @@ export function insertLimitSnapshot(
   getDb().query(
     `INSERT INTO claude_limit_snapshots
       (provider, account_id, five_hour_util, five_hour_resets_at, weekly_util, weekly_resets_at,
-       weekly_opus_util, weekly_opus_resets_at, weekly_sonnet_util, weekly_sonnet_resets_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+       weekly_opus_util, weekly_opus_resets_at, weekly_sonnet_util, weekly_sonnet_resets_at, extra_json)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
   ).run(
     data.provider ?? DEFAULT_USAGE_PROVIDER,
     data.account_id ?? null,
@@ -1868,6 +1878,7 @@ export function insertLimitSnapshot(
     data.weekly_util ?? null, data.weekly_resets_at ?? null,
     data.weekly_opus_util ?? null, data.weekly_opus_resets_at ?? null,
     data.weekly_sonnet_util ?? null, data.weekly_sonnet_resets_at ?? null,
+    data.extra_json ?? null,
   );
 }
 

package/src/services/provider-usage/usage-snapshot-store.ts

@@ -8,6 +8,7 @@ import {
   type LimitSnapshotRow,
 } from "../db.service.ts";
 import { AMBIENT_ACCOUNT_KEY } from "./usage-source.ts";
+import { deserializeUsageExtra, serializeUsageExtra, usageExtraSignature } from "../../shared/usage-extra.ts";
 
 /**
  * The durable half of the usage layer: turning a provider's `UsageInfo` into a
@@ -58,7 +59,7 @@ export function snapshotToUsage(row: LimitSnapshotRow): UsageInfo & { lastFetche
   if (row.weekly_sonnet_util != null) {
     usage.weeklySonnet = toBucket(row.weekly_sonnet_util, row.weekly_sonnet_resets_at ?? "", 168);
   }
-  return usage;
+  return { ...usage, ...deserializeUsageExtra(row.extra_json) };
 }
 
 /** Read the newest stored snapshot for one provider account, or undefined. */
@@ -89,6 +90,7 @@ function hasChanged(usage: UsageInfo, last: LimitSnapshotRow | null): boolean {
   if (moved(usage.weeklySonnet?.utilization, last.weekly_sonnet_util)) return true;
   if (usage.session?.resetsAt && usage.session.resetsAt !== (last.five_hour_resets_at ?? "")) return true;
   if (usage.weekly?.resetsAt && usage.weekly.resetsAt !== (last.weekly_resets_at ?? "")) return true;
+  if (usageExtraSignature(serializeUsageExtra(usage)) !== usageExtraSignature(last.extra_json)) return true;
   return false;
 }
 
@@ -101,7 +103,8 @@ function hasChanged(usage: UsageInfo, last: LimitSnapshotRow | null): boolean {
  */
 export function writeStoredUsage(providerId: string, accountId: string, usage: UsageInfo): void {
   const hasAnyBucket = usage.session != null || usage.weekly != null
-    || usage.weeklyOpus != null || usage.weeklySonnet != null;
+    || usage.weeklyOpus != null || usage.weeklySonnet != null
+    || !!usage.weeklyScoped?.length || usage.resetCredits != null;
   if (!hasAnyBucket) return;
 
   const id = accountId === AMBIENT_ACCOUNT_KEY ? null : accountId;
@@ -121,6 +124,7 @@ export function writeStoredUsage(providerId: string, accountId: string, usage: U
     weekly_opus_resets_at: usage.weeklyOpus?.resetsAt ?? null,
     weekly_sonnet_util: usage.weeklySonnet?.utilization ?? null,
     weekly_sonnet_resets_at: usage.weeklySonnet?.resetsAt ?? null,
+    extra_json: serializeUsageExtra(usage),
   });
   cleanupOldLimitSnapshots();
 }

package/src/shared/usage-extra.ts

@@ -0,0 +1,123 @@
+/**
+ * Usage details that have no fixed column: parsed from the provider's payload, stored as
+ * one JSON column on the limit snapshot, and read back into `UsageInfo`.
+ *
+ * Two things live here today, and both would otherwise vanish whenever usage is served from
+ * the stored snapshot rather than a live fetch:
+ *
+ * - Claude's per-model weekly limits. Anthropic stopped filling `seven_day_opus` /
+ *   `seven_day_sonnet` (both null now) and reports a model's own weekly cap as a
+ *   `limits[]` entry of kind `weekly_scoped` with the model's display name — that is how
+ *   "Fable" arrives. Read by name, so the next model shows up without a code change.
+ * - Codex's free rate-limit reset credits (`rateLimitResetCredits`), which say how many
+ *   "reset my limits" grants the account still holds and when they lapse.
+ *
+ * Pure and dependency-free so both the server and the browser can use it.
+ */
+import type { ResetCredits, ScopedLimitBucket } from "../types/chat.ts";
+
+/** A per-model limit as stored: no countdown fields, those are recomputed on read. */
+export interface StoredScopedLimit {
+  label: string;
+  utilization: number;
+  resetsAt: string;
+}
+
+export interface UsageExtra {
+  scoped?: StoredScopedLimit[];
+  resetCredits?: ResetCredits;
+}
+
+const WEEK_HOURS = 168;
+
+/** Recompute a weekly bucket's countdown against the current clock. */
+export function scopedBucket(s: StoredScopedLimit): ScopedLimitBucket {
+  const diff = s.resetsAt ? new Date(s.resetsAt).getTime() - Date.now() : 0;
+  const totalMins = diff > 0 ? Math.ceil(diff / 60_000) : 0;
+  return {
+    label: s.label,
+    utilization: s.utilization,
+    resetsAt: s.resetsAt,
+    resetsInMinutes: null,
+    resetsInHours: Math.round((totalMins / 60) * 100) / 100,
+    windowHours: WEEK_HOURS,
+  };
+}
+
+/**
+ * Claude `limits[]` → per-model weekly limits.
+ *
+ * `percent` is 0–100 like the rest of that payload; stored as a 0–1 fraction like every other
+ * bucket. Entries without a model name are skipped: an unlabelled row would read as a second
+ * "Weekly" bar that disagrees with the real one.
+ */
+export function parseClaudeScopedLimits(raw: unknown): StoredScopedLimit[] {
+  const limits = (raw as { limits?: unknown })?.limits;
+  if (!Array.isArray(limits)) return [];
+  const out: StoredScopedLimit[] = [];
+  for (const l of limits as Array<Record<string, any>>) {
+    if (l?.kind !== "weekly_scoped") continue;
+    const label = l?.scope?.model?.display_name;
+    if (typeof label !== "string" || !label.trim() || typeof l.percent !== "number") continue;
+    out.push({ label: label.trim(), utilization: l.percent / 100, resetsAt: typeof l.resets_at === "string" ? l.resets_at : "" });
+  }
+  return out;
+}
+
+/**
+ * Codex `rateLimitResetCredits` → how many free resets are left and when the next lapses.
+ *
+ * Only credits Codex marks `available` count; a used or expired one is history. Returns
+ * undefined when the payload has no credits block at all, so "none reported" and "0 left"
+ * stay distinguishable.
+ */
+export function parseCodexResetCredits(raw: unknown): ResetCredits | undefined {
+  const block = (raw as { rateLimitResetCredits?: unknown })?.rateLimitResetCredits as
+    { credits?: Array<Record<string, any>> } | null | undefined;
+  if (!block || !Array.isArray(block.credits)) return undefined;
+  const available = block.credits
+    .filter((c) => c?.status === "available")
+    .filter((c) => typeof c.expiresAt !== "number" || c.expiresAt * 1000 > Date.now())
+    .sort((a, b) => (a.expiresAt ?? Infinity) - (b.expiresAt ?? Infinity));
+  const next = available[0];
+  return {
+    available: available.length,
+    ...(typeof next?.expiresAt === "number" ? { nextExpiresAt: new Date(next.expiresAt * 1000).toISOString() } : {}),
+    ...(typeof next?.title === "string" ? { title: next.title } : {}),
+  };
+}
+
+/** The extra fields of a `UsageInfo`, as the JSON column holds them — null when there are none. */
+export function serializeUsageExtra(u: { weeklyScoped?: ScopedLimitBucket[]; resetCredits?: ResetCredits }): string | null {
+  const extra: UsageExtra = {};
+  if (u.weeklyScoped?.length) {
+    extra.scoped = u.weeklyScoped.map((b) => ({ label: b.label, utilization: b.utilization, resetsAt: b.resetsAt }));
+  }
+  if (u.resetCredits) extra.resetCredits = u.resetCredits;
+  return extra.scoped || extra.resetCredits ? JSON.stringify(extra) : null;
+}
+
+/** The JSON column back into `UsageInfo` fields. Malformed JSON reads as nothing, not a throw. */
+export function deserializeUsageExtra(json: string | null | undefined): { weeklyScoped?: ScopedLimitBucket[]; resetCredits?: ResetCredits } {
+  if (!json) return {};
+  let extra: UsageExtra;
+  try { extra = JSON.parse(json) as UsageExtra; } catch { return {}; }
+  return {
+    ...(extra.scoped?.length ? { weeklyScoped: extra.scoped.map(scopedBucket) } : {}),
+    ...(extra.resetCredits ? { resetCredits: extra.resetCredits } : {}),
+  };
+}
+
+/**
+ * What counts as a change worth a new snapshot row.
+ *
+ * Reset timestamps are left out on purpose: Claude's carry microseconds that differ on every
+ * call ("08:59:59.720048" then "09:00:00.363882"), so comparing them would write a row per
+ * sweep. A utilization moving or a credit being granted/used is what matters.
+ */
+export function usageExtraSignature(json: string | null | undefined): string {
+  const e = deserializeUsageExtra(json);
+  const scoped = (e.weeklyScoped ?? []).map((b) => `${b.label}:${b.utilization.toFixed(3)}`).sort().join(",");
+  const credits = e.resetCredits ? `${e.resetCredits.available}@${e.resetCredits.nextExpiresAt ?? ""}` : "";
+  return `${scoped}|${credits}`;
+}

package/src/types/chat.ts

@@ -209,10 +209,29 @@ export interface UsageInfo {
   weekly?: LimitBucket;
   weeklyOpus?: LimitBucket;
   weeklySonnet?: LimitBucket;
+  /** Claude's per-model weekly limits ("Fable", …), labelled by model. */
+  weeklyScoped?: ScopedLimitBucket[];
+  /** Codex's free rate-limit resets still available to this account. */
+  resetCredits?: ResetCredits;
   activeAccountId?: string;
   activeAccountLabel?: string;
 }
 
+/** A weekly limit that applies to one model only, named as the provider names it. */
+export interface ScopedLimitBucket extends LimitBucket {
+  label: string;
+}
+
+/** Free "reset my rate limits" credits Codex grants an account. */
+export interface ResetCredits {
+  /** How many can still be used. */
+  available: number;
+  /** ISO time the soonest-expiring one lapses, if any is available. */
+  nextExpiresAt?: string;
+  /** What the soonest one resets, as Codex words it ("Full reset (Weekly + 5 hr)"). */
+  title?: string;
+}
+
 /** Result subtype from SDK ResultMessage */
 export type ResultSubtype =
   | "success"